chore: move to new organization

As per https://golang.org/cmd/go/#hdr-Build_constraints,
using GOOS=android also matches tags and files for GOOS=linux,
so exclude it explicetly to avoid collisions.

Also using GOOS=illumos matches tags and files for GOOS=solaris.

Fixes #843.

.golangci.toml

@@ -41,6 +41,8 @@
     "testpackage",
     "goerr113",
     "nestif",
+    "exhaustive",
+    "nlreturn",
   ]
 
 [issues]

.goreleaser.yml

@@ -3,7 +3,7 @@ project_name: yaegi
 builds:
   - id: yaegi
     binary: yaegi
-    main: ./cmd/yaegi/yaegi.go
+    main: ./cmd/yaegi/
 
     goos:
       - darwin
@@ -28,7 +28,7 @@ builds:
 
   - id: goexports
     binary: goexports
-    main: ./cmd/goexports/goexports.go
+    main: ./cmd/goexports/
 
     goos:
       - darwin

.travis.yml

@@ -19,15 +19,15 @@ cache:
 matrix:
   fast_finish: true
   include:
-    - go: 1.13.x
     - go: 1.14.x
+    - go: 1.15.x
       env: STABLE=true
 
 env:
   global:
     - GO111MODULE=on
 
-go_import_path: github.com/containous/yaegi
+go_import_path: github.com/traefik/yaegi
 
 before_install:
   # Install linters and misspell

CONTRIBUTING.md

@@ -3,7 +3,7 @@
 Yaegi is an open source project, and your feedback and contributions
 are needed and always welcome.
 
-[Issues] and [Pull Requests] are opened at https://github.com/containous/yaegi.
+[Issues] and [Pull Requests] are opened at https://github.com/traefik/yaegi.
 
 Non trivial changes should be discussed with the project maintainers by
 opening a [Feature Request] clearly explaining rationale, background
@@ -13,12 +13,12 @@ discussions.
 Once the proposal is approved, a Pull Request can be opened. If you want
 to provide early visibility to reviewers, create a [Draft Pull Request].
 
-We will also require you to sign the [Containous Contributor License Agreement]
+We will also require you to sign the [Traefik Contributor License Agreement]
 after you submit your first pull request to this project. The link to sign the
 agreement will be presented to you in the web interface of the pull request.
 
-[Issues]: https://github.com/containous/yaegi/issues
-[Pull Requests]: https://github.com/containous/yaegi/issues
-[Feature Request]: https://github.com/containous/yaegi/issues/new?template=feature_request.md
+[Issues]: https://github.com/traefik/yaegi/issues
+[Pull Requests]: https://github.com/traefik/yaegi/issues
+[Feature Request]: https://github.com/traefik/yaegi/issues/new?template=feature_request.md
 [Draft Pull Request]: https://github.blog/2019-02-14-introducing-draft-pull-requests/
-[Containous Contributor License Agreement]: https://cla-assistant.io/containous/yaegi
+[Traefik Labs Contributor License Agreement]: https://cla-assistant.io/traefik/yaegi

LICENSE

@@ -187,6 +187,7 @@
       identification within third-party archives.
 
    Copyright 2019 Containous SAS
+   Copyright 2020 Traefik Labs SAS
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -2,9 +2,9 @@
 <img width="400" src="doc/images/yaegi.png" alt="Yaegi" title="Yaegi" />
 </p>
 
-[![release](https://img.shields.io/github/tag-date/containous/yaegi.svg?label=alpha)](https://github.com/containous/yaegi/releases)
-[![Build Status](https://travis-ci.com/containous/yaegi.svg?branch=master)](https://travis-ci.com/containous/yaegi)
-[![GoDoc](https://godoc.org/github.com/containous/yaegi?status.svg)](https://godoc.org/github.com/containous/yaegi)
+[![release](https://img.shields.io/github/tag-date/traefik/yaegi.svg?label=alpha)](https://github.com/traefik/yaegi/releases)
+[![Build Status](https://travis-ci.com/traefik/yaegi.svg?branch=master)](https://travis-ci.com/traefik/yaegi)
+[![GoDoc](https://godoc.org/github.com/traefik/yaegi?status.svg)](https://godoc.org/github.com/traefik/yaegi)
 [![Discourse status](https://img.shields.io/discourse/https/community.containo.us/status?label=Community&style=social)](https://community.containo.us/c/yaegi)
 
 Yaegi is Another Elegant Go Interpreter.
@@ -25,13 +25,13 @@ It powers executable Go scripts and plugins, in embedded interpreters or interac
 ### Go package
 
 ```go
-import "github.com/containous/yaegi/interp"
+import "github.com/traefik/yaegi/interp"
 ```
 
 ### Command-line executable
 
 ```bash
-go get -u github.com/containous/yaegi/cmd/yaegi
+go get -u github.com/traefik/yaegi/cmd/yaegi
 ```
 
 Note that you can use [rlwrap](https://github.com/hanslub42/rlwrap) (install with your favorite package manager),
@@ -47,8 +47,8 @@ Create an interpreter with `New()`, run Go code with `Eval()`:
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
 )
 
 func main() {
@@ -81,7 +81,7 @@ The following program is compiled ahead of time, except `bar()` which is interpr
 ```go
 package main
 
-import "github.com/containous/yaegi/interp"
+import "github.com/traefik/yaegi/interp"
 
 const src = `package foo
 func Bar(s string) string { return s + "-Foo" }`
@@ -155,11 +155,11 @@ Documentation about Yaegi commands and libraries can be found at usual [godoc.or
 
 Beside the known [bugs] which are supposed to be fixed in the short term, there are some limitations not planned to be addressed soon:
 
-- assembly files (`.s`) are not supported
-- calling C code is not supported (no virtual "C" package)
-- interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers
-- representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode
-- interpreting computation intensive code is likely to remain significantly slower than in compiled mode
+- Assembly files (`.s`) are not supported.
+- Calling C code is not supported (no virtual "C" package).
+- Interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers.
+- Representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode.
+- Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.
 
 ## Contributing
 
@@ -170,7 +170,7 @@ Beside the known [bugs] which are supposed to be fixed in the short term, there
 [Apache 2.0][License].
 
 [specs]: https://golang.org/ref/spec
-[docs]: https://godoc.org/github.com/containous/yaegi
-[license]: https://github.com/containous/yaegi/blob/master/LICENSE
-[github]: https://github.com/containous/yaegi
-[bugs]: https://github.com/containous/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug
+[docs]: https://godoc.org/github.com/traefik/yaegi
+[license]: https://github.com/traefik/yaegi/blob/master/LICENSE
+[github]: https://github.com/traefik/yaegi
+[bugs]: https://github.com/traefik/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug

_test/a42.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+func main() {
+	var b [8]byte
+	binary.LittleEndian.PutUint64(b[:], uint64(1))
+
+	fmt.Println(b)
+}
+
+// Output:
+// [1 0 0 0 0 0 0 0]

_test/addr0.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type extendedRequest struct {
+	http.Request
+
+	Data string
+}
+
+func main() {
+	r := extendedRequest{}
+	req := &r.Request
+
+
+	fmt.Println(r)
+	fmt.Println(req)
+}
+
+// Output:
+// {{ <nil>  0 0 map[] <nil> <nil> 0 [] false  map[] map[] <nil> map[]   <nil> <nil> <nil> <nil>} }
+// &{ <nil>  0 0 map[] <nil> <nil> 0 [] false  map[] map[] <nil> map[]   <nil> <nil> <nil> <nil>}

_test/b1/foo/foo.go

@@ -1,6 +1,6 @@
 package foo
 
-import bar "github.com/containous/yaegi/_test/b2/foo"
+import bar "github.com/traefik/yaegi/_test/b2/foo"
 
 var Desc = "in b1/foo"
 

_test/c1/c1.go

@@ -1,5 +1,5 @@
 package c1
 
-import "github.com/containous/yaegi/_test/c2"
+import "github.com/traefik/yaegi/_test/c2"
 
 var C1 = c2.C2 + "x"

_test/c2/c2.go

@@ -1,5 +1,5 @@
 package c2
 
-import "github.com/containous/yaegi/_test/c1"
+import "github.com/traefik/yaegi/_test/c1"
 
 var C2 = c1.C1 + "Y"

_test/cli4.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	m.next.ServeHTTP(rw, rq)
+}
+
+type mw0 struct{}
+
+func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Welcome to my website!")
+}
+
+func main() {
+	m0 := &mw0{}
+	m1 := &mw1{m0}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!

_test/cli5.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	m.next.ServeHTTP(rw, rq)
+}
+
+type mw0 struct{}
+
+func (m *mw0) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "Welcome to my website!")
+}
+
+func main() {
+	m0 := &mw0{}
+	m1 := &mw1{next: m0}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!

_test/cli6.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type T struct {
+	http.ResponseWriter
+}
+
+type mw1 struct {
+	next http.Handler
+}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	t := &T{
+		ResponseWriter: rw,
+	}
+	x := t.Header()
+	fmt.Fprint(rw, "Welcome to my website!", x)
+}
+
+func main() {
+	m1 := &mw1{}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", m1.ServeHTTP)
+
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client(server.URL)
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!map[]

_test/comp2.go

@@ -0,0 +1,14 @@
+package main
+
+type delta int32
+
+func main() {
+	a := delta(-1)
+
+	println(a != -1)
+	println(a == -1)
+}
+
+// Output:
+// false
+// true

_test/composite11.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"image/color"
+)
+
+func main() {
+	c := color.NRGBA64{1, 1, 1, 1}
+
+	fmt.Println(c)
+}
+
+// Output:
+// {1 1 1 1}

_test/composite6.go

@@ -3,7 +3,7 @@ package main
 import (
 	"fmt"
 
-	"github.com/containous/yaegi/_test/ct1"
+	"github.com/traefik/yaegi/_test/ct1"
 )
 
 type T struct {

_test/const15.go

@@ -0,0 +1,17 @@
+package main
+
+type T1 t1
+
+type t1 int8
+
+const (
+	P2 T1 = 2
+	P3 T1 = 3
+)
+
+func main() {
+	println(P3)
+}
+
+// Output:
+// 3

_test/eval0.go

@@ -2,13 +2,14 @@ package main
 
 import (
 	"log"
+	"os"
 
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	log.SetFlags(log.Lshortfile)
-	i := interp.New(interp.Options{})
+	i := interp.New(interp.Options{Stdout: os.Stdout})
 	if _, err := i.Eval(`func f() (int, int) { return 1, 2 }`); err != nil {
 		log.Fatal(err)
 	}

_test/foo/bar.go

@@ -1,6 +1,6 @@
 package foo
 
-import "github.com/containous/yaegi/_test/foo/boo"
+import "github.com/traefik/yaegi/_test/foo/boo"
 
 var Bar = "BARR"
 var Boo = boo.Boo

_test/foo/bir.go

@@ -1,5 +1,5 @@
 package foo
 
-import "github.com/containous/yaegi/_test/foo/boo"
+import "github.com/traefik/yaegi/_test/foo/boo"
 
 var Bir = boo.Boo + "22"

_test/import3.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/foo"
+import "github.com/traefik/yaegi/_test/foo"
 
 func main() { println(foo.Bar, foo.Boo) }
 

_test/import4.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/p1"
+import "github.com/traefik/yaegi/_test/p1"
 
 func main() { println("num:", p1.Uint32()) }
 

_test/import5.go

@@ -1,6 +1,6 @@
 package main
 
-import boo "github.com/containous/yaegi/_test/foo"
+import boo "github.com/traefik/yaegi/_test/foo"
 
 func main() { println(boo.Bar, boo.Boo, boo.Bir) }
 

_test/import6.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/c1"
+import "github.com/traefik/yaegi/_test/c1"
 
 func main() {
 	println(c1.C1)
@@ -8,4 +8,4 @@ func main() {
 
 // Error:
 // import cycle not allowed
-//	imports github.com/containous/yaegi/_test/c1
+//	imports github.com/traefik/yaegi/_test/c1

_test/import7.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/foo-bar"
+import bar "github.com/traefik/yaegi/_test/foo-bar"
 
 func main() {
 	println(bar.Name)

_test/import8.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/b1/foo"
+import "github.com/traefik/yaegi/_test/b1/foo"
 
 func main() {
 	println(foo.Desc)

_test/import9.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/containous/yaegi/_test/baz-bat"
+import "github.com/traefik/yaegi/_test/baz-bat"
 
 func main() {
 	println(baz.Name)

_test/inception.go

@@ -3,14 +3,14 @@ package main
 import (
 	"log"
 
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	log.SetFlags(log.Lshortfile)
 	i := interp.New(interp.Options{})
 	i.Use(interp.Symbols)
-	if _, err := i.Eval(`import "github.com/containous/yaegi/interp"`); err != nil {
+	if _, err := i.Eval(`import "github.com/traefik/yaegi/interp"`); err != nil {
 		log.Fatal(err)
 	}
 	if _, err := i.Eval(`i := interp.New(interp.Options{})`); err != nil {
@@ -20,6 +20,3 @@ func main() {
 		log.Fatal(err)
 	}
 }
-
-// Output:
-// 42

_test/init1.go

@@ -0,0 +1,12 @@
+package main
+
+func init() {
+	println("here")
+}
+
+func main() {
+	init()
+}
+
+// Error:
+// _test/init1.go:8:2: undefined: init

_test/interface44.go

@@ -0,0 +1,19 @@
+package main
+
+type S struct {
+	a int
+}
+
+func main() {
+	var i interface{} = S{a: 1}
+
+	s, ok := i.(S)
+	if !ok {
+		println("bad")
+		return
+	}
+	println(s.a)
+}
+
+// Output:
+// 1

_test/interface45.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	var i interface{} = 1
+	var s struct{}
+	s, _ = i.(struct{})
+	fmt.Println(s)
+}
+
+// Output:
+// {}

_test/interface46.go

@@ -0,0 +1,35 @@
+package main
+
+import "fmt"
+
+type I interface {
+	Foo() string
+}
+
+type Printer struct {
+	i I
+}
+
+func New(i I) *Printer {
+	return &Printer{
+		i: i,
+	}
+}
+
+func (p *Printer) Print() {
+	fmt.Println(p.i.Foo())
+}
+
+type T struct{}
+
+func (t *T) Foo() string {
+	return "test"
+}
+
+func main() {
+	g := New(&T{})
+	g.Print()
+}
+
+// Output:
+// test

_test/interp.gi

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {

_test/interp2.gi

@@ -1,13 +1,13 @@
 package main
 
 import (
-	"github.com/containous/yaegi/interp"
+	"github.com/traefik/yaegi/interp"
 )
 
 func main() {
 	i := interp.New(interp.Opt{})
 	i.Use(interp.ExportValue, interp.ExportType)
-	i.Eval(`import "github.com/containous/yaegi/interp"`)
+	i.Eval(`import "github.com/traefik/yaegi/interp"`)
 	i.Eval(`i := interp.New(interp.Opt{})`)
 	i.Eval(`i.Eval("println(42)")`)
 }

_test/ipp_as_key.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"guthib.com/toto" // pkg name is actually titi
+	"guthib.com/tata" // pkg name is actually tutu
+)
+
+func main() {
+	println("Hello", titi.Quux())
+	println("Hello", tutu.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar
+// Hello baz

_test/issue-770.go

@@ -0,0 +1,25 @@
+package main
+
+import "reflect"
+
+type I interface {
+	Foo() int
+}
+
+type T struct {
+	Name string
+}
+
+func (t T) Foo() int { return 0 }
+
+func f(v reflect.Value) int {
+	i := v.Interface().(I)
+	return i.Foo()
+}
+
+func main() {
+	println("hello")
+}
+
+// Output:
+// hello

_test/issue-772.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"log"
+	"os"
+	"text/template"
+)
+
+type Message struct {
+	Data string
+}
+
+func main() {
+	tmpl := template.New("name")
+
+	_, err := tmpl.Parse("{{.Data}}")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = tmpl.Execute(os.Stdout, Message{
+		Data: "Hello, World!!",
+	})
+
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+// Output:
+// Hello, World!!

_test/issue-775.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"net/http/httptest"
+)
+
+func main() {
+	recorder := httptest.NewRecorder()
+	recorder.Header().Add("Foo", "Bar")
+
+	for key, value := range recorder.Header() {
+		fmt.Println(key, value)
+	}
+}
+
+// Output:
+// Foo [Bar]

_test/issue-776.go

@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// Filter is a filter
+type Filter interface {
+	Foo()
+}
+
+// GIFT is a gift
+type GIFT struct {
+	Filters []Filter
+}
+
+// New is a new filter list
+func New(filters ...Filter) *GIFT {
+	return &GIFT{
+		Filters: filters,
+	}
+}
+
+// List lists filters
+func (g *GIFT) List() {
+	fmt.Printf("Hello from List!\n")
+}
+
+// MyFilter is one of the filters
+type MyFilter struct{}
+
+// Foo is a foo
+func (f *MyFilter) Foo() {}
+
+func main() {
+	g := New(&MyFilter{})
+	g.List()
+}
+
+// Output:
+// Hello from List!

_test/issue-782.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	from := uint32(2)
+	to := uint32(4)
+	b := a[from:to]
+	fmt.Print(b)
+}
+
+// Output:
+// [3 4]

_test/issue-784.go

@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// Filter is a filter interface
+type Filter interface {
+	Bounds(srcBounds string) (dstBounds string)
+}
+
+// GIFT type
+type GIFT struct {
+	Filters []Filter
+}
+
+// New creates a new filter list and initializes it with the given slice of filters.
+func New(filters ...Filter) *GIFT {
+	return &GIFT{
+		Filters: filters,
+	}
+}
+
+// Bounds calculates the appropriate bounds for the result image after applying all the added filters.
+func (g *GIFT) Bounds(srcBounds string) (dstBounds string) {
+	dstBounds = srcBounds
+	for _, f := range g.Filters {
+		dstBounds = f.Bounds(dstBounds)
+	}
+	return dstBounds
+}
+
+func main() {
+	var filters []Filter
+	bounds := "foo"
+	g := New(filters...)
+	fmt.Println(g.Bounds(bounds))
+}
+
+// Output:
+// foo

_test/m1/main.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func main() {
+	fmt.Println("vim-go")
+}
+
+func TestWeird(t *testing.T) {
+	fmt.Println("in TestWeird")
+}

_test/m1/main_test.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+)
+
+func TestMain(t *testing.T) {
+	fmt.Println("in test")
+}
+
+func BenchmarkMain(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		rand.Int()
+	}
+}

_test/math2.go

@@ -0,0 +1,12 @@
+package main
+
+const c uint64 = 2
+
+func main() {
+	if c&(1<<(uint64(1))) > 0 {
+		println("yes")
+	}
+}
+
+// Output:
+// yes

_test/math3.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"crypto/md5"
+	"fmt"
+)
+
+func md5Crypt(password, salt, magic []byte) []byte {
+	d := md5.New()
+	d.Write(password)
+	d.Write(magic)
+	d.Write(salt)
+
+	d2 := md5.New()
+	d2.Write(password)
+	d2.Write(salt)
+
+	for i, mixin := 0, d2.Sum(nil); i < len(password); i++ {
+		d.Write([]byte{mixin[i%16]})
+	}
+
+	return d.Sum(nil)
+}
+
+func main() {
+	b := md5Crypt([]byte("1"), []byte("2"), []byte("3"))
+
+	fmt.Println(b)
+}
+
+// Output:
+// [187 141 73 89 101 229 33 106 226 63 117 234 117 149 230 21]

_test/method35.go

@@ -0,0 +1,14 @@
+package main
+
+import "strconv"
+
+func main() {
+	var err error
+	_, err = strconv.Atoi("erwer")
+	if _, ok := err.(*strconv.NumError); ok {
+		println("here")
+	}
+}
+
+// Output:
+// here

_test/op1.go

@@ -7,4 +7,4 @@ func main() {
 }
 
 // Error:
-// 5:2: illegal operand types for '+=' operator
+// 5:2: invalid operation: mismatched types int and float64

_test/pkgname0.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+	baz "guthib.com/baz" // pkg name is also quux, force it to baz.
+)
+
+func main() {
+	println("Hello", quux.Quux())
+	println("Hello", baz.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar
+// Hello baz

_test/pkgname1.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+)
+
+func main() {
+	println("Hello", bar.Quux()) // bar should not be a known symbol.
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Error:
+// ../_test/pkgname1.go:8:19: undefined: bar

_test/pkgname2.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"guthib.com/toto" // pkg name is actually titi
+)
+
+func main() {
+	println("Hello", titi.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Output:
+// Hello bar

_test/redeclaration-global5.go

@@ -12,4 +12,5 @@ func main() {
 }
 
 // Error:
-// ../_test/redeclaration-global5.go:5:1: time redeclared in this block
+// ../_test/redeclaration-global5.go:5:6: time redeclared in this block
+//	previous declaration at ../_test/redeclaration-global5.go:3:5

_test/redeclaration-global7.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"guthib.com/bar" // pkg name is actually quux
+	"guthib.com/baz" // pkg name is also quux
+)
+
+func main() {
+	println("Hello", quux.Quux())
+}
+
+// GOPATH:testdata/redeclaration-global7
+// Error:
+// ../_test/redeclaration-global7.go:5:2: quux/redeclaration-global7.go redeclared as imported package name

_test/restricted0.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"log"
+)
+
+func main() {
+	defer func() {
+		r := recover()
+		fmt.Println("recover:", r)
+	}()
+	log.Fatal("log.Fatal does not exit")
+	println("not printed")
+}
+
+// Output:
+// recover: log.Fatal does not exit

_test/restricted1.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	defer func() {
+		r := recover()
+		fmt.Println("recover:", r)
+	}()
+	os.Exit(1)
+	println("not printed")
+}
+
+// Output:
+// recover: os.Exit(1)

_test/restricted2.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	p, err := os.FindProcess(os.Getpid())
+	fmt.Println(p, err)
+}
+
+// Output:
+// <nil> restricted

_test/restricted3.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+)
+
+var (
+	buf    bytes.Buffer
+	logger = log.New(&buf, "logger: ", log.Lshortfile)
+)
+
+func main() {
+	defer func() {
+		r := recover()
+		fmt.Println("recover:", r, buf.String())
+	}()
+	logger.Fatal("test log")
+}
+
+// Output:
+// recover: test log logger: restricted.go:39: test log

_test/rune1.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	t := make([]byte, 2)
+	t[0] = '$'
+	fmt.Println(t)
+}
+
+// Output:
+// [36 0]

_test/struct53.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+type T1 struct {
+	P []*T
+}
+
+type T2 struct {
+	P2 *T
+}
+
+type T struct {
+	*T1
+	S1 *T
+}
+
+func main() {
+	fmt.Println(T2{})
+}
+
+// Output:
+// {<nil>}

_test/struct54.go

@@ -0,0 +1,26 @@
+package main
+
+type S struct {
+	t *T
+}
+
+func newS() *S {
+	return &S{
+		t: &T{u: map[string]*U{}},
+	}
+}
+
+type T struct {
+	u map[string]*U
+}
+
+type U struct {
+	a int
+}
+
+func main() {
+	s := newS()
+	_ = s
+
+	println("ok")
+}

_test/struct55.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+type Logger struct {
+	m []*log.Logger
+}
+
+func (l *Logger) Infof(format string, args ...interface{}) {
+	l.m[0].Printf(format, args...)
+}
+
+func main() {
+	l := &Logger{m: []*log.Logger{log.New(os.Stdout, "", log.Lmsgprefix)}}
+	l.Infof("test %s", "test")
+}
+
+// Output:
+// test test

_test/struct56.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type A struct {
+	IA InnerA
+}
+
+type InnerA struct {
+	Timestamp int64
+}
+
+func main() {
+	a := &A{}
+	b, _ := json.Marshal(a)
+	fmt.Println(string(b))
+}
+
+// Output:
+// {"IA":{"Timestamp":0}}

_test/struct57.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type A struct {
+	InnerA
+}
+
+type InnerA struct {
+	Timestamp int64
+}
+
+func main() {
+	a := &A{}
+	b, _ := json.Marshal(a)
+	fmt.Println(string(b))
+}
+
+// Output:
+// {"Timestamp":0}

_test/tag0.go

@@ -1,9 +1,9 @@
 // The following comment line has the same effect as 'go run -tags=dummy'
-//yaegi:tags dummy
+// yaegi:tags dummy
 
 package main
 
-import _ "github.com/containous/yaegi/_test/ct"
+import _ "github.com/traefik/yaegi/_test/ct"
 
 func main() {
 	println("bye")

_test/testdata/redeclaration-global7/src/guthib.com/bar/quux.go

@@ -0,0 +1,5 @@
+package quux
+
+func Quux() string {
+	return "bar"
+}

_test/testdata/redeclaration-global7/src/guthib.com/baz/quux.go

@@ -0,0 +1,5 @@
+package quux
+
+func Quux() string {
+	return "baz"
+}

_test/testdata/redeclaration-global7/src/guthib.com/tata/tutu.go

@@ -0,0 +1,7 @@
+package tutu
+
+import "guthib.com/baz"
+
+func Quux() string {
+	return quux.Quux()
+}

_test/testdata/redeclaration-global7/src/guthib.com/toto/titi.go

@@ -0,0 +1,7 @@
+package titi
+
+import "guthib.com/bar"
+
+func Quux() string {
+	return quux.Quux()
+}

_test/type25.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"errors"
+	"sync/atomic"
+)
+
+type wrappedError struct {
+	wrapped error
+}
+
+func (e wrappedError) Error() string {
+	return "some outer error"
+}
+
+func (e wrappedError) Unwrap() error {
+	return e.wrapped
+}
+
+var err atomic.Value
+
+func getWrapped() *wrappedError {
+	if v := err.Load(); v != nil {
+		err := v.(wrappedError)
+		if err.wrapped != nil {
+			return &err
+		}
+	}
+	return nil
+}
+
+func main() {
+	err.Store(wrappedError{wrapped: errors.New("test")})
+
+	e := getWrapped()
+	if e != nil {
+		println(e.Error())
+		println(e.wrapped.Error())
+	}
+}
+
+// Output:
+// some outer error
+// test

_test/type26.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"errors"
+	"sync/atomic"
+)
+
+type wrappedError struct {
+	wrapped error
+}
+
+func (e *wrappedError) Error() string {
+	return "some outer error"
+}
+
+func (e *wrappedError) Unwrap() error {
+	return e.wrapped
+}
+
+var err atomic.Value
+
+func getWrapped() *wrappedError {
+	if v := err.Load(); v != nil {
+		err := v.(*wrappedError)
+		if err.wrapped != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func main() {
+	err.Store(&wrappedError{wrapped: errors.New("test")})
+
+	e := getWrapped()
+	if e != nil {
+		println(e.Error())
+		println(e.wrapped.Error())
+	}
+}
+
+// Output:
+// some outer error
+// test

_test/var12.go

@@ -0,0 +1,13 @@
+package main
+
+var (
+	a = b
+	b = "hello"
+)
+
+func main() {
+	println(a)
+}
+
+// Output:
+// hello

_test/var13.go

@@ -0,0 +1,23 @@
+package main
+
+var (
+	a = concat("hello", b)
+	b = concat(" ", c, "!")
+	c = d
+	d = "world"
+)
+
+func concat(a ...string) string {
+	var s string
+	for _, ss := range a {
+		s += ss
+	}
+	return s
+}
+
+func main() {
+	println(a)
+}
+
+// Output:
+// hello world!

_test/var14.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/traefik/yaegi/_test/vars"
+
+func main() {
+	println(vars.A)
+}
+
+// Output:
+// hello world!

_test/vars/first.go

@@ -0,0 +1,14 @@
+package vars
+
+var (
+	A = concat("hello", B)
+	C = D
+)
+
+func concat(a ...string) string {
+	var s string
+	for _, ss := range a {
+		s += ss
+	}
+	return s
+}

_test/vars/second.go

@@ -0,0 +1,6 @@
+package vars
+
+var (
+	B = concat(" ", C, "!")
+	D = "world"
+)

cmd/goexports/goexports.go

@@ -11,7 +11,7 @@ Usage:
 
 Example:
 
-    goexports github.com/containous/yaegi/interp
+    goexports github.com/traefik/yaegi/interp
 
 The same goexport program is used for all target operating systems and architectures.
 The GOOS and GOARCH environment variables set the desired target.
@@ -23,272 +23,16 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
-	"go/constant"
-	"go/format"
-	"go/importer"
-	"go/token"
-	"go/types"
-	"io/ioutil"
+	"io"
 	"log"
-	"math/big"
 	"os"
 	"path"
 	"runtime"
-	"strconv"
 	"strings"
-	"text/template"
+
+	"github.com/traefik/yaegi/extract"
 )
 
-const model = `// Code generated by 'goexports {{.PkgName}}'. DO NOT EDIT.
-
-{{.License}}
-
-{{if .BuildTags}}// +build {{.BuildTags}}{{end}}
-
-package {{.Dest}}
-
-import (
-{{- range $key, $value := .Imports }}
-	{{- if $value}}
-	"{{$key}}"
-	{{- end}}
-{{- end}}
-	"{{.PkgName}}"
-	"reflect"
-)
-
-func init() {
-	Symbols["{{.PkgName}}"] = map[string]reflect.Value{
-		{{- if .Val}}
-		// function, constant and variable definitions
-		{{range $key, $value := .Val -}}
-			{{- if $value.Addr -}}
-				"{{$key}}": reflect.ValueOf(&{{$value.Name}}).Elem(),
-			{{else -}}
-				"{{$key}}": reflect.ValueOf({{$value.Name}}),
-			{{end -}}
-		{{end}}
-
-		{{- end}}
-		{{- if .Typ}}
-		// type definitions
-		{{range $key, $value := .Typ -}}
-			"{{$key}}": reflect.ValueOf((*{{$value}})(nil)),
-		{{end}}
-
-		{{- end}}
-		{{- if .Wrap}}
-		// interface wrapper definitions
-		{{range $key, $value := .Wrap -}}
-			"_{{$key}}": reflect.ValueOf((*{{$value.Name}})(nil)),
-		{{end}}
-		{{- end}}
-	}
-}
-{{range $key, $value := .Wrap -}}
-	// {{$value.Name}} is an interface wrapper for {{$key}} type
-	type {{$value.Name}} struct {
-		{{range $m := $value.Method -}}
-		W{{$m.Name}} func{{$m.Param}} {{$m.Result}}
-		{{end}}
-	}
-	{{range $m := $value.Method -}}
-		func (W {{$value.Name}}) {{$m.Name}}{{$m.Param}} {{$m.Result}} { {{$m.Ret}} W.W{{$m.Name}}{{$m.Arg}} }
-	{{end}}
-{{end}}
-`
-
-// Val store the value name and addressable status of symbols.
-type Val struct {
-	Name string // "package.name"
-	Addr bool   // true if symbol is a Var
-}
-
-// Method store information for generating interface wrapper method.
-type Method struct {
-	Name, Param, Result, Arg, Ret string
-}
-
-// Wrap store information for generating interface wrapper.
-type Wrap struct {
-	Name   string
-	Method []Method
-}
-
-func genContent(dest, pkgName, license string, skip map[string]bool) ([]byte, error) {
-	p, err := importer.ForCompiler(token.NewFileSet(), "source", nil).Import(pkgName)
-	if err != nil {
-		return nil, err
-	}
-
-	prefix := "_" + pkgName + "_"
-	prefix = strings.NewReplacer("/", "_", "-", "_", ".", "_").Replace(prefix)
-
-	typ := map[string]string{}
-	val := map[string]Val{}
-	wrap := map[string]Wrap{}
-	imports := map[string]bool{}
-	sc := p.Scope()
-
-	for _, pkg := range p.Imports() {
-		imports[pkg.Path()] = false
-	}
-	qualify := func(pkg *types.Package) string {
-		if pkg.Path() != pkgName {
-			imports[pkg.Path()] = true
-		}
-		return pkg.Name()
-	}
-
-	for _, name := range sc.Names() {
-		o := sc.Lookup(name)
-		if !o.Exported() {
-			continue
-		}
-
-		pname := path.Base(pkgName) + "." + name
-		if skip[pname] {
-			continue
-		}
-
-		switch o := o.(type) {
-		case *types.Const:
-			if b, ok := o.Type().(*types.Basic); ok && (b.Info()&types.IsUntyped) != 0 {
-				// convert untyped constant to right type to avoid overflow
-				val[name] = Val{fixConst(pname, o.Val(), imports), false}
-			} else {
-				val[name] = Val{pname, false}
-			}
-		case *types.Func:
-			val[name] = Val{pname, false}
-		case *types.Var:
-			val[name] = Val{pname, true}
-		case *types.TypeName:
-			typ[name] = pname
-			if t, ok := o.Type().Underlying().(*types.Interface); ok {
-				var methods []Method
-				for i := 0; i < t.NumMethods(); i++ {
-					f := t.Method(i)
-					if !f.Exported() {
-						continue
-					}
-
-					sign := f.Type().(*types.Signature)
-					args := make([]string, sign.Params().Len())
-					params := make([]string, len(args))
-					for j := range args {
-						v := sign.Params().At(j)
-						if args[j] = v.Name(); args[j] == "" {
-							args[j] = fmt.Sprintf("a%d", j)
-						}
-						params[j] = args[j] + " " + types.TypeString(v.Type(), qualify)
-					}
-					arg := "(" + strings.Join(args, ", ") + ")"
-					param := "(" + strings.Join(params, ", ") + ")"
-
-					results := make([]string, sign.Results().Len())
-					for j := range results {
-						v := sign.Results().At(j)
-						results[j] = v.Name() + " " + types.TypeString(v.Type(), qualify)
-					}
-					result := "(" + strings.Join(results, ", ") + ")"
-
-					ret := ""
-					if sign.Results().Len() > 0 {
-						ret = "return"
-					}
-
-					methods = append(methods, Method{f.Name(), param, result, arg, ret})
-				}
-				wrap[name] = Wrap{prefix + name, methods}
-			}
-		}
-	}
-
-	var buildTags string
-	if runtime.Version() != "devel" {
-		parts := strings.Split(runtime.Version(), ".")
-
-		minorRaw := getMinor(parts[1])
-
-		currentGoVersion := parts[0] + "." + minorRaw
-
-		minor, errParse := strconv.Atoi(minorRaw)
-		if errParse != nil {
-			return nil, fmt.Errorf("failed to parse version: %v", errParse)
-		}
-
-		nextGoVersion := parts[0] + "." + strconv.Itoa(minor+1)
-
-		buildTags = currentGoVersion + ",!" + nextGoVersion
-	}
-
-	base := template.New("goexports")
-	parse, err := base.Parse(model)
-	if err != nil {
-		return nil, fmt.Errorf("template parsing error: %v", err)
-	}
-
-	if pkgName == "log/syslog" {
-		buildTags += ",!windows,!nacl,!plan9"
-	}
-
-	b := new(bytes.Buffer)
-	data := map[string]interface{}{
-		"Dest":      dest,
-		"Imports":   imports,
-		"PkgName":   pkgName,
-		"Val":       val,
-		"Typ":       typ,
-		"Wrap":      wrap,
-		"BuildTags": buildTags,
-		"License":   license,
-	}
-	err = parse.Execute(b, data)
-	if err != nil {
-		return nil, fmt.Errorf("template error: %v", err)
-	}
-
-	// gofmt
-	source, err := format.Source(b.Bytes())
-	if err != nil {
-		return nil, fmt.Errorf("failed to format source: %v: %s", err, b.Bytes())
-	}
-	return source, nil
-}
-
-// fixConst checks untyped constant value, converting it if necessary to avoid overflow.
-func fixConst(name string, val constant.Value, imports map[string]bool) string {
-	var (
-		tok string
-		str string
-	)
-	switch val.Kind() {
-	case constant.Int:
-		tok = "INT"
-		str = val.ExactString()
-	case constant.Float:
-		v := constant.Val(val) // v is *big.Rat or *big.Float
-		f, ok := v.(*big.Float)
-		if !ok {
-			f = new(big.Float).SetRat(v.(*big.Rat))
-		}
-
-		tok = "FLOAT"
-		str = f.Text('g', int(f.Prec()))
-	case constant.Complex:
-		// TODO: not sure how to parse this case
-		fallthrough
-	default:
-		return name
-	}
-
-	imports["go/constant"] = true
-	imports["go/token"] = true
-
-	return fmt.Sprintf("constant.MakeFromLiteral(\"%s\", token.%s, 0)", str, tok)
-}
-
 // genLicense generates the correct LICENSE header text from the provided
 // path to a LICENSE file.
 func genLicense(fname string) (string, error) {
@@ -318,9 +62,13 @@ func genLicense(fname string) (string, error) {
 	return license.String(), nil
 }
 
-func main() {
-	licenseFlag := flag.String("license", "", "path to a LICENSE file")
+var (
+	licenseFlag = flag.String("license", "", "path to a LICENSE file")
+	// TODO: deal with a module that has several packages (so there's only one go.mod file at the root of the project).
+	importPathFlag = flag.String("import_path", "", "the namespace for the symbols extracted from the argument. Not needed if the argument is from the stdlib, or if the name can be found in a go.mod")
+)
 
+func main() {
 	flag.Parse()
 
 	if flag.NArg() == 0 {
@@ -333,55 +81,57 @@ func main() {
 		log.Fatal(err)
 	}
 
-	dir, err := os.Getwd()
+	wd, err := os.Getwd()
 	if err != nil {
 		log.Fatal(err)
 	}
-	dest := path.Base(dir)
 
-	for _, pkg := range flag.Args() {
-		var oFile string
-		skip := map[string]bool{}
-		if pkg == "syscall" {
-			goos, arch := os.Getenv("GOOS"), os.Getenv("GOARCH")
-			oFile = strings.Replace(pkg, "/", "_", -1) + "_" + goos + "_" + arch + ".go"
-			if goos == "solaris" {
-				skip["syscall.RawSyscall6"] = true
-				skip["syscall.Syscall6"] = true
-			}
-		} else {
-			oFile = strings.Replace(pkg, "/", "_", -1) + ".go"
-		}
+	ext := extract.Extractor{
+		Dest:    path.Base(wd),
+		License: license,
+	}
+	goos, goarch := os.Getenv("GOOS"), os.Getenv("GOARCH")
+	skip := map[string]bool{}
+	if goos == "solaris" {
+		skip["syscall.RawSyscall6"] = true
+		skip["syscall.Syscall6"] = true
+	}
+	ext.Skip = skip
 
-		content, err := genContent(dest, pkg, license, skip)
+	for _, pkgIdent := range flag.Args() {
+		var buf bytes.Buffer
+		importPath, err := ext.Extract(pkgIdent, *importPathFlag, &buf)
 		if err != nil {
 			log.Println(err)
 			continue
 		}
 
+		var oFile string
+		if pkgIdent == "syscall" {
+			oFile = strings.ReplaceAll(importPath, "/", "_") + "_" + goos + "_" + goarch + ".go"
+		} else {
+			oFile = strings.ReplaceAll(importPath, "/", "_") + ".go"
+		}
+
 		prefix := runtime.Version()
 		if runtime.Version() != "devel" {
 			parts := strings.Split(runtime.Version(), ".")
 
-			prefix = parts[0] + "_" + getMinor(parts[1])
+			prefix = parts[0] + "_" + extract.GetMinor(parts[1])
 		}
 
-		err = ioutil.WriteFile(prefix+"_"+oFile, content, 0666)
+		f, err := os.Create(prefix + "_" + oFile)
 		if err != nil {
 			log.Fatal(err)
 		}
+
+		if _, err := io.Copy(f, &buf); err != nil {
+			_ = f.Close()
+			log.Fatal(err)
+		}
+
+		if err := f.Close(); err != nil {
+			log.Fatal(err)
+		}
 	}
 }
-
-func getMinor(part string) string {
-	minor := part
-	index := strings.Index(minor, "beta")
-	if index < 0 {
-		index = strings.Index(minor, "rc")
-	}
-	if index > 0 {
-		minor = minor[:index]
-	}
-
-	return minor
-}

cmd/yaegi/extract.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/traefik/yaegi/extract"
+)
+
+func extractCmd(arg []string) error {
+	var licensePath string
+	var importPath string
+
+	eflag := flag.NewFlagSet("run", flag.ContinueOnError)
+	eflag.StringVar(&licensePath, "license", "", "path to a LICENSE file")
+	eflag.StringVar(&importPath, "import_path", "", "the namespace for the extracted symbols")
+	eflag.Usage = func() {
+		fmt.Println("Usage: yaegi extract [options] packages...")
+		fmt.Println("Options:")
+		eflag.PrintDefaults()
+	}
+
+	if err := eflag.Parse(arg); err != nil {
+		return err
+	}
+
+	args := eflag.Args()
+	if len(args) == 0 {
+		return fmt.Errorf("missing package")
+	}
+
+	license, err := genLicense(licensePath)
+	if err != nil {
+		return err
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	ext := extract.Extractor{
+		Dest:    path.Base(wd),
+		License: license,
+	}
+
+	for _, pkgIdent := range args {
+		var buf bytes.Buffer
+		importPath, err := ext.Extract(pkgIdent, importPath, &buf)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			continue
+		}
+
+		oFile := strings.ReplaceAll(importPath, "/", "_") + ".go"
+		f, err := os.Create(oFile)
+		if err != nil {
+			return err
+		}
+
+		if _, err := io.Copy(f, &buf); err != nil {
+			_ = f.Close()
+			return err
+		}
+
+		if err := f.Close(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// genLicense generates the correct LICENSE header text from the provided
+// path to a LICENSE file.
+func genLicense(fname string) (string, error) {
+	if fname == "" {
+		return "", nil
+	}
+
+	f, err := os.Open(fname)
+	if err != nil {
+		return "", fmt.Errorf("could not open LICENSE file: %v", err)
+	}
+	defer func() { _ = f.Close() }()
+
+	license := new(strings.Builder)
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		txt := sc.Text()
+		if txt != "" {
+			txt = " " + txt
+		}
+		license.WriteString("//" + txt + "\n")
+	}
+	if sc.Err() != nil {
+		return "", fmt.Errorf("could not scan LICENSE file: %v", err)
+	}
+
+	return license.String(), nil
+}

cmd/yaegi/help.go

@@ -0,0 +1,43 @@
+package main
+
+import "fmt"
+
+const usage = `Yaegi is a Go interpreter.
+
+Usage:
+
+    yaegi [command] [arguments]
+
+The commands are:
+
+    extract     generate a wrapper file from a source package
+    help        print usage information
+    run         execute a Go program from source
+    test        execute test functions in a Go package
+
+Use "yaegi help <command>" for more information about a command.
+
+If no command is given or if the first argument is not a command, then
+the run command is assumed.
+`
+
+func help(arg []string) error {
+	var cmd string
+	if len(arg) > 0 {
+		cmd = arg[0]
+	}
+
+	switch cmd {
+	case Extract:
+		return extractCmd([]string{"-h"})
+	case Help, "", "-h", "--help":
+		fmt.Print(usage)
+		return nil
+	case Run:
+		return run([]string{"-h"})
+	case Test:
+		return test([]string{"-h"})
+	default:
+		return fmt.Errorf("help: invalid yaegi command: %v", cmd)
+	}
+}

cmd/yaegi/run.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
+	"github.com/traefik/yaegi/stdlib/syscall"
+	"github.com/traefik/yaegi/stdlib/unrestricted"
+	"github.com/traefik/yaegi/stdlib/unsafe"
+)
+
+func run(arg []string) error {
+	var interactive bool
+	var useSyscall bool
+	var useUnrestricted bool
+	var useUnsafe bool
+	var tags string
+	var cmd string
+	var err error
+
+	rflag := flag.NewFlagSet("run", flag.ContinueOnError)
+	rflag.BoolVar(&interactive, "i", false, "start an interactive REPL")
+	rflag.BoolVar(&useSyscall, "syscall", false, "include syscall symbols")
+	rflag.BoolVar(&useUnrestricted, "unrestricted", false, "include unrestricted symbols")
+	rflag.StringVar(&tags, "tags", "", "set a list of build tags")
+	rflag.BoolVar(&useUnsafe, "unsafe", false, "include usafe symbols")
+	rflag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
+	rflag.Usage = func() {
+		fmt.Println("Usage: yaegi run [options] [path] [args]")
+		fmt.Println("Options:")
+		rflag.PrintDefaults()
+	}
+	if err = rflag.Parse(arg); err != nil {
+		return err
+	}
+	args := rflag.Args()
+
+	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
+	i.Use(stdlib.Symbols)
+	i.Use(interp.Symbols)
+	if useSyscall {
+		i.Use(syscall.Symbols)
+	}
+	if useUnsafe {
+		i.Use(unsafe.Symbols)
+	}
+	if useUnrestricted {
+		// Use of unrestricted symbols should always follow use of stdlib symbols, to update them.
+		i.Use(unrestricted.Symbols)
+	}
+
+	if cmd != "" {
+		_, err = i.Eval(cmd)
+		showError(err)
+	}
+
+	if len(args) == 0 {
+		if interactive || cmd == "" {
+			_, err = i.REPL()
+			showError(err)
+		}
+		return err
+	}
+
+	// Skip first os arg to set command line as expected by interpreted main
+	path := args[0]
+	os.Args = arg[1:]
+	flag.CommandLine = flag.NewFlagSet(path, flag.ExitOnError)
+
+	if isFile(path) {
+		err = runFile(i, path)
+	} else {
+		_, err = i.EvalPath(path)
+	}
+	showError(err)
+
+	if err != nil {
+		return err
+	}
+
+	if interactive {
+		_, err = i.REPL()
+		showError(err)
+	}
+	return err
+}
+
+func isFile(path string) bool {
+	fi, err := os.Stat(path)
+	return err == nil && fi.Mode().IsRegular()
+}
+
+func runFile(i *interp.Interpreter, path string) error {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	if s := string(b); strings.HasPrefix(s, "#!") {
+		// Allow executable go scripts, Have the same behavior as in interactive mode.
+		s = strings.Replace(s, "#!", "//", 1)
+		_, err = i.Eval(s)
+		return err
+	}
+
+	// Files not starting with "#!" are supposed to be pure Go, directly Evaled.
+	_, err = i.EvalPath(path)
+	return err
+}
+
+func showError(err error) {
+	if err == nil {
+		return
+	}
+	fmt.Fprintln(os.Stderr, err)
+	if p, ok := err.(interp.Panic); ok {
+		fmt.Fprintln(os.Stderr, string(p.Stack))
+	}
+}

cmd/yaegi/test.go

@@ -0,0 +1,131 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"go/build"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
+	"github.com/traefik/yaegi/stdlib/syscall"
+	"github.com/traefik/yaegi/stdlib/unrestricted"
+	"github.com/traefik/yaegi/stdlib/unsafe"
+)
+
+func test(arg []string) (err error) {
+	var (
+		bench           string
+		benchmem        bool
+		benchtime       string
+		count           string
+		cpu             string
+		failfast        bool
+		run             string
+		short           bool
+		tags            string
+		useUnrestricted bool
+		useUnsafe       bool
+		useSyscall      bool
+		timeout         string
+		verbose         bool
+	)
+
+	tflag := flag.NewFlagSet("test", flag.ContinueOnError)
+	tflag.StringVar(&bench, "bench", "", "Run only those benchmarks matching a regular expression.")
+	tflag.BoolVar(&benchmem, "benchmem", false, "Print memory allocation statistics for benchmarks.")
+	tflag.StringVar(&benchtime, "benchtime", "", "Run enough iterations of each benchmark to take t.")
+	tflag.StringVar(&count, "count", "", "Run each test and benchmark n times (default 1).")
+	tflag.StringVar(&cpu, "cpu", "", "Specify a list of GOMAXPROCS values for which the tests or benchmarks should be executed.")
+	tflag.BoolVar(&failfast, "failfast", false, "Do not start new tests after the first test failure.")
+	tflag.StringVar(&run, "run", "", "Run only those tests matching a regular expression.")
+	tflag.BoolVar(&short, "short", false, "Tell long-running tests to shorten their run time.")
+	tflag.StringVar(&tags, "tags", "", "Set a list of build tags.")
+	tflag.StringVar(&timeout, "timeout", "", "If a test binary runs longer than duration d, panic.")
+	tflag.BoolVar(&useUnrestricted, "unrestricted", false, "Include unrestricted symbols.")
+	tflag.BoolVar(&useUnsafe, "unsafe", false, "Include usafe symbols.")
+	tflag.BoolVar(&useSyscall, "syscall", false, "Include syscall symbols.")
+	tflag.BoolVar(&verbose, "v", false, "Verbose output: log all tests as they are run.")
+	tflag.Usage = func() {
+		fmt.Println("Usage: yaegi test [options] [path]")
+		fmt.Println("Options:")
+		tflag.PrintDefaults()
+	}
+	if err = tflag.Parse(arg); err != nil {
+		return err
+	}
+	args := tflag.Args()
+	path := "."
+	if len(args) > 0 {
+		path = args[0]
+	}
+
+	// Overwrite os.Args with correct flags to setup testing.Init.
+	tf := []string{""}
+	if bench != "" {
+		tf = append(tf, "-test.bench", bench)
+	}
+	if benchmem {
+		tf = append(tf, "-test.benchmem")
+	}
+	if benchtime != "" {
+		tf = append(tf, "-test.benchtime", benchtime)
+	}
+	if count != "" {
+		tf = append(tf, "-test.count", count)
+	}
+	if cpu != "" {
+		tf = append(tf, "-test.cpu", cpu)
+	}
+	if failfast {
+		tf = append(tf, "-test.failfast")
+	}
+	if run != "" {
+		tf = append(tf, "-test.run", run)
+	}
+	if short {
+		tf = append(tf, "-test.short")
+	}
+	if timeout != "" {
+		tf = append(tf, "-test.timeout", timeout)
+	}
+	if verbose {
+		tf = append(tf, "-test.v")
+	}
+	testing.Init()
+	os.Args = tf
+	flag.Parse()
+
+	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
+	i.Use(stdlib.Symbols)
+	i.Use(interp.Symbols)
+	if useSyscall {
+		i.Use(syscall.Symbols)
+	}
+	if useUnrestricted {
+		i.Use(unrestricted.Symbols)
+	}
+	if useUnsafe {
+		i.Use(unsafe.Symbols)
+	}
+	if err = i.EvalTest(path); err != nil {
+		return err
+	}
+
+	benchmarks := []testing.InternalBenchmark{}
+	tests := []testing.InternalTest{}
+	for name, sym := range i.Symbols(path) {
+		switch fun := sym.Interface().(type) {
+		case func(*testing.B):
+			benchmarks = append(benchmarks, testing.InternalBenchmark{name, fun})
+		case func(*testing.T):
+			tests = append(tests, testing.InternalTest{name, fun})
+		}
+	}
+
+	testing.Main(regexp.MatchString, tests, benchmarks, nil)
+	return nil
+}

cmd/yaegi/yaegi.go

@@ -85,87 +85,53 @@ Debugging support (may be removed at any time):
 package main
 
 import (
+	"errors"
 	"flag"
 	"fmt"
-	"go/build"
-	"io/ioutil"
 	"log"
 	"os"
-	"strings"
+)
 
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
-	"github.com/containous/yaegi/stdlib/syscall"
-	"github.com/containous/yaegi/stdlib/unsafe"
+const (
+	Extract = "extract"
+	Help    = "help"
+	Run     = "run"
+	Test    = "test"
 )
 
 func main() {
-	var interactive bool
-	var useUnsafe bool
-	var useSyscall bool
-	var tags string
 	var cmd string
-	flag.BoolVar(&interactive, "i", false, "start an interactive REPL")
-	flag.BoolVar(&useSyscall, "syscall", false, "include syscall symbols")
-	flag.StringVar(&tags, "tags", "", "set a list of build tags")
-	flag.BoolVar(&useUnsafe, "unsafe", false, "include usafe symbols")
-	flag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
-	flag.Usage = func() {
-		fmt.Println("Usage:", os.Args[0], "[options] [script] [args]")
-		fmt.Println("Options:")
-		flag.PrintDefaults()
-	}
-	flag.Parse()
-	args := flag.Args()
-	log.SetFlags(log.Lshortfile)
+	var err error
+	var exitCode int
 
-	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
-	i.Use(stdlib.Symbols)
-	i.Use(interp.Symbols)
-	if useSyscall {
-		i.Use(syscall.Symbols)
-	}
-	if useUnsafe {
-		i.Use(unsafe.Symbols)
+	log.SetFlags(log.Lshortfile) // Ease debugging.
+
+	if len(os.Args) > 1 {
+		cmd = os.Args[1]
 	}
 
-	if cmd != `` {
-		i.REPL(strings.NewReader(cmd), os.Stderr)
+	switch cmd {
+	case Extract:
+		err = extractCmd(os.Args[2:])
+	case Help, "-h", "--help":
+		err = help(os.Args[2:])
+	case Run:
+		err = run(os.Args[2:])
+	case Test:
+		err = test(os.Args[2:])
+	default:
+		// If no command is given, fallback to default "run" command.
+		// This allows scripts starting with "#!/usr/bin/env yaegi",
+		// as passing more than 1 argument to #! executable may be not supported
+		// on all platforms.
+		cmd = Run
+		err = run(os.Args[1:])
 	}
 
-	if len(args) == 0 {
-		if interactive || cmd == `` {
-			i.REPL(os.Stdin, os.Stdout)
-		}
-		return
-	}
-
-	// Skip first os arg to set command line as expected by interpreted main
-	os.Args = os.Args[1:]
-	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-
-	b, err := ioutil.ReadFile(args[0])
-	if err != nil {
-		log.Fatal("Could not read file: ", args[0])
-	}
-
-	if s := string(b); strings.HasPrefix(s, "#!") {
-		// Allow executable go scripts, Have the same behavior as in interactive mode.
-		s = strings.Replace(s, "#!", "//", 1)
-		i.REPL(strings.NewReader(s), os.Stdout)
-	} else {
-		// Files not starting with "#!" are supposed to be pure Go, directly Evaled.
-		i.Name = args[0]
-		_, err := i.Eval(s)
-		if err != nil {
-			fmt.Println(err)
-			if p, ok := err.(interp.Panic); ok {
-				fmt.Println(string(p.Stack))
-			}
-		}
-	}
-
-	if interactive {
-		i.REPL(os.Stdin, os.Stdout)
+	if err != nil && !errors.Is(err, flag.ErrHelp) {
+		err = fmt.Errorf("%s: %w", cmd, err)
+		fmt.Fprintln(os.Stderr, err)
+		exitCode = 1
 	}
+	os.Exit(exitCode)
 }

cmd/yaegi/yaegi_test.go

@@ -2,17 +2,19 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 )
 
 const (
-	// CITimeoutMultiplier is the multiplier for all timeouts in the CI
+	// CITimeoutMultiplier is the multiplier for all timeouts in the CI.
 	CITimeoutMultiplier = 3
 )
 
@@ -108,8 +110,8 @@ func TestYaegiCmdCancel(t *testing.T) {
 			continue
 		}
 
-		if outBuf.String() != "context canceled\n" {
-			t.Errorf("unexpected output: %q", &outBuf)
+		if strings.TrimSuffix(errBuf.String(), "\n") != context.Canceled.Error() {
+			t.Errorf("unexpected error: %q", &errBuf)
 		}
 	}
 }

example/closure/closure_test.go

@@ -3,8 +3,8 @@ package clos1
 import (
 	"testing"
 
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
 )
 
 func TestFunctionCall(t *testing.T) {

example/getfunc/getfunc_test.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/containous/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
 )
 
 func TestGetFunc(t *testing.T) {

example/pkg/_pkg/src/github.com/foo/pkg/pkg.go

@@ -3,7 +3,7 @@ package pkg
 import (
 	"fmt"
 
-	"guthib.com/containous/fromage"
+	"guthib.com/traefik/fromage"
 )
 
 func Here() string {

example/pkg/_pkg10/src/github.com/foo/pkg.go

@@ -3,7 +3,7 @@ package pkg
 import (
 	"fmt"
 
-	"guthib.com/containous/fromage"
+	"guthib.com/traefik/fromage"
 )
 
 func Here() string {

example/pkg/_pkg11/src/foo/foo.go

@@ -3,7 +3,7 @@ package main
 import (
 	"fmt"
 
-	"guthib.com/containous/fromage"
+	"guthib.com/traefik/fromage"
 )
 
 func main() {

example/pkg/_pkg12/src/guthib.com/foo/main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+
+	"guthib.com/foo/pkg"
+)
+
+func main() {
+	fmt.Printf("%s", pkg.NewSample()())
+}

example/pkg/_pkg12/src/guthib.com/foo/pkg/pkg.go

@@ -0,0 +1,17 @@
+package pkg
+
+import (
+	"fmt"
+
+	"guthib.com/bar"
+)
+
+func Here() string {
+	return "hello"
+}
+
+func NewSample() func() string {
+	return func() string {
+		return fmt.Sprintf("%s %s", bar.Bar(), Here())
+	}
+}

example/pkg/_pkg12/src/guthib.com/foo/vendor/guthib.com/bar/bar.go

@@ -0,0 +1,6 @@
+package bar
+
+// Bar is bar
+func Bar() string {
+	return "Yo"
+}

example/pkg/_pkg2/src/github.com/foo/pkg/pkg.go

@@ -3,7 +3,7 @@ package pkg
 import (
 	"fmt"
 
-	"guthib.com/containous/fromage"
+	"guthib.com/traefik/fromage"
 )
 
 func Here() string {

example/pkg/_pkg2/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go

@@ -3,9 +3,9 @@ package fromage
 import (
 	"fmt"
 
-	"guthib.com/containous/cheese"
+	"guthib.com/traefik/cheese"
 )
 
 func Hello() string {
 	return fmt.Sprintf("Fromage %s", cheese.Hello())
-}
+}

example/pkg/_pkg3/src/github.com/foo/pkg/pkg.go

@@ -3,7 +3,7 @@ package pkg
 import (
 	"fmt"
 
-	"guthib.com/containous/fromage"
+	"guthib.com/traefik/fromage"
 )
 
 func Here() string {

example/pkg/_pkg3/src/github.com/foo/pkg/vendor/guthib.com/traefik/fromage/fromage.go

@@ -3,10 +3,10 @@ package fromage
 import (
 	"fmt"
 
-	"guthib.com/containous/cheese"
-	"guthib.com/containous/fromage/couteau"
+	"guthib.com/traefik/cheese"
+	"guthib.com/traefik/fromage/couteau"
 )
 
 func Hello() string {
 	return fmt.Sprintf("Fromage %s %s", couteau.Hello(), cheese.Hello())
-}
+}