interp: fix generic check on nil function

Related to issue https://github.com/traefik/traefik/issues/9231

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,27 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-
----
-
-The following program `sample.go` triggers a panic:
-
-```go
-package main
-
-func main() {
-// add a sample
-}
-```
-
-Expected result:
-```console
-$ go run ./sample.go
-// output
-```
-
-Got:
-```console
-$ yaegi ./sample.go
-// output
-```

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,66 @@
+name: Bug Report
+description: Create a report to help us improve
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ⚠️ Make sure to browse the opened and closed issues before submit your issue.
+
+  - type: textarea
+    id: sample
+    attributes:
+      label: "The following program `sample.go` triggers an unexpected result"
+      value: |
+        package main
+
+        func main() {
+          // add a sample
+        }
+      render: go
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected result
+      description: |-
+        ```console
+        $ go run ./sample.go
+        // output
+        ```
+      placeholder: $ go run ./sample.go
+      render: console
+    validations:
+      required: true
+
+  - type: textarea
+    id: got
+    attributes:
+      label: Got
+      description: |-
+        ```console
+        $ yaegi ./sample.go
+        // output
+        ```
+      placeholder: $ yaegi ./sample.go
+      render: console
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: Yaegi Version
+      description: Can be a tag or a hash.
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Notes
+      description: Use [Markdown syntax](https://help.github.com/articles/github-flavored-markdown) if needed.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Questions
+    url: https://community.traefik.io/c/yaegi
+    about: If you have a question, or are looking for advice, please post on our discussions forum!
+  - name: Documentation
+    url: https://pkg.go.dev/github.com/traefik/yaegi
+    about: Please take a look to our documenation.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,19 +0,0 @@
----
-name:  Feature request
-about: Propose a change to Yaegi!
----
-
-<!-- ⚠️ If you do not respect this template your issue will be closed. -->
-<!-- ⚠️ Make sure to browse the opened and closed issues before submit your issue. -->
-
-#### Proposal
-
-<!-- Write your feature request in the form of a proposal to be considered for implementation -->
-
-#### Background
-
-<!-- Describe the background problem or need that led to this feature request -->
-
-#### Workarounds
-
-<!-- Are there any current workarounds that you're using that others in similar positions should know about? -->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,32 @@
+name: Feature request
+description: Propose a change to Yaegi
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ⚠️ Make sure to browse the opened and closed issues before submit your issue.
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposal
+      description: Write your feature request in the form of a proposal to be considered for implementation.
+    validations:
+      required: true
+
+  - type: textarea
+    id: background
+    attributes:
+      label: Background
+      description: Describe the background problem or need that led to this feature request.
+    validations:
+      required: true
+
+  - type: textarea
+    id: workarounds
+    attributes:
+      label: Workarounds
+      description: Are there any current workarounds that you're using that others in similar positions should know about?
+    validations:
+      required: true

.github/workflows/go-cross.yml

@@ -17,7 +17,7 @@ jobs:
 
     strategy:
       matrix:
-        go-version: [ 1.15, 1.16 ]
+        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
@@ -45,11 +46,16 @@ jobs:
       - name: Cache Go modules
         uses: actions/cache@v2
         with:
+          # In order:
+          # * Module download cache
+          # * Build cache (Linux)
+          # * Build cache (Mac)
+          # * Build cache (Windows)
           path: |
-            ~/go/pkg/mod              # Module download cache
+            ~/go/pkg/mod
-            ~/.cache/go-build         # Build cache (Linux)
+            ~/.cache/go-build
-            ~/Library/Caches/go-build # Build cache (Mac)
+            ~/Library/Caches/go-build
-            '%LocalAppData%\go-build' # Build cache (Windows)
+            %LocalAppData%\go-build
           key: ${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.go-version }}-go-

.github/workflows/main.yml

@@ -7,8 +7,8 @@ on:
   pull_request:
 
 env:
-  GO_VERSION: 1.16
+  GO_VERSION: 1.18
-  GOLANGCI_LINT_VERSION: v1.36.0
+  GOLANGCI_LINT_VERSION: v1.47.1
 
 jobs:
 
@@ -45,12 +45,13 @@ jobs:
     needs: linting
     strategy:
       matrix:
-        go-version: [ 1.15, 1.16 ]
+        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.15, 1.16 ]
+        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.16
+  GO_VERSION: 1.19
 
 jobs:
 

.golangci.toml

@@ -23,13 +23,17 @@
 [linters]
   enable-all = true
   disable = [
-    "maligned",
+    "golint", # deprecated
+    "scopelint", # deprecated
+    "interfacer", # deprecated
+    "maligned", # deprecated
+    "exhaustivestruct", # deprecated
     "lll",
     "gas",
     "dupl",
     "prealloc",
-    "scopelint",
     "gocyclo",
+    "cyclop",
     "gochecknoinits",
     "gochecknoglobals",
     "wsl",
@@ -46,9 +50,15 @@
     "wrapcheck",
     "nestif",
     "exhaustive",
-    "exhaustivestruct",
+    "exhaustruct",
     "forbidigo",
     "ifshort",
+    "forcetypeassert",
+    "varnamelen",
+    "nosnakecase",
+    "nonamedreturns",
+    "nilnil",
+    "maintidx",
     "errorlint", # TODO: must be reactivate before fixes
   ]
 
@@ -59,8 +69,11 @@
   exclude = []
 
   [[issues.exclude-rules]]
-    path = "interp/.+_test\\.go"
+    path = ".+_test\\.go"
     linters = ["goconst"]
+  [[issues.exclude-rules]]
+    path = ".+_test\\.go"
+    text = "var-declaration:"
 
   [[issues.exclude-rules]]
     path = "interp/interp.go"
@@ -68,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

@@ -3,9 +3,9 @@
 </p>
 
 [![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)
+[![Build Status](https://github.com/traefik/yaegi/actions/workflows/main.yml/badge.svg)](https://github.com/traefik/yaegi/actions/workflows/main.yml)
-[![GoDoc](https://godoc.org/github.com/traefik/yaegi?status.svg)](https://godoc.org/github.com/traefik/yaegi)
+[![GoDoc](https://godoc.org/github.com/traefik/yaegi?status.svg)](https://pkg.go.dev/mod/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)
+[![Discourse status](https://img.shields.io/discourse/https/community.traefik.io/status?label=Community&style=social)](https://community.traefik.io/c/yaegi)
 
 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.
@@ -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.13 and Go 1.14 (the latest 2 major releases)
+* Support Go 1.18 and Go 1.19 (the latest 2 major releases)
 
 ## Install
 
@@ -186,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/traefik/yaegi
+[docs]: https://pkg.go.dev/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/a29.go

@@ -6,16 +6,18 @@ const (
 	zero = iota
 	one
 	two
+	three
 )
 
 func main() {
 	a := [...]string{
-		zero: "zero",
+		zero:      "zero",
-		one:  "one",
+		one:       "one",
-		two:  "two",
+		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/add1.go

@@ -22,6 +22,12 @@ func main() {
 	var g int = 2
 	a = 10 + g
 	println(a.(int))
+
+	// multiple assignment
+	var foo interface{}
+	foo, a = "hello", 11 + g
+	println(a.(int))
+	println(foo.(string))
 }
 
 // Output:
@@ -31,3 +37,5 @@ func main() {
 // 10
 // 11
 // 12
+// 13
+// hello

_test/addr2.go

@@ -57,7 +57,7 @@ func main() {
 	fmt.Println(err, vvv)
 }
 
-// Ouput:
+// Output:
 // <nil> {work bob@work.com}
 // <nil> {work bob@work.com}
 // <nil> {work bob@work.com}

_test/addr4.go

@@ -103,7 +103,7 @@ func main() {
 	intoMap()
 }
 
-// Ouput:
+// Output:
 // 0 : foo
 // 1 : bar
 // 0 : foo

_test/alias2.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func (t MyT) Test() string {
+	return "hello"
+}
+
+type MyT int
+
+func main() {
+	t := MyT(1)
+
+	fmt.Println(t.Test())
+}
+
+// Output:
+// hello

_test/alias3.go

@@ -0,0 +1,22 @@
+package main
+
+import "github.com/traefik/yaegi/_test/alias3"
+
+var globalT *T
+
+func init() {
+	globalT = &T{A: "test"}
+}
+
+type T alias3.T
+
+func (t *T) PrintT() {
+	(*alias3.T)(t).Print()
+}
+
+func main() {
+	globalT.PrintT()
+}
+
+// Output:
+// test

_test/alias3/alias3.go

@@ -0,0 +1,31 @@
+package alias3
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type T struct {
+	A string
+}
+
+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/append3.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []int{1, 2}
+	b := [2]int{3, 4}
+	fmt.Println(append(a, b[:]...))
+	fmt.Println(append(a, []int{5, 6}...))
+}
+
+// Output:
+// [1 2 3 4]
+// [1 2 5 6]

_test/append4.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []*int{}
+	a = append(a, nil)
+	fmt.Println(a)
+}
+
+// Output:
+// [<nil>]

_test/assert2.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"strings"
+	"sync"
+)
+
+// Defined an interface of stringBuilder that 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)
+	Reset()
+	Grow(n int)
+	String() string
+}
+
+var builderPool = sync.Pool{New: func() interface{} {
+	return newStringBuilder()
+}}
+
+func newStringBuilder() stringBuilder {
+	return &strings.Builder{}
+}
+
+func main() {
+	i := builderPool.Get()
+	sb := i.(stringBuilder)
+	_, _ = sb.WriteString("hello")
+
+	println(sb.String())
+
+	builderPool.Put(i)
+}
+
+// Output:
+// hello

_test/assign15.go

@@ -8,4 +8,4 @@ func main() {
 }
 
 // Error:
-// _test/assign15.go:5:26: cannot use type chan<- struct{} as type <-chan struct{} in assignment
+// _test/assign15.go:5:26: cannot use type chan<- struct {} as type <-chan struct {} in assignment

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

@@ -1,13 +0,0 @@
-// A test program
-
-// +build darwin,linux !arm
-// +build go1.12 !go1.13
-
-package main
-
-func main() {
-	println("hello world")
-}
-
-// Output:
-// hello world

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

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	foos := []func(){}
+
+	for i := 0; i < 3; i++ {
+		a, b := i, i
+		foos = append(foos, func() { println(i, a, b) })
+	}
+	foos[0]()
+	foos[1]()
+	foos[2]()
+}
+
+// Output:
+// 3 0 0
+// 3 1 1
+// 3 2 2

_test/closure11.go

@@ -0,0 +1,22 @@
+package main
+
+type T struct {
+	F func()
+}
+
+func main() {
+	foos := []T{}
+
+	for i := 0; i < 3; i++ {
+		a := i
+		foos = append(foos, T{func() { println(i, a) }})
+	}
+	foos[0].F()
+	foos[1].F()
+	foos[2].F()
+}
+
+// Output:
+// 3 0
+// 3 1
+// 3 2

_test/closure12.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+type T struct {
+	F func()
+}
+
+func main() {
+	foos := []T{}
+
+	for i := 0; i < 3; i++ {
+		a := i
+		n := fmt.Sprintf("i=%d", i)
+		foos = append(foos, T{func() { println(i, a, n) }})
+	}
+	foos[0].F()
+	foos[1].F()
+	foos[2].F()
+}
+
+// Output:
+// 3 0 i=0
+// 3 1 i=1
+// 3 2 i=2

_test/closure9.go

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	foos := []func(){}
+
+	for i := 0; i < 3; i++ {
+		a := i
+		foos = append(foos, func() { println(i, a) })
+	}
+	foos[0]()
+	foos[1]()
+	foos[2]()
+}
+
+// Output:
+// 3 0
+// 3 1
+// 3 2

_test/composite18.go

@@ -0,0 +1,32 @@
+package main
+
+import "fmt"
+
+type fn func(string, string) bool
+
+var funcs = []fn{
+	cmpLessFn,
+	cmpGreaterFn,
+	nil,
+}
+
+func cmpLessFn(a string, b string) bool {
+	return a < b
+}
+
+func cmpGreaterFn(a string, b string) bool {
+	return a > b
+}
+
+func main() {
+	for _, f := range funcs {
+		if f == nil {
+			continue
+		}
+		fmt.Println(f("a", "b"))
+	}
+}
+
+// Output:
+// true
+// false

_test/composite19.go

@@ -0,0 +1,33 @@
+package main
+
+import "fmt"
+
+type fn func(string, string) bool
+
+var funcs = map[string]fn{
+	"less":    cmpLessFn,
+	"greater": cmpGreaterFn,
+	"none":     nil,
+}
+
+func cmpLessFn(a string, b string) bool {
+	return a < b
+}
+
+func cmpGreaterFn(a string, b string) bool {
+	return a > b
+}
+
+func main() {
+	for _, n := range []string{"less", "greater", "none"} {
+		f := funcs[n]
+		if f == nil {
+			continue
+		}
+		fmt.Println(f("a", "b"))
+	}
+}
+
+// Output:
+// true
+// false

_test/const13.go

@@ -9,7 +9,7 @@ func main() {
 	const huge = 1 << 100
 	const large = huge >> 38
 
-	fmt.Println(large)
+	fmt.Println(int64(large))
 }
 
 // Output:

_test/const20.go

@@ -2,7 +2,7 @@ package main
 
 import "fmt"
 
-const maxLen = int64(int(^uint(0) >> 1))
+const maxLen = int64(int64(^uint64(0) >> 1))
 
 func main() {
 	fmt.Println(maxLen)

_test/const25.go

@@ -0,0 +1,11 @@
+package main
+
+const (
+	FGBlack Attribute = iota + 30
+)
+
+type Attribute int
+
+func main() {
+	println(FGBlack)
+}

_test/const26.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+)
+
+func init() {
+	fmt.Println(constString)
+	fmt.Println(const2)
+	fmt.Println(varString)
+}
+
+const constString string = "hello"
+
+const (
+	const1 = iota + 10
+	const2
+	const3
+)
+
+var varString string = "test"
+
+func main() {}
+
+// Output:
+// hello
+// 11
+// test

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

@@ -0,0 +1,9 @@
+package d1
+
+type T struct {
+	Name string
+}
+
+func (t *T) F() { println(t.Name) }
+
+func NewT(s string) *T { return &T{s} }

_test/d2/d2.go

@@ -0,0 +1,8 @@
+package d2
+
+import "github.com/traefik/yaegi/_test/d1"
+
+var (
+	X = d1.NewT("test")
+	F = X.F
+)

_test/d3.go

@@ -0,0 +1,11 @@
+package main
+
+import "github.com/traefik/yaegi/_test/d2"
+
+func main() {
+	f := d2.F
+	f()
+}
+
+// Output:
+// test

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

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func main() {
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		print("test")
+	}()
+
+	wg.Wait()
+}
+
+func print(state string) {
+	fmt.Println(state)
+}
+
+// Output:
+// test

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

@@ -0,0 +1,23 @@
+package main
+
+type Error interface {
+	error
+	Message() string
+}
+
+type T struct {
+	Msg string
+}
+
+func (t *T) Error() string   { return t.Msg }
+func (t *T) Message() string { return "message:" + t.Msg }
+
+func newError() Error { return &T{"test"} }
+
+func main() {
+	e := newError()
+	println(e.Error())
+}
+
+// Output:
+// test

_test/interface52.go

@@ -0,0 +1,17 @@
+package main
+
+import "testing"
+
+func main() {
+	t := testing.T{}
+	var tb testing.TB
+	tb = &t
+	if tb.TempDir() == "" {
+		println("FAIL")
+		return
+	}
+	println("PASS")
+}
+
+// Output:
+// PASS

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

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+func main() {
+	a, b := 1, 1
+	for i := 0; i < 10; i++ {
+		fmt.Println(a)
+		a, b = b, a+b
+	}
+}
+
+// Output:
+// 1
+// 1
+// 2
+// 3
+// 5
+// 8
+// 13
+// 21
+// 34
+// 55

_test/issue-1065.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type AST struct {
+	Num      int
+	Children []AST
+}
+
+func newAST(num int, root AST, children ...AST) AST {
+	return AST{num, append([]AST{root}, children...)}
+}
+
+func main() {
+	ast := newAST(1, AST{}, AST{})
+	fmt.Println(ast)
+}
+
+// Output:
+// {1 [{0 []} {0 []}]}

_test/issue-1068.go

@@ -0,0 +1,19 @@
+package main
+
+type I interface {
+	Hello()
+}
+
+type T struct{}
+
+func (t T) Hello() { println("hello") }
+
+type I2 I
+
+func main() {
+	var i I2 = T{}
+	i.Hello()
+}
+
+// Output:
+// hello

_test/issue-1088.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	for i, ch := range "日本語" {
+		fmt.Printf("%#U starts at byte position %d\n", ch, i)
+	}
+}
+
+// Output:
+// U+65E5 '日' starts at byte position 0
+// U+672C '本' starts at byte position 3
+// U+8A9E '語' starts at byte position 6

_test/issue-1089.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	fmt.Println(`"` + time.RFC3339Nano + `"`)
+}
+
+// Output:
+// "2006-01-02T15:04:05.999999999Z07:00"

_test/issue-1093.go

@@ -0,0 +1,13 @@
+package main
+
+func b() string {
+	return "b"
+}
+
+func main() {
+	var x int
+	x = "a" + b()
+}
+
+// Error:
+// 9:6: cannot use type untyped string as type int in assignment

_test/issue-1094.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	var x interface{}
+	x = "a" + fmt.Sprintf("b")
+	fmt.Printf("%v %T\n", x, x)
+}
+
+// Output:
+// ab string

_test/issue-1101.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func main() {
+	method := "POST"
+	switch method {
+	case http.MethodPost:
+		fmt.Println("It's a post!")
+	}
+}
+
+// Output:
+// It's a post!

_test/issue-1115.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+outer:
+	for y := 0; y < 10; y++ {
+		for x := 0; x < 10; x++ {
+			if x == 5 && y == 5 {
+				break outer
+			}
+		}
+		fmt.Println(y)
+	}
+	fmt.Println("Yay! I finished!")
+}
+
+// Output:
+// 0
+// 1
+// 2
+// 3
+// 4
+// Yay! I finished!

_test/issue-1126.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+func main() {
+	err := errors.New("hello there")
+
+	switch true {
+	case err == nil:
+		break
+	case strings.Contains(err.Error(), "hello"):
+		fmt.Println("True!")
+	default:
+		fmt.Println("False!")
+	}
+}
+
+// Output:
+// True!

_test/issue-1128.go

@@ -0,0 +1,11 @@
+package main
+
+import "net"
+
+func main() {
+	c := append(net.Buffers{}, []byte{})
+	println(len(c))
+}
+
+// Output:
+// 1

_test/issue-1134.go

@@ -0,0 +1,20 @@
+package main
+
+type I interface {
+	Hello()
+}
+
+type T struct {
+	Name  string
+	Child []*T
+}
+
+func (t *T) Hello() { println("Hello", t.Name) }
+
+func main() {
+	var i I = new(T)
+	i.Hello()
+}
+
+// Output:
+// Hello

_test/issue-1136.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+type T struct {
+	r io.Reader
+}
+
+func (t *T) Read(p []byte) (n int, err error) { n, err = t.r.Read(p); return }
+
+func main() {
+	x := io.LimitedReader{}
+	y := io.Reader(&x)
+	y = &T{y}
+	fmt.Println(y.Read([]byte("")))
+}
+
+// Output:
+// 0 EOF

_test/issue-1145.go

@@ -0,0 +1,14 @@
+package main
+
+import "sync"
+
+type F func()
+
+func main() {
+	var wg sync.WaitGroup
+	var f F = wg.Done
+	println(f != nil)
+}
+
+// Output:
+// true

_test/issue-1156.go

@@ -0,0 +1,25 @@
+package main
+
+type myInterface interface {
+	myFunc() string
+}
+
+type V struct{}
+
+func (v *V) myFunc() string { return "hello" }
+
+type U struct {
+	v myInterface
+}
+
+func (u *U) myFunc() string { return u.v.myFunc() }
+
+func main() {
+	x := V{}
+	y := myInterface(&x)
+	y = &U{y}
+	println(y.myFunc())
+}
+
+// Output:
+// hello

_test/issue-1163.go

@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+type WidgetEvent struct {
+	Nothing string
+}
+
+type WidgetControl interface {
+	HandleEvent(e *WidgetEvent)
+}
+
+type Button struct{}
+
+func (b *Button) HandleEvent(e *WidgetEvent) {
+}
+
+type WindowEvent struct {
+	Something int
+}
+
+type Window struct {
+	Widget WidgetControl
+}
+
+func (w *Window) HandleEvent(e *WindowEvent) {
+}
+
+func main() {
+	window := &Window{
+		Widget: &Button{},
+	}
+	windowevent := &WindowEvent{}
+	// The next line uses the signature from the wrong method, resulting in an error.
+	// Renaming one of the clashing method names fixes the problem.
+	window.HandleEvent(windowevent)
+	fmt.Println("OK!")
+}
+
+// Output:
+// OK!

_test/issue-1166.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+type T []byte
+
+func (t *T) Write(p []byte) (n int, err error) { *t = append(*t, p...); return len(p), nil }
+
+func foo(w io.Writer) {
+	a := w.(*T)
+	fmt.Fprint(a, "test")
+	fmt.Printf("%s\n", *a)
+}
+
+func main() {
+	x := T{}
+	foo(&x)
+}
+
+// Output:
+// test

_test/issue-1167.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+)
+
+func main() {
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+	pub := key.Public().(*ecdsa.PublicKey)
+	println(pub.Params().Name)
+}
+
+// Output:
+// P-256

_test/issue-1173.go

@@ -0,0 +1,10 @@
+package main
+
+var real = func() { println("Hello") }
+
+func main() {
+	real()
+}
+
+// Output:
+// Hello

_test/issue-1175.go

@@ -0,0 +1,18 @@
+package main
+
+type Level int8
+
+const (
+	a Level = -1
+	b Level = 5
+	d       = b - a + 1
+)
+
+type counters [d]int
+
+func main() {
+	println(len(counters{}))
+}
+
+// Output:
+// 7

_test/issue-1177.go

@@ -0,0 +1,13 @@
+package main
+
+type counters [3][16]int
+
+func main() {
+	cs := &counters{}
+	p := &cs[0][1]
+	*p = 2
+	println(cs[0][1])
+}
+
+// Output:
+// 2

_test/issue-1179.go

@@ -0,0 +1,23 @@
+package main
+
+type I interface {
+	F()
+}
+
+type T struct {
+	Name string
+}
+
+func (t *T) F() { println("in F", t.Name) }
+
+func NewI(s string) I { return newT(s) }
+
+func newT(s string) *T { return &T{s} }
+
+func main() {
+	i := NewI("test")
+	i.F()
+}
+
+// Output:
+// in F test

_test/issue-1181.go

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	a, b := 1, 2
+	a, b = b, -a
+	println(a, b)
+}
+
+// Output:
+// 2 -1

_test/issue-1185.go

@@ -0,0 +1,20 @@
+package main
+
+import "io"
+
+type B []byte
+
+func (b B) Write(p []byte) (n int, err error) {
+	b = p
+	return len(p), nil
+}
+
+func main() {
+	b := B{}
+	a := make([]io.Writer, 0)
+	a = append(a, b)
+	println(len(a))
+}
+
+// Output:
+// 1

_test/issue-1187.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"io"
+	"os"
+)
+
+type sink interface {
+	io.Writer
+	io.Closer
+}
+
+func newSink() sink {
+	// return os.Stdout	// Stdout is special in yaegi tests
+	file, err := os.CreateTemp("", "yaegi-test.*")
+	if err != nil {
+		panic(err)
+	}
+	return file
+}
+
+func main() {
+	s := newSink()
+	n, err := s.Write([]byte("Hello\n"))
+	if err != nil {
+		panic(err)
+	}
+	var writer io.Writer = s
+	m, err := writer.Write([]byte("Hello\n"))
+	if err != nil {
+		panic(err)
+	}
+	var closer io.Closer = s
+	err = closer.Close()
+	if err != nil {
+		panic(err)
+	}
+	err = os.Remove(s.(*os.File).Name())
+	if err != nil {
+		panic(err)
+	}
+	println(m, n)
+}
+
+// Output:
+// 6 6

_test/issue-1189.go

@@ -0,0 +1,31 @@
+package main
+
+type I interface {
+	Foo() int
+}
+
+type S1 struct {
+	i int
+}
+
+func (s S1) Foo() int { return s.i }
+
+type S2 struct{}
+
+func (s *S2) Foo() int { return 42 }
+
+func main() {
+	Is := map[string]I{
+		"foo": S1{21},
+		"bar": &S2{},
+	}
+	n := 0
+	for _, s := range Is {
+		n += s.Foo()
+	}
+	bar := "bar"
+	println(n, Is["foo"].Foo(), Is[bar].Foo())
+}
+
+// Output:
+// 63 21 42

_test/issue-1202.go

@@ -0,0 +1,34 @@
+package main
+
+import "fmt"
+
+type foobar struct {
+	callback func(string) func()
+}
+
+func cb(text string) func() {
+	return func() {
+		fmt.Println(text)
+	}
+}
+
+func main() {
+	// These ways of invoking it all work...
+	cb("Hi from inline callback!")()
+
+	asVarTest1 := cb("Hi from asVarTest1 callback!")
+	asVarTest1()
+
+	asVarTest2 := cb
+	asVarTest2("Hi from asVarTest2 callback!")()
+
+	// But inside a struct panics in yaegi...
+	asStructField := &foobar{callback: cb}
+	asStructField.callback("Hi from struct field callback!")() // <--- panics here
+}
+
+// Output:
+// Hi from inline callback!
+// Hi from asVarTest1 callback!
+// Hi from asVarTest2 callback!
+// Hi from struct field callback!

_test/issue-1205.go

@@ -0,0 +1,25 @@
+package main
+
+type Option interface {
+	apply()
+}
+
+func f(opts ...Option) {
+	for _, opt := range opts {
+		opt.apply()
+	}
+}
+
+type T struct{}
+
+func (t *T) apply() { println("in apply") }
+
+func main() {
+	opt := []Option{&T{}}
+	f(opt[0]) // works
+	f(opt...) // fails
+}
+
+// Output:
+// in apply
+// in apply

_test/issue-1208.go

@@ -0,0 +1,23 @@
+package main
+
+type Enabler interface {
+	Enabled() bool
+}
+
+type Logger struct {
+	core Enabler
+}
+
+func (log *Logger) GetCore() Enabler { return log.core }
+
+type T struct{}
+
+func (t *T) Enabled() bool { return true }
+
+func main() {
+	base := &Logger{&T{}}
+	println(base.GetCore().Enabled())
+}
+
+// Output:
+// true

_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>