fix: replace playground link in docs

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.

.gitignore

@@ -3,7 +3,7 @@
 *.dot
 .idea/
 /yaegi
-cmd/goexports/goexports
+internal/cmd/extract/extract
 example/inception/inception
 _test/tmp/
 /dist

.golangci.toml

@@ -38,6 +38,11 @@
     "gocognit",
     "stylecheck",
     "gomnd",
+    "testpackage",
+    "goerr113",
+    "nestif",
+    "exhaustive",
+    "nlreturn",
   ]
 
 [issues]

.goreleaser.yml

@@ -3,32 +3,7 @@ project_name: yaegi
 builds:
   - id: yaegi
     binary: yaegi
-    main: ./cmd/yaegi/yaegi.go
-
-    goos:
-      - darwin
-      - linux
-#      - windows
-      - freebsd
-      - openbsd
-      - solaris
-    goarch:
-      - amd64
-      - 386
-      - arm
-      - arm64
-    goarm:
-      - 7
-      - 6
-      - 5
-
-    ignore:
-      - goos: darwin
-        goarch: 386
-
-  - id: goexports
-    binary: goexports
-    main: ./cmd/goexports/goexports.go
+    main: ./cmd/yaegi/
 
     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.

Makefile

@@ -3,15 +3,15 @@ check:
 	golangci-lint run
 
 # Generate stdlib/syscall/syscall_GOOS_GOARCH.go for all platforms
-gen_all_syscall: cmd/goexports/goexports
-	@cd stdlib/syscall && \
-	for v in $$(go tool dist list); do \
+gen_all_syscall: internal/cmd/extract/extract
+	@for v in $$(go tool dist list); do \
 		echo syscall_$${v%/*}_$${v#*/}.go; \
-		GOOS=$${v%/*} GOARCH=$${v#*/} go generate; \
+		GOOS=$${v%/*} GOARCH=$${v#*/} go generate ./stdlib/syscall ./stdlib/unrestricted; \
 	done
 
-cmd/goexports/goexports: cmd/goexports/goexports.go
-	go generate cmd/goexports/goexports.go
+internal/cmd/extract/extract:
+	rm -f internal/cmd/extract/extract
+	go generate ./internal/cmd/extract
 
 generate: gen_all_syscall
 	go generate
@@ -20,4 +20,8 @@ tests:
 	GO111MODULE=off go test -v ./...
 	GO111MODULE=off go test -race ./interp
 
-.PHONY: check gen_all_syscall gen_tests
+# https://github.com/goreleaser/godownloader
+install.sh: .goreleaser.yml
+	godownloader --repo=traefik/yaegi -o install.sh .goreleaser.yml
+
+.PHONY: check gen_all_syscall gen_tests generate_downloader internal/cmd/extract/extract

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,18 +25,24 @@ 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),
 and alias the `yaegi` command in `alias yaegi='rlwrap yaegi'` in your `~/.bashrc`, to have history and command line edition.
 
+### CI Integration
+
+```bash
+curl -sfL https://raw.githubusercontent.com/traefik/yaegi/master/install.sh | bash -s -- -b $GOPATH/bin v0.9.0
+```
+
 ## Usage
 
 ### As an embedded interpreter
@@ -47,8 +53,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() {
@@ -68,7 +74,7 @@ func main() {
 }
 ```
 
-[Go Playground](https://play.golang.org/p/zzvw4VlerLP)
+[Go Playground](https://play.golang.org/p/2n-EpZbMYI9)
 
 ### As a dynamic extension framework
 
@@ -81,7 +87,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" }`
@@ -106,7 +112,7 @@ func main() {
 }
 ```
 
-[Go Playground](https://play.golang.org/p/6SEAoaO7n0U)
+[Go Playground](https://play.golang.org/p/WvwH4JqrU-p)
 
 ### As a command-line interpreter
 
@@ -155,11 +161,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 +176,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/assign13.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func getStr() string {
+	return "test"
+}
+
+func main() {
+	m := make(map[string]string, 0)
+	m["a"] = fmt.Sprintf("%v", 0.1)
+	m["b"] = string(fmt.Sprintf("%v", 0.1))
+	m["c"] = getStr()
+
+	fmt.Println(m)
+}
+
+// Output:
+// map[a:0.1 b:0.1 c:test]

_test/assign14.go

@@ -0,0 +1,16 @@
+package main
+
+var optionsG map[string]string = nil
+
+var roundG = 30
+
+func main() {
+	dummy := roundG
+	roundG = dummy + 1
+	println(roundG)
+	println(optionsG == nil)
+}
+
+// Output:
+// 31
+// true

_test/assign15.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var c chan<- struct{} = make(chan struct{})
+	var d <-chan struct{} = c
+
+	_ = d
+}
+
+// Error:
+// _test/assign15.go:5:26: cannot use type chan<- struct{} as type <-chan struct{} in assignment

_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/baz-bat/baz-bat.go

@@ -0,0 +1,3 @@
+package baz
+
+var Name = "baz-bat"

_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/chan10.go

@@ -0,0 +1,12 @@
+package main
+
+import "time"
+
+func main() {
+	var tick <-chan time.Time = time.Tick(time.Millisecond)
+	_ = tick
+	println("success")
+}
+
+// Output:
+// success

_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/composite10.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []map[int]int{make(map[int]int)}
+
+	for _, b := range a {
+		fmt.Println(b)
+	}
+}
+
+// Output:
+// map[]

_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/composite12.go

@@ -0,0 +1,19 @@
+package main
+
+type A struct {
+	C D
+}
+
+type D struct {
+	E string
+}
+
+func main() {
+	a := A{}
+	a.C = D{"bb"}
+
+	println(a.C.E)
+}
+
+// Output:
+// bb

_test/composite13.go

@@ -0,0 +1,19 @@
+package main
+
+type A struct {
+	C D
+}
+
+type D struct {
+	E string
+}
+
+func main() {
+	a := A{}
+	a.C = D{E: "bb"}
+
+	println(a.C.E)
+}
+
+// Output:
+// bb

_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/composite8bis.go

@@ -0,0 +1,16 @@
+package main
+
+type T struct{ I int }
+
+func main() {
+	t := []*T{}
+	s := []int{1, 2}
+	for _, e := range s {
+		x := &T{I: e}
+		t = append(t, x)
+	}
+	println(t[0].I, t[1].I)
+}
+
+// Output:
+// 1 2

_test/composite9.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := [][]int{make([]int,0)}
+
+	for _, b := range a {
+		fmt.Println(b)
+	}
+}
+
+// Output:
+// []

_test/const13.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	const tooBig = 1267650600228229401496703205376
+	const huge = 1 << 100
+	const large = huge >> 38
+
+	fmt.Println(large)
+}
+
+// Output:
+// 4611686018427387904

_test/const14.go

@@ -0,0 +1,13 @@
+package main
+
+import "compress/flate"
+
+func f1(i int) { println("i:", i) }
+
+func main() {
+	i := flate.BestSpeed
+	f1(i)
+}
+
+// Output:
+// i: 1

_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/const16.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println(7 / 3)
+}
+
+// Output:
+// 2

_test/defer5.go

@@ -0,0 +1,32 @@
+package main
+
+func f1() {
+	defer println("f1-begin")
+	f2()
+	defer println("f1-end")
+}
+
+func f2() {
+	defer println("f2-begin")
+	f3()
+	defer println("f2-end")
+}
+
+func f3() {
+	defer println("f3-begin")
+	println("hello")
+	defer println("f3-end")
+}
+
+func main() {
+	f1()
+}
+
+// Output:
+// hello
+// f3-end
+// f3-begin
+// f2-end
+// f2-begin
+// f1-end
+// f1-begin

_test/defer6.go

@@ -0,0 +1,27 @@
+package main
+
+func f1() {
+	defer print("f1-begin ")
+	f2()
+	defer print("f1-end ")
+}
+
+func f2() {
+	defer print("f2-begin ")
+	f3()
+	defer print("f2-end ")
+}
+
+func f3() {
+	defer print("f3-begin ")
+	print("hello ")
+	defer print("f3-end ")
+}
+
+func main() {
+	f1()
+	println()
+}
+
+// Output:
+// hello f3-end f3-begin f2-end f2-begin f1-end f1-begin

_test/defer7.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func f1(in, out []string) {
+	defer copy(out, in)
+}
+
+func main() {
+	in := []string{"foo", "bar"}
+	out := make([]string, 2)
+	f1(in, out)
+
+	fmt.Println(out)
+}
+
+// Output:
+// [foo bar]

_test/defer8.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func f1(m map[string]string) {
+	defer delete(m, "foo")
+	defer delete(m, "test")
+
+	fmt.Println(m)
+}
+
+func main() {
+	m := map[string]string{
+		"foo": "bar",
+		"baz": "bat",
+	}
+	f1(m)
+
+	fmt.Println(m)
+}
+
+// Output:
+// map[baz:bat foo:bar]
+// map[baz:bat]

_test/defer9.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func f1(ch chan string) {
+	defer close(ch)
+
+	ch <- "foo"
+}
+
+func main() {
+	ch := make(chan string, 1)
+	f1(ch)
+
+	for s := range ch {
+		fmt.Println(s)
+	}
+}
+
+// Output:
+// foo

_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

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/traefik/yaegi/_test/baz-bat"
+
+func main() {
+	println(baz.Name)
+}
+
+// Output:
+// baz-bat

_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/interface42.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	v := interface{}(0)
+
+	fmt.Println(v)
+}
+
+// Output:
+// 0

_test/interface43.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	v := interface{}(nil)
+
+	fmt.Println(v)
+}
+
+// Output:
+// <nil>

_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-735.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+var optionsG map[string]string
+
+var roundG int = 30
+
+func strToInt(s string, defaultValue int) int {
+	n, err := strconv.ParseInt(s, 10, 0)
+	if err != nil {
+		return defaultValue
+	}
+	return int(n)
+}
+
+func main() {
+	optionsG := map[string]string{"round": "12", "b": "one"}
+	roundG = strToInt(optionsG["round"], 50)
+	fmt.Println(roundG)
+	fmt.Println(optionsG)
+}
+
+// Output:
+// 12
+// map[b:one round:12]

_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/m2/m2_test.go

@@ -0,0 +1,7 @@
+package m2
+
+import "testing"
+
+func TestM2(t *testing.T) {
+	t.Errorf("got %s, want %s", "AAA", "BBB")
+}

_test/make2.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	var s uint = 4
+	t := make([]int, s)
+	fmt.Println(t)
+}
+
+// Output:
+// [0 0 0 0]

_test/map29.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+type Item struct {
+	Object interface{}
+	Expiry time.Duration
+}
+
+func main() {
+	items := map[string]Item{}
+
+	items["test"] = Item{
+		Object: "test",
+		Expiry: time.Second,
+	}
+
+	item := items["test"]
+	fmt.Println(item)
+}
+
+// Output:
+// {test 1s}

_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/method32.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var a = []func(string){bar}
+	 b := a[0]
+	 b("bar")
+}
+
+func bar(a string) {
+	fmt.Println(a)
+}
+
+// Output:
+// bar

_test/method33.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+)
+
+type T1 struct{}
+
+func (t1 T1) f() {
+	fmt.Println("T1.f()")
+}
+
+func (t1 T1) g() {
+	fmt.Println("T1.g()")
+}
+
+type T2 struct {
+	T1
+}
+
+func (t2 T2) f() {
+	fmt.Println("T2.f()")
+}
+
+type I interface {
+	f()
+}
+
+func printType(i I) {
+	if t1, ok := i.(T1); ok {
+		println("T1 ok")
+		t1.f()
+		t1.g()
+	}
+
+	if t2, ok := i.(T2); ok {
+		println("T2 ok")
+		t2.f()
+		t2.g()
+	}
+}
+
+func main() {
+	println("T1")
+	printType(T1{})
+	println("T2")
+	printType(T2{})
+}
+
+// Output:
+// T1
+// T1 ok
+// T1.f()
+// T1.g()
+// T2
+// T2 ok
+// T2.f()
+// T1.g()

_test/method34.go

@@ -0,0 +1,23 @@
+package main
+
+type Root struct {
+	Name string
+}
+
+type One struct {
+	Root
+}
+
+type Hi interface {
+	Hello() string
+}
+
+func (r *Root) Hello() string { return "Hello " + r.Name }
+
+func main() {
+	var one interface{} = &One{Root{Name: "test2"}}
+	println(one.(Hi).Hello())
+}
+
+// Output:
+// Hello test2

_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/op6.go

@@ -0,0 +1,17 @@
+package main
+
+type T int
+
+func (t T) Error() string { return "T: error" }
+
+var invalidT T
+
+func main() {
+	var err error
+	if err != invalidT {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/op7.go

@@ -0,0 +1,17 @@
+package main
+
+type T int
+
+func (t T) Error() string { return "T: error" }
+
+var invalidT T
+
+func main() {
+	var err error
+	if err > invalidT {
+		println("ok")
+	}
+}
+
+// Error:
+// _test/op7.go:11:5: invalid operation: operator > not defined on error

_test/op8.go

@@ -0,0 +1,21 @@
+package main
+
+type I interface {
+	Get() interface{}
+}
+
+type T struct{}
+
+func (T) Get() interface{} {
+	return nil
+}
+
+func main() {
+	var i I = T{}
+	var ei interface{}
+
+	println(i != ei)
+}
+
+// Output:
+// true

_test/op9.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var i complex128 = 1i
+	var f complex128 = 0.4i
+
+	print(i > f)
+}
+
+// Error:
+// _test/op9.go:7:8: invalid operation: operator > not defined on complex128

_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/range7.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+)
+
+func someChan() <-chan struct{} {
+	c := make(chan struct{}, 1)
+	c <- struct{}{}
+	return c
+}
+
+func main() {
+	for _ = range someChan() {
+		fmt.Println("success")
+		return
+	}
+}
+
+// Output:
+// success

_test/range8.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	for _ = range time.Tick(time.Millisecond) {
+		fmt.Println("success")
+		return
+	}
+}
+
+// Output:
+// success

_test/range9.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var c chan<- struct{} = make(chan struct{})
+
+	for _ = range c {
+	}
+}
+
+// Error:
+// _test/range9.go:6:16: invalid operation: range c receive from send-only channel

_test/recover2.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	println("hello")
+
+	var r interface{} = 1
+	r = recover()
+	if r == nil {
+		println("world")
+	}
+}
+
+// Output:
+// hello
+// world

_test/recover3.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	println("hello")
+
+	var r interface{} = 1
+	r = recover()
+	fmt.Printf("%v\n", r)
+	if r == nil {
+		println("world")
+	}
+	if r != nil {
+		println("exception")
+	}
+}
+
+// Output:
+// hello
+// <nil>
+// world

_test/recover4.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func div(a, b int) (result int) {
+	defer func() {
+		r := recover()
+
+		fmt.Printf("r = %#v\n", r)
+
+		if r != nil {
+			result = 0
+		}
+	}()
+
+	return a / b
+}
+
+func main() {
+	println(div(30, 2))
+}
+
+// Output:
+// r = <nil>
+// 15

_test/redeclaration-global0.go

@@ -0,0 +1,14 @@
+package main
+
+type time int
+
+var time string
+
+func main() {
+	time = "hello"
+	println(time)
+}
+
+// Error:
+// ../_test/redeclaration-global0.go:5:5: time redeclared in this block
+//	previous declaration at ../_test/redeclaration-global0.go:3:6

_test/redeclaration-global1.go

@@ -0,0 +1,12 @@
+package main
+
+var time int
+
+type time string
+
+func main() {
+	var t time = "hello"
+	println(t)
+}
+
+// TODO: expected redeclaration error.

_test/redeclaration-global2.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"time"
+	"time"
+)
+
+func main() {
+	var t time.Time
+	println(t.String())
+}
+
+// Error:
+// ../_test/redeclaration-global2.go:5:2: time/redeclaration-global2.go redeclared in this block

_test/redeclaration-global3.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"time"
+)
+
+var time string
+
+func main() {
+	time = "hello"
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global3.go:7:5: time redeclared in this block

_test/redeclaration-global4.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"time"
+)
+
+type time string
+
+func main() {
+	var t time = "hello"
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global4.go:7:6: time redeclared in this block

_test/redeclaration-global5.go

@@ -0,0 +1,16 @@
+package main
+
+var time int
+
+func time() string {
+	return "hello"
+}
+
+func main() {
+	t := time()
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global5.go:5:6: time redeclared in this block
+//	previous declaration at ../_test/redeclaration-global5.go:3:5

_test/redeclaration-global6.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"time"
+)
+
+func time() string {
+	return "hello"
+}
+
+func main() {
+	t := time()
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global6.go:7:1: time redeclared in this block

_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/redeclaration0.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	type foo struct {
+		yolo string
+	}
+
+	var foo int
+	foo = 2
+	println(foo)
+}
+
+// Error:
+// ../_test/redeclaration0.go:8:6: foo redeclared in this block
+//	previous declaration at ../_test/redeclaration0.go:4:7

_test/redeclaration1.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	var foo string
+
+	var foo int
+	foo = 2
+	println(foo)
+}
+
+// Error:
+// ../_test/redeclaration1.go:6:6: foo redeclared in this block