interp: fix redeclarations containing a blank variable

In [short variable declarations](https://go.dev/ref/spec#Short_variable_declarations),
The reuse of existing symbols is possible only if a new variable is defined,
otherwise a new symbol must be created, which was not the case in the issue.

Search for new symbols and correctly ignore blank variables.

Fixes #1434.

.github/workflows/go-cross.yml

@@ -17,7 +17,7 @@ jobs:
 
     strategy:
       matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ 1.18, 1.19 ]
         os: [ubuntu-latest, macos-latest, windows-latest]
 
         include:
@@ -34,6 +34,7 @@ jobs:
         uses: actions/setup-go@v2
         with:
           go-version: ${{ matrix.go-version }}
+          stable: true
 
       # https://github.com/marketplace/actions/checkout
       - name: Checkout code

.github/workflows/main.yml

@@ -7,8 +7,8 @@ on:
   pull_request:
 
 env:
-  GO_VERSION: 1.17
-  GOLANGCI_LINT_VERSION: v1.41.1
+  GO_VERSION: 1.18
+  GOLANGCI_LINT_VERSION: v1.47.1
 
 jobs:
 
@@ -45,12 +45,13 @@ jobs:
     needs: linting
     strategy:
       matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ 1.18, 1.19 ]
     steps:
       - name: Set up Go ${{ matrix.go-version }}
         uses: actions/setup-go@v2
         with:
           go-version: ${{ matrix.go-version }}
+          stable: true
 
       - name: Check out code
         uses: actions/checkout@v2
@@ -75,13 +76,14 @@ jobs:
         working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
     strategy:
       matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ 1.18, 1.19 ]
 
     steps:
       - name: Set up Go ${{ matrix.go-version }}
         uses: actions/setup-go@v2
         with:
           go-version: ${{ matrix.go-version }}
+          stable: true
 
       - name: Check out code
         uses: actions/checkout@v2

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       - v[0-9]+.[0-9]+*
 
 env:
-  GO_VERSION: 1.17
+  GO_VERSION: 1.19
 
 jobs:
 

.golangci.toml

@@ -27,6 +27,7 @@
     "scopelint", # deprecated
     "interfacer", # deprecated
     "maligned", # deprecated
+    "exhaustivestruct", # deprecated
     "lll",
     "gas",
     "dupl",
@@ -49,10 +50,15 @@
     "wrapcheck",
     "nestif",
     "exhaustive",
-    "exhaustivestruct",
+    "exhaustruct",
     "forbidigo",
     "ifshort",
     "forcetypeassert",
+    "varnamelen",
+    "nosnakecase",
+    "nonamedreturns",
+    "nilnil",
+    "maintidx",
     "errorlint", # TODO: must be reactivate before fixes
   ]
 
@@ -75,6 +81,12 @@
   [[issues.exclude-rules]]
     path = "interp/interp.go"
     text = "`out` can be `io.Writer`"
+  [[issues.exclude-rules]]
+    path = "interp/interp.go"
+    text = "`Panic` should conform to the `XxxError` format"
   [[issues.exclude-rules]]
     path = "interp/interp_eval_test.go"
     linters = ["thelper"]
+  [[issues.exclude-rules]]
+    path = "interp/debugger.go"
+    linters = ["containedctx"]

README.md

@@ -18,7 +18,7 @@ It powers executable Go scripts and plugins, in embedded interpreters or interac
 * Works everywhere Go works
 * All Go & runtime resources accessible from script (with control)
 * Security: `unsafe` and `syscall` packages neither used nor exported by default
-* Support Go 1.16 and Go 1.17 (the latest 2 major releases)
+* Support Go 1.18 and Go 1.19 (the latest 2 major releases)
 
 ## Install
 

_test/a29.go

@@ -6,16 +6,18 @@ const (
 	zero = iota
 	one
 	two
+	three
 )
 
 func main() {
 	a := [...]string{
-		zero: "zero",
-		one:  "one",
-		two:  "two",
+		zero:      "zero",
+		one:       "one",
+		three:     "three",
+		three + 2: "five",
 	}
 	fmt.Printf("%v %T\n", a, a)
 }
 
 // Output:
-// [zero one two] [3]string
+// [zero one  three  five] [6]string

_test/alias3/alias3.go

@@ -1,5 +1,10 @@
 package alias3
 
+import (
+	"fmt"
+	"net/http"
+)
+
 type T struct {
 	A string
 }
@@ -7,3 +12,20 @@ type T struct {
 func (t *T) Print() {
 	println(t.A)
 }
+
+type A http.Header
+
+func (a A) ForeachKey() error {
+	for k, vals := range a {
+		for _, v := range vals {
+			fmt.Println(k, v)
+		}
+
+	}
+
+	return nil
+}
+
+func (a A) Set(k string, v []string) {
+	a[k] = v
+}

_test/alias4.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type A http.Header
+
+func (a A) Test1() {
+	fmt.Println("test1")
+}
+
+type B A
+
+func (b B) Test2() {
+	fmt.Println("test2")
+}
+
+func (b B) Test3() {
+	for k, vals := range b {
+		for _, v := range vals {
+			fmt.Println(k, v)
+		}
+	}
+}
+
+func main() {
+	b := B{}
+
+	b.Test2()
+	b["test"] = []string{"a", "b"}
+	b.Test3()
+}
+
+// Output:
+// test2
+// test a
+// test b

_test/assert2.go

@@ -5,8 +5,8 @@ import (
 	"sync"
 )
 
-// Defined an interface of stringBuilder that compatible with
-// strings.Builder(go 1.10) and bytes.Buffer(< go 1.10)
+// Define an interface of stringBuilder that is compatible with
+// strings.Builder(go 1.10) and bytes.Buffer(< go 1.10).
 type stringBuilder interface {
 	WriteRune(r rune) (n int, err error)
 	WriteString(s string) (int, error)

_test/assign17.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+	s := make([]map[string]string, 0)
+	m := make(map[string]string)
+	m["m1"] = "m1"
+	m["m2"] = "m2"
+	s = append(s, m)
+	tmpStr := "start"
+	println(tmpStr)
+	for _, v := range s {
+		tmpStr, ok := v["m1"]
+		println(tmpStr, ok)
+	}
+	println(tmpStr)
+}
+
+// Output:
+// start
+// m1 true
+// start

_test/assign18.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+	s := make([]map[string]string, 0)
+	m := make(map[string]string)
+	m["m1"] = "m1"
+	m["m2"] = "m2"
+	s = append(s, m)
+	tmpStr := "start"
+	println(tmpStr)
+	for _, v := range s {
+		tmpStr, _ := v["m1"]
+		println(tmpStr)
+	}
+	println(tmpStr)
+}
+
+// Output:
+// start
+// m1
+// start

_test/break0.go

@@ -0,0 +1,24 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+OuterLoop:
+	println("Boo")
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				break OuterLoop
+			case false:
+				println(foo)
+			}
+		}
+	}
+}
+
+// Error:
+// 15:5: invalid break label OuterLoop

_test/break1.go

@@ -0,0 +1,24 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+OuterLoop:
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				break OuterLoop
+			case false:
+				println(foo)
+			}
+		}
+	}
+}
+
+// Output:
+// I:  0
+// true

_test/break2.go

@@ -0,0 +1,25 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+OuterLoop:
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				break OuterLoop
+			case false:
+				println(foo)
+				continue OuterLoop
+			}
+		}
+	}
+}
+
+// Output:
+// I:  0
+// true

_test/break3.go

@@ -0,0 +1,27 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+	goto OuterLoop
+	println("Boo")
+OuterLoop:
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				break OuterLoop
+			case false:
+				println(foo)
+				goto OuterLoop
+			}
+		}
+	}
+}
+
+// Output:
+// I:  0
+// true

_test/cli1.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net"
 	"net/http"
@@ -13,7 +13,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cli2.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net"
 	"net/http"
@@ -21,7 +21,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cli3.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
@@ -13,7 +13,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cli4.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
@@ -40,7 +40,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cli5.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
@@ -40,7 +40,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cli6.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
@@ -41,7 +41,7 @@ func client(uri string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/cont2.go

@@ -0,0 +1,26 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+OuterLoop:
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				continue OuterLoop
+			case false:
+				println(foo)
+			}
+		}
+	}
+}
+
+// Output:
+// I:  0
+// true
+// I:  1
+// true

_test/cont3.go

@@ -0,0 +1,24 @@
+package main
+
+func main() {
+	n := 2
+	m := 2
+	foo := true
+OuterLoop:
+	println("boo")
+	for i := 0; i < n; i++ {
+		println("I: ", i)
+		for j := 0; j < m; j++ {
+			switch foo {
+			case true:
+				println(foo)
+				continue OuterLoop
+			case false:
+				println(foo)
+			}
+		}
+	}
+}
+
+// Error:
+// 15:5: invalid continue label OuterLoop

_test/file_access.go

@@ -2,12 +2,11 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 )
 
 func main() {
-	file, err := ioutil.TempFile("", "yeagibench")
+	file, err := os.CreateTemp("", "yeagibench")
 	if err != nil {
 		panic(err)
 	}
@@ -23,7 +22,7 @@ func main() {
 		panic(err)
 	}
 
-	b, err := ioutil.ReadFile(file.Name())
+	b, err := os.ReadFile(file.Name())
 	if err != nil {
 		panic(err)
 	}

_test/gen1.go

@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+// SumInts adds together the values of m.
+func SumInts(m map[string]int64) int64 {
+	var s int64
+	for _, v := range m {
+		s += v
+	}
+	return s
+}
+
+// SumFloats adds together the values of m.
+func SumFloats(m map[string]float64) float64 {
+	var s float64
+	for _, v := range m {
+		s += v
+	}
+	return s
+}
+
+func main() {
+	// Initialize a map for the integer values
+	ints := map[string]int64{
+		"first":  34,
+		"second": 12,
+	}
+
+	// Initialize a map for the float values
+	floats := map[string]float64{
+		"first":  35.98,
+		"second": 26.99,
+	}
+
+	fmt.Printf("Non-Generic Sums: %v and %v\n",
+		SumInts(ints),
+		SumFloats(floats))
+}

_test/gen10.go

@@ -0,0 +1,12 @@
+package main
+
+func genFunc() (f func()) {
+	return f
+}
+
+func main() {
+	println(genFunc() == nil)
+}
+
+// Output:
+// true

_test/gen2.go

@@ -0,0 +1,34 @@
+package main
+
+import "fmt"
+
+// SumIntsOrFloats sums the values of map m. It supports both int64 and float64
+// as types for map values.
+func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
+	var s V
+	for _, v := range m {
+		s += v
+	}
+	return s
+}
+
+func main() {
+	// Initialize a map for the integer values
+	ints := map[string]int64{
+		"first":  34,
+		"second": 12,
+	}
+
+	// Initialize a map for the float values
+	floats := map[string]float64{
+		"first":  35.98,
+		"second": 26.99,
+	}
+
+	fmt.Printf("Generic Sums: %v and %v\n",
+		SumIntsOrFloats[string, int64](ints),
+		SumIntsOrFloats[string, float64](floats))
+}
+
+// Output:
+// Generic Sums: 46 and 62.97

_test/gen3.go

@@ -0,0 +1,22 @@
+package main
+
+type Number interface {
+	int | int64 | ~float64
+}
+
+func Sum[T Number](numbers []T) T {
+	var total T
+	for _, x := range numbers {
+		total += x
+	}
+	return total
+}
+
+func main() {
+	xs := []int{3, 5, 10}
+	total := Sum(xs)
+	println(total)
+}
+
+// Output:
+// 18

_test/gen4.go

@@ -0,0 +1,42 @@
+package main
+
+import "fmt"
+
+type List[T any] struct {
+	head, tail *element[T]
+}
+
+// A recursive generic type.
+type element[T any] struct {
+	next *element[T]
+	val  T
+}
+
+func (lst *List[T]) Push(v T) {
+	if lst.tail == nil {
+		lst.head = &element[T]{val: v}
+		lst.tail = lst.head
+	} else {
+		lst.tail.next = &element[T]{val: v}
+		lst.tail = lst.tail.next
+	}
+}
+
+func (lst *List[T]) GetAll() []T {
+	var elems []T
+	for e := lst.head; e != nil; e = e.next {
+		elems = append(elems, e.val)
+	}
+	return elems
+}
+
+func main() {
+	lst := List[int]{}
+	lst.Push(10)
+	lst.Push(13)
+	lst.Push(23)
+	fmt.Println("list:", lst.GetAll())
+}
+
+// Output:
+// list: [10 13 23]

_test/gen5.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+type Set[Elem comparable] struct {
+	m map[Elem]struct{}
+}
+
+func Make[Elem comparable]() Set[Elem] {
+	return Set[Elem]{m: make(map[Elem]struct{})}
+}
+
+func (s Set[Elem]) Add(v Elem) {
+	s.m[v] = struct{}{}
+}
+
+func main() {
+	s := Make[int]()
+	s.Add(1)
+	fmt.Println(s)
+}
+
+// Output:
+// {map[1:{}]}

_test/gen6.go

@@ -0,0 +1,19 @@
+package main
+
+func MapKeys[K comparable, V any](m map[K]V) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
+
+func main() {
+	var m = map[int]string{1: "2", 2: "4", 4: "8"}
+
+	// Test type inference
+	println(len(MapKeys(m)))
+}
+
+// Output:
+// 3

_test/gen7.go

@@ -0,0 +1,19 @@
+package main
+
+func MapKeys[K comparable, V any](m map[K]V) []K {
+	r := make([]K, 0, len(m))
+	for k := range m {
+		r = append(r, k)
+	}
+	return r
+}
+
+func main() {
+	var m = map[int]string{1: "2", 2: "4", 4: "8"}
+
+	// Test type inference
+	println(len(MapKeys))
+}
+
+// Error:
+// invalid argument for len

_test/gen8.go

@@ -0,0 +1,15 @@
+package main
+
+type Float interface {
+	~float32 | ~float64
+}
+
+func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
+
+func main() {
+	var x, y int = 1, 2
+	println(add(x, y))
+}
+
+// Error:
+// int does not implement main.Float

_test/gen9.go

@@ -0,0 +1,14 @@
+package main
+
+type Float interface {
+	~float32 | ~float64
+}
+
+func add[T Float](a, b T) float64 { return float64(a) + float64(b) }
+
+func main() {
+	println(add(1, 2))
+}
+
+// Error:
+// untyped int does not implement main.Float

_test/io2.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"strings"
 )
@@ -10,7 +10,7 @@ import (
 func main() {
 	r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
 
-	b, err := ioutil.ReadAll(r)
+	b, err := io.ReadAll(r)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/issue-1187.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"io"
-	"io/ioutil"
 	"os"
 )
 
@@ -13,7 +12,7 @@ type sink interface {
 
 func newSink() sink {
 	// return os.Stdout	// Stdout is special in yaegi tests
-	file, err := ioutil.TempFile("", "yaegi-test.*")
+	file, err := os.CreateTemp("", "yaegi-test.*")
 	if err != nil {
 		panic(err)
 	}

_test/issue-1260.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+type WriteSyncer interface {
+	io.Writer
+	Sync() error
+}
+
+type Sink interface {
+	WriteSyncer
+	io.Closer
+}
+
+func newFileSink(path string) (Sink, error) {
+	return os.OpenFile(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
+}
+
+type Sink1 struct{ name string }
+
+func (s Sink1) Write(b []byte) (int, error) { println("in Write"); return 0, nil }
+func (s Sink1) Sync() error                 { println("in Sync"); return nil }
+func (s Sink1) Close() error                { println("in Close", s.name); return nil }
+func newS1(name string) Sink                { return Sink1{name} }
+func newS1p(name string) Sink               { return &Sink1{name} }
+
+type Sink2 struct{ name string }
+
+func (s *Sink2) Write(b []byte) (int, error) { println("in Write"); return 0, nil }
+func (s *Sink2) Sync() error                 { println("in Sync"); return nil }
+func (s *Sink2) Close() error                { println("in Close", s.name); return nil }
+func newS2(name string) Sink                 { return Sink1{name} }
+
+func main() {
+	tmpfile, err := os.CreateTemp("", "xxx")
+	if err != nil {
+		panic(err)
+	}
+	defer os.Remove(tmpfile.Name())
+	closers := []io.Closer{}
+	sink, err := newFileSink(tmpfile.Name())
+	if err != nil {
+		panic(err)
+	}
+	closers = append(closers, sink)
+
+	s1p := newS1p("ptr")
+	s1 := newS1("struct")
+	s2 := newS2("ptr2")
+	closers = append(closers, s1p, s1, s2)
+	for _, closer := range closers {
+		fmt.Println(closer.Close())
+	}
+}
+
+// Output:
+// <nil>
+// in Close ptr
+// <nil>
+// in Close struct
+// <nil>
+// in Close ptr2
+// <nil>

_test/issue-1276.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"flag"
+)
+
+type customFlag struct{}
+
+func (cf customFlag) String() string {
+	return "custom flag"
+}
+
+func (cf customFlag) Set(string) error {
+	return nil
+}
+
+func main() {
+	flag.Var(customFlag{}, "cf", "custom flag")
+	flag.Parse()
+	println("Hello, playground")
+}
+
+// Output:
+// Hello, playground

_test/issue-1280.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"io"
+	"log"
+	"os"
+)
+
+type DBReader interface {
+	io.ReadCloser
+	io.ReaderAt
+}
+
+type DB struct {
+	f DBReader
+}
+
+func main() {
+	f, err := os.Open("/dev/null")
+	if err != nil {
+		log.Fatal(err)
+	}
+	d := &DB{f}
+	data := make([]byte, 1)
+	_, _ = d.f.ReadAt(data, 0)
+	println("bye")
+}
+
+// Output:
+// bye

_test/issue-1285.go

@@ -0,0 +1,25 @@
+package main
+
+type (
+	T1 struct{ Path [12]int8 }
+	T2 struct{ Path *[12]int8 }
+)
+
+var (
+	t11 = &T1{}
+	t21 = &T2{}
+)
+
+func main() {
+	b := [12]byte{}
+	t12 := &T1{}
+	t22 := &T2{}
+	b11 := (*[len(t11.Path)]byte)(&b)
+	b12 := (*[len(t12.Path)]byte)(&b)
+	b21 := (*[len(t21.Path)]byte)(&b)
+	b22 := (*[len(t22.Path)]byte)(&b)
+	println(len(b11), len(b12), len(b21), len(b22))
+}
+
+// Output:
+// 12 12 12 12

_test/issue-1288.go

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	println("Hi")
+	goto done
+done:
+}
+
+// Output:
+// Hi

_test/issue-1300.go

@@ -0,0 +1,20 @@
+package main
+
+const buflen = 512
+
+type T struct {
+	buf []byte
+}
+
+func f(t *T) { *t = T{buf: make([]byte, 0, buflen)} }
+
+func main() {
+	s := T{}
+	println(cap(s.buf))
+	f(&s)
+	println(cap(s.buf))
+}
+
+// Output:
+// 0
+// 512

_test/issue-1304.go

@@ -0,0 +1,16 @@
+package main
+
+type Node struct {
+	Name  string
+	Alias *Node
+	Child []*Node
+}
+
+func main() {
+	n := &Node{Name: "parent"}
+	n.Child = append(n.Child, &Node{Name: "child"})
+	println(n.Name, n.Child[0].Name)
+}
+
+// Output:
+// parent child

_test/issue-1306.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func check() (result bool, err error) {
+	return true, nil
+}
+
+func main() {
+	result, error := check()
+	fmt.Println(result, error)
+}
+
+// Output:
+// true <nil>

_test/issue-1308.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+type test struct {
+	v interface{}
+	s string
+}
+
+type T struct {
+	name string
+}
+
+func main() {
+	t := []test{
+		{
+			v: []interface{}{
+				T{"hello"},
+			},
+			s: "world",
+		},
+	}
+	fmt.Println(t)
+}
+
+// Output:
+// [{[{hello}] world}]

_test/issue-1311.go

@@ -0,0 +1,19 @@
+package main
+
+type T struct {
+	v interface{}
+}
+
+func f() (ret int64, err error) {
+	ret += 2
+	return
+}
+
+func main() {
+	t := &T{}
+	t.v, _ = f()
+	println(t.v.(int64))
+}
+
+// Output:
+// 2

_test/issue-1315.go

@@ -0,0 +1,32 @@
+package main
+
+type Intf interface {
+	M()
+}
+
+type T struct {
+	s string
+}
+
+func (t *T) M() { println("in M") }
+
+func f(i interface{}) {
+	switch j := i.(type) {
+	case Intf:
+		j.M()
+	default:
+		println("default")
+	}
+}
+
+func main() {
+	var i Intf
+	var k interface{} = 1
+	i = &T{"hello"}
+	f(i)
+	f(k)
+}
+
+// Output:
+// in M
+// default

_test/issue-1320.go

@@ -0,0 +1,29 @@
+package main
+
+type Pooler interface {
+	Get() string
+}
+
+type baseClient struct {
+	connPool Pooler
+}
+
+type connPool struct {
+	name string
+}
+
+func (c *connPool) Get() string { return c.name }
+
+func newBaseClient(i int, p Pooler) *baseClient {
+	return &baseClient{connPool: p}
+}
+
+func newConnPool() *connPool { return &connPool{name: "connPool"} }
+
+func main() {
+	b := newBaseClient(0, newConnPool())
+	println(b.connPool.(*connPool).name)
+}
+
+// Output:
+// connPool

_test/issue-1326.go

@@ -0,0 +1,42 @@
+package main
+
+type Option interface {
+	apply(*T)
+}
+
+type T struct {
+	s string
+}
+
+type opt struct {
+	name string
+}
+
+func (o *opt) apply(t *T) {
+	println(o.name)
+}
+
+func BuildOptions() []Option {
+	return []Option{
+		&opt{"opt1"},
+		&opt{"opt2"},
+	}
+}
+
+func NewT(name string, options ...Option) *T {
+	t := &T{name}
+	for _, opt := range options {
+		opt.apply(t)
+	}
+	return t
+}
+
+func main() {
+	t := NewT("hello", BuildOptions()...)
+	println(t.s)
+}
+
+// Output:
+// opt1
+// opt2
+// hello

_test/issue-1328.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"crypto/sha1"
+	"encoding/hex"
+)
+
+func main() {
+	script := "hello"
+	sumRaw := sha1.Sum([]byte(script))
+	sum := hex.EncodeToString(sumRaw[:])
+	println(sum)
+}
+
+// Output:
+// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d

_test/issue-1330.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"net"
+)
+
+type wrappedConn struct {
+	net.Conn
+}
+
+func main() {
+	_, err := net.Listen("tcp", "127.0.0.1:49153")
+	if err != nil {
+		panic(err)
+	}
+
+	dialer := &net.Dialer{
+		LocalAddr: &net.TCPAddr{
+			IP:   net.ParseIP("127.0.0.1"),
+			Port: 0,
+		},
+	}
+
+	conn, err := dialer.Dial("tcp", "127.0.0.1:49153")
+	if err != nil {
+		panic(err)
+	}
+	defer conn.Close()
+
+	t := &wrappedConn{conn}
+	var w io.Writer = t
+	if n, err := w.Write([]byte("hello")); err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println(n)
+	}
+}
+
+// Output:
+// 5

_test/issue-1332.go

@@ -0,0 +1,17 @@
+package main
+
+func run(fn func(name string)) { fn("test") }
+
+type T2 struct {
+	name string
+}
+
+func (t *T2) f(s string) { println(s, t.name) }
+
+func main() {
+	t2 := &T2{"foo"}
+	run(t2.f)
+}
+
+// Output:
+// test foo

_test/issue-1333.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+)
+
+func mock(name string) http.HandlerFunc {
+	return func(rw http.ResponseWriter, req *http.Request) {
+		fmt.Fprint(rw, "Hello ", name)
+	}
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		panic(err)
+	}
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(string(body))
+}
+
+func main() {
+	mux := http.NewServeMux()
+	server := httptest.NewServer(mux)
+	defer server.Close()
+	mux.Handle("/", mock("foo"))
+	client(server.URL)
+}
+
+// Output:
+// Hello foo

_test/issue-1337.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"io"
+	"os"
+)
+
+func f(i interface{}) {
+	switch at := i.(type) {
+	case int, int8:
+		println("integer", at)
+	case io.Reader:
+		println("reader")
+	}
+	println("bye")
+}
+
+func main() {
+	var fd *os.File
+	var r io.Reader = fd
+	f(r)
+}
+
+// Output:
+// reader
+// bye

_test/issue-1342.go

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

_test/issue-1344.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	var m = map[string]interface{}{"a": "a"}
+	a, _ := m["a"]
+	b, ok := a.(string)
+	fmt.Println("a:", a, ", b:", b, ", ok:", ok)
+}
+
+// Output:
+// a: a , b: a , ok: true

_test/issue-1354.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+	println(test()) // Go prints true, Yaegi false
+}
+
+func test() bool {
+	if true {
+		goto label
+	}
+	goto label
+label:
+	println("Go continues here")
+	return true
+	println("Yaegi goes straight to this return (this line is never printed)")
+	return false
+}
+
+// Output:
+// Go continues here
+// true

_test/issue-1355.go

@@ -0,0 +1,22 @@
+package main
+
+import "github.com/traefik/yaegi/_test/p2"
+
+func f(i interface{}) {
+	_, ok := i.(p2.I)
+	println("ok:", ok)
+}
+
+func main() {
+	var v *p2.T
+	var i interface{}
+
+	i = v
+	_, ok := i.(p2.I)
+	println("ok:", ok)
+	f(v)
+}
+
+// Output:
+// ok: true
+// ok: true

_test/issue-1360.go

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

_test/issue-1361.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+type obj struct {
+	num float64
+}
+
+type Fun func(o *obj) (r *obj, err error)
+
+func numFun(fn func(f float64) float64) Fun {
+	return func(o *obj) (*obj, error) {
+		return &obj{fn(o.num)}, nil
+	}
+}
+
+func main() {
+	f := numFun(math.Cos)
+	r, err := f(&obj{})
+	fmt.Println(r, err)
+}
+
+// Output:
+// &{1} <nil>

_test/issue-1364.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	var value interface{}
+	var err error
+	value, err = strconv.ParseFloat("123", 64)
+	fmt.Println(value, err)
+}
+
+// Output:
+// 123 <nil>

_test/issue-1365.go

@@ -0,0 +1,18 @@
+package main
+
+func genInt() (int, error) { return 3, nil }
+
+func getInt() (value int) {
+	value, err := genInt()
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+func main() {
+	println(getInt())
+}
+
+// Output:
+// 3

_test/issue-1368.go

@@ -0,0 +1,16 @@
+package main
+
+const dollar byte = 36
+
+func main() {
+	var c byte = 36
+	switch true {
+	case c == dollar:
+		println("ok")
+	default:
+		println("not ok")
+	}
+}
+
+// Output:
+// ok

_test/issue-1371.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+type node struct {
+	parent *node
+	child  []*node
+	key    string
+}
+
+func main() {
+	root := &node{key: "root"}
+	root.child = nil
+	fmt.Println("root:", root)
+}
+
+// Output:
+// root: &{<nil> [] root}

_test/issue-1373.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+func NewBadExpr() ast.Expr {
+	return &ast.BadExpr{}
+}
+
+func main() {
+	fmt.Printf("%T\n", NewBadExpr().(*ast.BadExpr))
+}
+
+// Output:
+// *ast.BadExpr

_test/issue-1375.go

@@ -0,0 +1,38 @@
+package main
+
+import "fmt"
+
+type Option func(*Struct)
+
+func WithOption(opt string) Option {
+	return func(s *Struct) {
+		s.opt = opt
+	}
+}
+
+type Struct struct {
+	opt string
+}
+
+func New(opts ...Option) *Struct {
+	s := new(Struct)
+	for _, opt := range opts {
+		opt(s)
+	}
+	return s
+}
+
+func (s *Struct) ShowOption() {
+	fmt.Println(s.opt)
+}
+
+func main() {
+	opts := []Option{
+		WithOption("test"),
+	}
+	s := New(opts...)
+	s.ShowOption()
+}
+
+// Output:
+// test

_test/issue-1378.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	t, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
+	if err != nil {
+		panic(err)
+	}
+	fn := func() error {
+		_, err := t.GobEncode()
+		return err
+	}
+	fmt.Println(fn())
+}
+
+// Output:
+// <nil>

_test/issue-1381.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func main() {
+	var bufPtrOne *bytes.Buffer
+	var bufPtrTwo *bytes.Buffer
+	var bufPtrThree *bytes.Buffer
+	var bufPtrFour *bytes.Buffer
+
+	for i := 0; i < 2; i++ {
+		bufOne := bytes.Buffer{}
+		bufTwo := &bytes.Buffer{}
+		var bufThree bytes.Buffer
+		bufFour := new(bytes.Buffer)
+
+		if bufPtrOne == nil {
+			bufPtrOne = &bufOne
+		} else if bufPtrOne == &bufOne {
+			fmt.Println("bufOne was not properly redeclared")
+		} else {
+			fmt.Println("bufOne is properly redeclared")
+		}
+
+		if bufPtrTwo == nil {
+			bufPtrTwo = bufTwo
+		} else if bufPtrTwo == bufTwo {
+			fmt.Println("bufTwo was not properly redeclared")
+		} else {
+			fmt.Println("bufTwo is properly redeclared")
+		}
+
+		if bufPtrThree == nil {
+			bufPtrThree = &bufThree
+		} else if bufPtrThree == &bufThree {
+			fmt.Println("bufThree was not properly redeclared")
+		} else {
+			fmt.Println("bufThree is properly redeclared")
+		}
+
+		if bufPtrFour == nil {
+			bufPtrFour = bufFour
+		} else if bufPtrFour == bufFour {
+			fmt.Println("bufFour was not properly redeclared")
+		} else {
+			fmt.Println("bufFour is properly redeclared")
+		}
+	}
+}
+
+// Output:
+// bufOne is properly redeclared
+// bufTwo is properly redeclared
+// bufThree is properly redeclared
+// bufFour is properly redeclared

_test/issue-1404.go

@@ -0,0 +1,22 @@
+package main
+
+type I interface {
+	inI()
+}
+
+type T struct {
+	name string
+}
+
+func (t *T) inI() {}
+
+func main() {
+	var i I = &T{name: "foo"}
+
+	if i, ok := i.(*T); ok {
+		println(i.name)
+	}
+}
+
+// Output:
+// foo

_test/issue-1408.go

@@ -0,0 +1,16 @@
+package main
+
+type (
+	Number  = int32
+	Number2 = Number
+)
+
+func f(n Number2) { println(n) }
+
+func main() {
+	var n Number = 5
+	f(n)
+}
+
+// Output:
+// 5

_test/issue-1411.go

@@ -0,0 +1,16 @@
+package main
+
+type Number int32
+
+func (n Number) IsValid() bool { return true }
+
+type Number1 = Number
+
+type Number2 = Number1
+
+func main() {
+	a := Number2(5)
+	println(a.IsValid())
+}
+
+// Output: true

_test/issue-1421.go

@@ -0,0 +1,9 @@
+package main
+
+type Number = int
+
+func main() {
+	println(Number(1) < int(2))
+}
+
+// Output: true

_test/issue-1425.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"io"
+	"log"
+	"os"
+	"strings"
+)
+
+type WrappedReader struct {
+	reader io.Reader
+}
+
+func (wr WrappedReader) Read(p []byte) (n int, err error) {
+	return wr.reader.Read(p)
+}
+
+// Of course, this implementation is completely stupid because it does not write
+// to the intended writer, as any honest WriteTo implementation should. its
+// implemtion is just to make obvious the divergence of behaviour with yaegi.
+func (wr WrappedReader) WriteTo(w io.Writer) (n int64, err error) {
+	// Ignore w, send to Stdout to prove whether this WriteTo is used.
+	data, err := io.ReadAll(wr)
+	if err != nil {
+		return 0, err
+	}
+	nn, err := os.Stdout.Write(data)
+	return int64(nn), err
+}
+
+func main() {
+	f := strings.NewReader("hello world")
+	wr := WrappedReader{reader: f}
+
+	// behind the scenes, io.Copy is supposed to use wr.WriteTo if the implementation exists.
+	// With Go, it works as expected, i.e. the output is sent to os.Stdout.
+	// With Yaegi, it doesn't, i.e. the output is sent to io.Discard.
+	if _, err := io.Copy(io.Discard, wr); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// Output:
+// hello world

_test/issue-1439.go

@@ -0,0 +1,25 @@
+package main
+
+type Transformer interface {
+	Reset()
+}
+
+type Encoder struct {
+	Transformer
+}
+
+type nop struct{}
+
+func (nop) Reset() { println("Reset") }
+
+func f(e Transformer) {
+	e.Reset()
+}
+
+func main() {
+	e := Encoder{Transformer: nop{}}
+	f(e)
+}
+
+// Output:
+// Reset

_test/issue-1447.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type I interface {
+	Name() string
+}
+
+type S struct {
+	iMap map[string]I
+}
+
+func main() {
+	s := S{}
+	s.iMap = map[string]I{}
+	fmt.Println(s)
+}
+
+// Output:
+// {map[]}

_test/issue-435.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type Foo int
+
+func (f Foo) String() string {
+	return "foo-" + strconv.Itoa(int(f))
+}
+
+func print1(arg interface{}) {
+	fmt.Println(arg)
+}
+
+func main() {
+	var arg Foo = 3
+	var f = print1
+	f(arg)
+}
+
+// Output:
+// foo-3

_test/issue-558.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"strings"
 )
@@ -36,7 +35,7 @@ type pipe struct {
 
 func newReadAutoCloser(r io.Reader) readAutoCloser {
 	if _, ok := r.(io.Closer); !ok {
-		return readAutoCloser{ioutil.NopCloser(r)}
+		return readAutoCloser{io.NopCloser(r)}
 	}
 	return readAutoCloser{r.(io.ReadCloser)}
 }
@@ -44,7 +43,7 @@ func newReadAutoCloser(r io.Reader) readAutoCloser {
 func main() {
 	p := &pipe{}
 	p.Reader = newReadAutoCloser(strings.NewReader("test"))
-	b, err := ioutil.ReadAll(p.Reader)
+	b, err := io.ReadAll(p.Reader)
 	if err != nil {
 		log.Fatal(err)
 	}

_test/method38.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/traefik/yaegi/_test/method38"
+)
+
+func main() {
+	fmt.Println(method38.Get())
+}
+
+// Output:
+// &{[] {<nil>}}

_test/method38/a.go

@@ -0,0 +1,19 @@
+package method38
+
+import "sync"
+
+func NewPool() Pool { return Pool{} }
+
+type Buffer struct {
+	bs   []byte
+	pool Pool
+}
+
+type Pool struct {
+	p *sync.Pool
+}
+
+var (
+	_pool = NewPool()
+	Get   = _pool.Get
+)

_test/method38/b.go

@@ -0,0 +1,3 @@
+package method38
+
+func (p Pool) Get() *Buffer { return &Buffer{} }

_test/method39.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/traefik/yaegi/_test/method38"
+)
+
+func NewPool() Pool { return Pool{} }
+
+type Buffer struct {
+	bs   []byte
+	pool Pool
+}
+
+type Pool struct {
+	p *sync.Pool
+}
+
+var (
+	_pool = NewPool()
+	Get   = _pool.Get
+)
+
+
+func main() {
+	fmt.Println(Get())
+}
+
+// Error:
+// 17:11: undefined selector Get

_test/os0.go

@@ -2,11 +2,11 @@ package main
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 )
 
 func main() {
-	_, err := ioutil.ReadFile("__NotExisting__")
+	_, err := os.ReadFile("__NotExisting__")
 	if err != nil {
 		fmt.Println(err.Error())
 	}

_test/p2/p2.go

@@ -0,0 +1,9 @@
+package p2
+
+type I interface {
+	isI()
+}
+
+type T struct{}
+
+func (t *T) isI() {}

_test/p4/p4.go

@@ -0,0 +1,3 @@
+package p4
+
+var Value1 = "value1"

_test/p5.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/traefik/yaegi/_test/p5"
+
+func main() {
+	println(*p5.Value1)
+}
+
+// Output:
+// value1

_test/p5/p5.go

@@ -0,0 +1,8 @@
+package p5
+
+import "github.com/traefik/yaegi/_test/p4"
+
+var (
+	Value1 = &val1
+	val1   = p4.Value1
+)

_test/struct46.go

@@ -8,6 +8,7 @@ type A struct {
 }
 
 type D struct {
+	F *A
 	E *A
 }
 

_test/struct61.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+type A struct {
+	B string
+	D
+}
+
+type D struct {
+	*A
+	E *A
+}
+
+func main() {
+	a := &A{B: "b"}
+	a.D = D{E: a}
+	fmt.Println(a.D.E.B)
+}
+
+// Output:
+// b

_test/struct62.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	type A struct{ *A }
+	v := &A{}
+	v.A = v
+	println("v.A.A = v", v.A.A == v)
+}
+
+// Output:
+// v.A.A = v true

_test/switch39.go

@@ -0,0 +1,17 @@
+package main
+
+func f(params ...interface{}) {
+	switch p0 := params[0].(type) {
+	case string:
+		println("string:", p0)
+	default:
+		println("not a string")
+	}
+}
+
+func main() {
+	f("Hello")
+}
+
+// Output:
+// string: Hello

_test/switch40.go

@@ -0,0 +1,17 @@
+package main
+
+func f(params ...interface{}) {
+	switch params[0].(type) {
+	case string:
+		println("a string")
+	default:
+		println("not a string")
+	}
+}
+
+func main() {
+	f("Hello")
+}
+
+// Output:
+// a string

_test/type27.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type Foo = int
+
+func (f Foo) Bar() int {
+	return f * f
+}
+
+func main() {
+	x := Foo(1)
+	fmt.Println(x.Bar())
+}
+
+// Error:
+// 7:1: cannot define new methods on non-local type int

_test/type28.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type Foo = int
+
+func (f *Foo) Bar() int {
+	return *f * *f
+}
+
+func main() {
+	x := Foo(1)
+	fmt.Println(x.Bar())
+}
+
+// Error:
+// 7:1: cannot define new methods on non-local type int

_test/type29.go

@@ -0,0 +1,12 @@
+package main
+
+var Foo int
+
+func (f Foo) Bar() int {
+	return 1
+}
+
+func main() {}
+
+// Error:
+// 5:1: cannot define new methods on non-local type int

_test/type30.go

@@ -0,0 +1,12 @@
+package main
+
+var Foo *int
+
+func (f Foo) Bar() int {
+	return 1
+}
+
+func main() {}
+
+// Error:
+// 5:1: cannot define new methods on non-local type int

_test/type31.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func (f Foo) Bar() int {
+	return f * f
+}
+
+type Foo = int
+
+func main() {
+	x := Foo(1)
+	fmt.Println(x.Bar())
+}
+
+// Error:
+// 5:1: cannot define new methods on non-local type int

_test/type32.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func (f *Foo) Bar() int {
+	return *f * *f
+}
+
+type Foo = int
+
+func main() {
+	x := Foo(1)
+	fmt.Println(x.Bar())
+}
+
+// Error:
+// 5:1: cannot define new methods on non-local type int

_test/type33.go

@@ -0,0 +1,11 @@
+package main
+
+func (f *Foo) Bar() int {
+	return *f * *f
+}
+
+func main() {
+}
+
+// Error:
+// 3:1: undefined: Foo

_test/var16.go

@@ -0,0 +1,19 @@
+package main
+
+func getArray() ([]int, error) { println("getArray"); return []int{1, 2}, nil }
+
+func getNum() (int, error) { println("getNum"); return 3, nil }
+
+func main() {
+	if a, err := getNum(); err != nil {
+		println("#1", a)
+	} else if a, err := getArray(); err != nil {
+		println("#2", a)
+	}
+	println("#3")
+}
+
+// Output:
+// getNum
+// getArray
+// #3