interp: fix type recursivity detection

Fix the logic to detect recursive struct types, which was giving a false positive.
We now use the local type name  as key in tracker map.

A non-regression test case is included (_test/struct49.go).

This completes #1008.

.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
+    main: ./cmd/yaegi/
-
-    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
 
     goos:
       - darwin
@@ -70,3 +45,19 @@ archives:
         format: zip
     files:
       - LICENSE
+
+brews:
+  - tap:
+      owner: traefik
+      name: homebrew-tap
+    commit_author:
+      name: traefiker
+      email: 30906710+traefiker@users.noreply.github.com
+    folder: Formula
+    homepage: https://github.com/traefik/yaegi
+    description: |
+      Yaegi is Another Elegant Go Interpreter.
+      It powers executable Go scripts and plugins, in embedded interpreters
+      or interactive shells, on top of the Go runtime.
+    test: |
+      system "#{bin}/yaegi version"

.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
+[Issues]: https://github.com/traefik/yaegi/issues
-[Pull Requests]: https://github.com/containous/yaegi/issues
+[Pull Requests]: https://github.com/traefik/yaegi/issues
-[Feature Request]: https://github.com/containous/yaegi/issues/new?template=feature_request.md
+[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,21 +3,28 @@ check:
 	golangci-lint run
 
 # Generate stdlib/syscall/syscall_GOOS_GOARCH.go for all platforms
-gen_all_syscall: cmd/goexports/goexports
+gen_all_syscall: internal/cmd/extract/extract
-	@cd stdlib/syscall && \
+	@for v in $$(go tool dist list); do \
-	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
+internal/cmd/extract/extract:
-	go generate cmd/goexports/goexports.go
+	rm -f internal/cmd/extract/extract
+	go generate ./internal/cmd/extract
 
 generate: gen_all_syscall
 	go generate
 
-tests:
+install:
-	GO111MODULE=off go test -v ./...
+	GOFLAGS=-ldflags=-X=main.version=$$(git describe --tags) go install ./...
-	GO111MODULE=off go test -race ./interp
 
-.PHONY: check gen_all_syscall gen_tests
+tests:
+	go test -v ./...
+	go test -race ./interp
+
+# 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 install

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)
+[![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/containous/yaegi.svg?branch=master)](https://travis-ci.com/containous/yaegi)
+[![Build Status](https://travis-ci.com/traefik/yaegi.svg?branch=master)](https://travis-ci.com/traefik/yaegi)
-[![GoDoc](https://godoc.org/github.com/containous/yaegi?status.svg)](https://godoc.org/github.com/containous/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/traefik/yaegi/interp"
-	"github.com/containous/yaegi/stdlib"
+	"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
 
@@ -122,10 +128,20 @@ Hello World
 >
 ```
 
-Or interpret Go files:
+Note that in interactive mode, all stdlib package are pre-imported,
+you can use them directly:
 
 ```console
-$ yaegi cmd/yaegi/yaegi.go
+$ yaegi
+> reflect.TypeOf(time.Date)
+: func(int, time.Month, int, int, int, int, int, *time.Location) time.Time
+>
+```
+
+Or interpret Go packages, directories or files, including itself:
+
+```console
+$ yaegi -syscall -unsafe -unrestricted github.com/traefik/yaegi/cmd/yaegi
 >
 ```
 
@@ -155,11 +171,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
+- Assembly files (`.s`) are not supported.
-- calling C code is not supported (no virtual "C" package)
+- 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
+- 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
+- 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
+- Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.
 
 ## Contributing
 
@@ -170,7 +186,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
+[docs]: https://godoc.org/github.com/traefik/yaegi
-[license]: https://github.com/containous/yaegi/blob/master/LICENSE
+[license]: https://github.com/traefik/yaegi/blob/master/LICENSE
-[github]: https://github.com/containous/yaegi
+[github]: https://github.com/traefik/yaegi
-[bugs]: https://github.com/containous/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug
+[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/a43.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type T [l1 + l2]int
+
+const (
+	l1 = 2
+	l2 = 3
+)
+
+func main() {
+	fmt.Println(T{})
+}
+
+// Output:
+// [0 0 0 0 0]

_test/a44.go

@@ -0,0 +1,12 @@
+package main
+
+var a = [max]int{}
+
+const max = 32
+
+func main() {
+	println(len(a))
+}
+
+// Output:
+// 32

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

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+type T struct {
+	A int
+	B int
+}
+
+func main() {
+	a := &[]T{
+		{1, 2},
+		{3, 4},
+	}
+	fmt.Println("a:", a)
+	x := &(*a)[1:][0]
+	fmt.Println("x:", x)
+}
+
+// Output:
+// a: &[{1 2} {3 4}]
+// x: &{3 4}

_test/addr2.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"encoding/xml"
+	"fmt"
+)
+
+type Email struct {
+	Where string `xml:"where,attr"`
+	Addr  string
+}
+
+func f(s string, r interface{}) error {
+	return xml.Unmarshal([]byte(s), &r)
+}
+
+func main() {
+	data := `
+		<Email where='work'>
+			<Addr>bob@work.com</Addr>
+		</Email>
+	`
+	v := Email{}
+	err := f(data, &v)
+	fmt.Println(err, v)
+}
+
+// Ouput:
+// <nil> {work bob@work.com}

_test/append1.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+)
+
+func main() {
+	s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
+	s.Scan()
+	println(string(append(s.Bytes(), []byte(" World")...)))
+}
+
+// Output:
+// Hello World

_test/append2.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+)
+
+func main() {
+	s := bufio.NewScanner(bytes.NewReader([]byte("Hello\nTest\nLine3")))
+	s.Scan()
+	println(string(append(s.Bytes(), " World"...)))
+}
+
+// Output:
+// Hello World

_test/assert0.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+)
+
+type MyWriter interface {
+	Write(p []byte) (i int, err error)
+}
+
+type TestStruct struct{}
+
+func (t TestStruct) Write(p []byte) (n int, err error) {
+	return len(p), nil
+}
+
+func usesWriter(w MyWriter) {
+	n, _ := w.Write([]byte("hello world"))
+	fmt.Println(n)
+}
+
+type MyStringer interface {
+	String() string
+}
+
+func usesStringer(s MyStringer) {
+	fmt.Println(s.String())
+}
+
+func main() {
+	aType := reflect.TypeOf((*MyWriter)(nil)).Elem()
+
+	var t interface{}
+	t = TestStruct{}
+	var tw MyWriter
+	var ok bool
+	tw, ok = t.(MyWriter)
+	if !ok {
+		fmt.Println("TestStruct does not implement MyWriter")
+	} else {
+		fmt.Println("TestStruct implements MyWriter")
+		usesWriter(tw)
+	}
+	n, _ := t.(MyWriter).Write([]byte("hello world"))
+	fmt.Println(n)
+	bType := reflect.TypeOf(TestStruct{})
+	fmt.Println(bType.Implements(aType))
+
+	// not redundant with the above, because it goes through a slightly different code path.
+	if _, ok := t.(MyWriter); !ok {
+		fmt.Println("TestStruct does not implement MyWriter")
+		return
+	} else {
+		fmt.Println("TestStruct implements MyWriter")
+	}
+
+	t = 42
+	foo, ok := t.(MyWriter)
+	if !ok {
+		fmt.Println("42 does not implement MyWriter")
+	} else {
+		fmt.Println("42 implements MyWriter")
+	}
+	_ = foo
+
+	if _, ok := t.(MyWriter); !ok {
+		fmt.Println("42 does not implement MyWriter")
+	} else {
+		fmt.Println("42 implements MyWriter")
+	}
+
+	var tt interface{}
+	tt = time.Nanosecond
+	var myD MyStringer
+	myD, ok = tt.(MyStringer)
+	if !ok {
+		fmt.Println("time.Nanosecond does not implement MyStringer")
+	} else {
+		fmt.Println("time.Nanosecond implements MyStringer")
+		usesStringer(myD)
+	}
+	fmt.Println(tt.(MyStringer).String())
+	cType := reflect.TypeOf((*MyStringer)(nil)).Elem()
+	dType := reflect.TypeOf(time.Nanosecond)
+	fmt.Println(dType.Implements(cType))
+
+	if _, ok := tt.(MyStringer); !ok {
+		fmt.Println("time.Nanosecond does not implement MyStringer")
+	} else {
+		fmt.Println("time.Nanosecond implements MyStringer")
+	}
+
+	tt = 42
+	bar, ok := tt.(MyStringer)
+	if !ok {
+		fmt.Println("42 does not implement MyStringer")
+	} else {
+		fmt.Println("42 implements MyStringer")
+	}
+	_ = bar
+
+	if _, ok := tt.(MyStringer); !ok {
+		fmt.Println("42 does not implement MyStringer")
+	} else {
+		fmt.Println("42 implements MyStringer")
+	}
+}
+
+// Output:
+// TestStruct implements MyWriter
+// 11
+// 11
+// true
+// TestStruct implements MyWriter
+// 42 does not implement MyWriter
+// 42 does not implement MyWriter
+// time.Nanosecond implements MyStringer
+// 1ns
+// 1ns
+// true
+// time.Nanosecond implements MyStringer
+// 42 does not implement MyStringer
+// 42 does not implement MyStringer

_test/assert1.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+)
+
+type TestStruct struct{}
+
+func (t TestStruct) String() string {
+	return "hello world"
+}
+
+func main() {
+	aType := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
+
+	var t interface{}
+	t = time.Nanosecond
+	s, ok := t.(fmt.Stringer)
+	if !ok {
+		fmt.Println("time.Nanosecond does not implement fmt.Stringer")
+		return
+	}
+	fmt.Println(s.String())
+	fmt.Println(t.(fmt.Stringer).String())
+	bType := reflect.TypeOf(time.Nanosecond)
+	fmt.Println(bType.Implements(aType))
+
+	// not redundant with the above, because it goes through a slightly different code path.
+	if _, ok := t.(fmt.Stringer); !ok {
+		fmt.Println("time.Nanosecond does not implement fmt.Stringer")
+		return
+	} else {
+		fmt.Println("time.Nanosecond implements fmt.Stringer")
+	}
+
+	t = 42
+	foo, ok := t.(fmt.Stringer)
+	if !ok {
+		fmt.Println("42 does not implement fmt.Stringer")
+	} else {
+		fmt.Println("42 implements fmt.Stringer")
+		return
+	}
+	_ = foo
+
+	if _, ok := t.(fmt.Stringer); !ok {
+		fmt.Println("42 does not implement fmt.Stringer")
+	} else {
+		fmt.Println("42 implements fmt.Stringer")
+		return
+	}
+
+	var tt interface{}
+	tt = TestStruct{}
+	ss, ok := tt.(fmt.Stringer)
+	if !ok {
+		fmt.Println("TestStuct does not implement fmt.Stringer")
+		return
+	}
+	fmt.Println(ss.String())
+	fmt.Println(tt.(fmt.Stringer).String())
+	// TODO(mpl): uncomment when fixed
+	// cType := reflect.TypeOf(TestStruct{})
+	// fmt.Println(cType.Implements(aType))
+
+	if _, ok := tt.(fmt.Stringer); !ok {
+		fmt.Println("TestStuct does not implement fmt.Stringer")
+		return
+	} else {
+		fmt.Println("TestStuct implements fmt.Stringer")
+	}
+}
+
+// Output:
+// 1ns
+// 1ns
+// true
+// time.Nanosecond implements fmt.Stringer
+// 42 does not implement fmt.Stringer
+// 42 does not implement fmt.Stringer
+// hello world
+// hello world
+// TestStuct implements fmt.Stringer

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

@@ -0,0 +1,15 @@
+package main
+
+type H struct {
+	bits uint
+}
+
+func main() {
+	h := &H{8}
+	var x uint = (1 << h.bits) >> 6
+
+	println(x)
+}
+
+// Output:
+// 4

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

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := map[string]*image.Point{
+		"foo": {X: 3, Y: 2},
+		"bar": {X: 4, Y: 5},
+	}
+	fmt.Println(v["foo"], v["bar"])
+}
+
+// Output:
+// (3,2) (4,5)

_test/binstruct_ptr_slice0.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := []*image.Point{
+		{X: 3, Y: 2},
+		{X: 4, Y: 5},
+	}
+	fmt.Println(v)
+}
+
+// Output:
+// [(3,2) (4,5)]

_test/binstruct_slice0.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"image"
+)
+
+func main() {
+	v := []image.Point{
+		{X: 3, Y: 2},
+	}
+	fmt.Println(v)
+}
+
+// Output:
+// [(3,2)]

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

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+type T struct {
+	b []byte
+}
+
+func main() {
+	t := T{nil}
+	fmt.Println(t)
+}
+
+// Output:
+// {[]}

_test/composite15.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"fmt"
+)
+
+func interfaceAsInts() {
+	var a interface{}
+	b := 2
+	c := 3
+	a = []int{b, c}
+
+	d, ok := a.([]int)
+	if !ok {
+		println("nope")
+		return
+	}
+
+	for _, v := range d {
+		fmt.Println(v)
+	}
+}
+
+func interfaceAsInterfaces() {
+	var a, b, c interface{}
+	b = 2
+	c = 3
+	a = []interface{}{b, c}
+
+	d, ok := a.([]interface{})
+	if !ok {
+		println("nope")
+		return
+	}
+
+	for _, v := range d {
+		fmt.Println(v)
+	}
+}
+
+func main() {
+	interfaceAsInts()
+	interfaceAsInterfaces()
+}
+
+// Output:
+// 2
+// 3
+// 2
+// 3

_test/composite16.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"net/url"
+)
+
+func main() {
+	body := url.Values{
+		"Action": {"none"},
+	}
+	fmt.Println(body)
+}
+
+// Output:
+// map[Action:[none]]

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

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+var t [7/3]int
+
+func main() {
+	t[0] = 3/2
+	t[1] = 5/2
+	fmt.Println(t)
+}
+
+// Output:
+// [1 2]

_test/const18.go

@@ -0,0 +1,11 @@
+package main
+
+import "time"
+
+func main() {
+	a := int64(time.Second)
+	println(a)
+}
+
+// Output:
+// 1000000000

_test/const19.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func get10Hours() time.Duration {
+	return 10 * time.Hour
+}
+
+func main() {
+	fmt.Println(get10Hours().String())
+}
+
+// Output:
+// 10h0m0s

_test/const20.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+const maxLen = int64(int(^uint(0) >> 1))
+
+func main() {
+	fmt.Println(maxLen)
+}
+
+// Output:
+// 9223372036854775807

_test/const21.go

@@ -0,0 +1,12 @@
+package main
+
+const a = 64
+
+var b uint = a * a / 2
+
+func main() {
+	println(b)
+}
+
+// Output:
+// 2048

_test/const22.go

@@ -0,0 +1,15 @@
+package main
+
+const (
+	numDec uint8 = (1 << iota) / 2
+	numHex
+	numOct
+	numFloat
+)
+
+func main() {
+	println(13 & (numHex | numOct))
+}
+
+// Output:
+// 1

_test/convert0.go

@@ -0,0 +1,21 @@
+package main
+
+type T struct {
+	v int
+}
+
+type comparator func(T, T) bool
+
+func sort(items []T, comp comparator) {
+	println("in sort")
+}
+
+func compT(t0, t1 T) bool { return t0.v < t1.v }
+
+func main() {
+	a := []T{}
+	sort(a, comparator(compT))
+}
+
+// Output:
+// in sort

_test/convert1.go

@@ -0,0 +1,17 @@
+package main
+
+import "strconv"
+
+type atoidef func(s string) (int, error)
+
+func main() {
+	stdatoi := atoidef(strconv.Atoi)
+	n, err := stdatoi("7")
+	if err != nil {
+		panic(err)
+	}
+	println(n)
+}
+
+// Output:
+// 7

_test/convert2.go

@@ -0,0 +1,19 @@
+package main
+
+import "bufio"
+
+func fakeSplitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	return 7, nil, nil
+}
+
+func main() {
+	splitfunc := bufio.SplitFunc(fakeSplitFunc)
+	n, _, err := splitfunc(nil, true)
+	if err != nil {
+		panic(err)
+	}
+	println(n)
+}
+
+// Output:
+// 7

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

@@ -0,0 +1,16 @@
+package main
+
+func f() int { println("in f"); return 1 }
+
+func main() {
+	for i := f(); ; {
+		println("in loop")
+		if i > 0 {
+			break
+		}
+	}
+}
+
+// Output:
+// in f
+// in loop

_test/for16.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	max := 1
+	for ; ; max-- {
+		if max == 0 {
+			break
+		}
+		println("in for")
+	}
+	println("bye")
+}
+
+// Output:
+// in for
+// bye

_test/fun23.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x int) { return x }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// 3:17: too many arguments to return

_test/fun24.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x int) (int, int) { return x, "foo" }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// cannot use "foo" (type stringT) as type intT in return argument

_test/fun25.go

@@ -0,0 +1,10 @@
+package main
+
+func f(x string) (a int, b int) { return x, 5 }
+
+func main() {
+	print("hello")
+}
+
+// Error:
+// cannot use x (type stringT) as type intT in return argument

_test/fun26.go

@@ -0,0 +1,17 @@
+package main
+
+type F func() (int, error)
+
+func f1() (int, error) { return 3, nil }
+
+func f2(a string, f F) {
+	c, _ := f()
+	println(a, c)
+}
+
+func main() {
+	f2("hello", F(f1))
+}
+
+// Output:
+// hello 3

_test/goto1.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	if true {
+		goto here
+	}
+here:
+	println("ok")
+}
+
+// Output:
+// ok

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

@@ -0,0 +1,32 @@
+package main
+
+type Doer interface {
+	Do() error
+}
+
+type T struct {
+	Name string
+}
+
+func (t *T) Do() error { println("in do"); return nil }
+
+func f() (Doer, error) { return &T{"truc"}, nil }
+
+type Ev struct {
+	doer func() (Doer, error)
+}
+
+func (e *Ev) do() {
+	d, _ := e.doer()
+	d.Do()
+}
+
+func main() {
+	e := &Ev{f}
+	println(e != nil)
+	e.do()
+}
+
+// Output:
+// true
+// in do

_test/interface48.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type I1 interface{ A }
+
+type A = I2
+
+type I2 interface{ F() I1 }
+
+func main() {
+	var i I1
+	fmt.Println(i)
+}
+
+// Output:
+// <nil>

_test/interface49.go

@@ -0,0 +1,45 @@
+package main
+
+type Descriptor interface {
+	ParentFile() FileDescriptor
+}
+
+type FileDescriptor interface {
+	Enums() EnumDescriptors
+	Services() ServiceDescriptors
+}
+
+type EnumDescriptors interface {
+	Get(i int) EnumDescriptor
+}
+
+type EnumDescriptor interface {
+	Values() EnumValueDescriptors
+}
+
+type EnumValueDescriptors interface {
+	Get(i int) EnumValueDescriptor
+}
+
+type EnumValueDescriptor interface {
+	Descriptor
+}
+
+type ServiceDescriptors interface {
+	Get(i int) ServiceDescriptor
+}
+
+type ServiceDescriptor interface {
+	Descriptor
+	isServiceDescriptor
+}
+
+type isServiceDescriptor interface{ ProtoType(ServiceDescriptor) }
+
+func main() {
+	var d Descriptor
+	println(d == nil)
+}
+
+// Output:
+// true

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

@@ -0,0 +1,40 @@
+package main
+
+type TypeA struct {
+	B TypeB
+}
+
+type TypeB struct {
+	C1 *TypeC
+	C2 *TypeC
+}
+
+type TypeC struct {
+	Val string
+	D   *TypeD
+	D2  *TypeD
+}
+
+type TypeD struct {
+	Name string
+}
+
+func build() *TypeA {
+	return &TypeA{
+		B: TypeB{
+			C2: &TypeC{Val: "22"},
+		},
+	}
+}
+
+func Bar(s string) string {
+	a := build()
+	return s + "-" + a.B.C2.Val
+}
+
+func main() {
+	println(Bar("test"))
+}
+
+// Output:
+// test-22

_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