fix: avoid memory leak in closure

Simplify frame management. Remove node dependency on frame pointer. Fixes #1618
fix: do not panic when assigning to _ (blank) var.
2024-04-03 18:22:04 +02:00 · 2024-04-02 19:18:03 +02:00 · 2024-03-06 09:12:03 +01:00 · 2024-03-05 17:56:04 +01:00 · 2024-03-04 12:00:25 +01:00 · 2023-09-27 00:22:05 +02:00
739 changed files with 30603 additions and 10673 deletions
--- a/.github/workflows/go-cross.yml
+++ b/.github/workflows/go-cross.yml
@@ -17,7 +17,7 @@ jobs:

    strategy:
      matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ oldstable, stable ]
        os: [ubuntu-latest, macos-latest, windows-latest]

        include:
@@ -29,35 +29,18 @@ jobs:
            go-path-suffix: \go

    steps:
-      # https://github.com/marketplace/actions/setup-go-environment
-      - name: Set up Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-
      # https://github.com/marketplace/actions/checkout
      - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          path: go/src/github.com/traefik/yaegi

-      # https://github.com/marketplace/actions/cache
-      - name: Cache Go modules
-        uses: actions/cache@v2
+      # https://github.com/marketplace/actions/setup-go-environment
+      - name: Set up Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
        with:
-          # In order:
-          # * Module download cache
-          # * Build cache (Linux)
-          # * Build cache (Mac)
-          # * Build cache (Windows)
-          path: |
-            ~/go/pkg/mod
-            ~/.cache/go-build
-            ~/Library/Caches/go-build
-            %LocalAppData%\go-build
-          key: ${{ runner.os }}-${{ matrix.go-version }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.go-version }}-go-
+          go-version: ${{ matrix.go-version }}
+          stable: true

      - name: Setup GOPATH
        run: go env -w GOPATH=${{ github.workspace }}${{ matrix.go-path-suffix }}
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -7,8 +7,8 @@ on:
  pull_request:

 env:
-  GO_VERSION: 1.17
-  GOLANGCI_LINT_VERSION: v1.42.1
+  GO_VERSION: stable
+  GOLANGCI_LINT_VERSION: v1.56.2

 jobs:

@@ -16,16 +16,16 @@ jobs:
    name: Linting
    runs-on: ubuntu-latest
    steps:
-      - name: Set up Go ${{ env.GO_VERSION }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
      - name: Check out code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

+      - name: Set up Go ${{ env.GO_VERSION }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+
      - name: Check and get dependencies
        run: |
          go mod tidy
@@ -45,18 +45,19 @@ jobs:
    needs: linting
    strategy:
      matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ oldstable, stable ]
    steps:
-      - name: Set up Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-
      - name: Check out code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

+      - name: Set up Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+          stable: true
+
      - name: Check generated code
        run: |
          rm -f interp/op.go
@@ -75,23 +76,24 @@ jobs:
        working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
    strategy:
      matrix:
-        go-version: [ 1.16, 1.17 ]
+        go-version: [ oldstable, stable ]

    steps:
-      - name: Set up Go ${{ matrix.go-version }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-
      - name: Check out code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          path: go/src/github.com/traefik/yaegi
          fetch-depth: 0

+      - name: Set up Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+          stable: true
+
      # https://github.com/marketplace/actions/cache
      - name: Cache Go modules
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        with:
          path: ./_test/tmp
          key: ${{ runner.os }}-yaegi-${{ hashFiles('**//_test/tmp/') }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -6,7 +6,7 @@ on:
      - v[0-9]+.[0-9]+*

 env:
-  GO_VERSION: 1.17
+  GO_VERSION: stable

 jobs:

@@ -15,28 +15,20 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - name: Set up Go ${{ env.GO_VERSION }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
      - name: Check out code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
        with:
          fetch-depth: 0

-      - name: Cache Go modules
-        uses: actions/cache@v2
+      - name: Set up Go ${{ env.GO_VERSION }}
+        uses: actions/setup-go@v5
        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
+          go-version: ${{ env.GO_VERSION }}

      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+        uses: goreleaser/goreleaser-action@v5
        with:
          version: latest
-          args: release --rm-dist
+          args: release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GH_TOKEN_REPO }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 .*.swo
 .*.swp
 *.dot
+*.out
 .idea/
 /yaegi
 internal/cmd/extract/extract
--- a/.golangci.toml
+++ b/.golangci.toml
@@ -1,83 +0,0 @@
-[run]
-  deadline = "5m"
-  skip-files = []
-
-[linters-settings]
-
-  [linters-settings.govet]
-    check-shadowing = false
-
-  [linters-settings.gocyclo]
-    min-complexity = 12.0
-
-  [linters-settings.maligned]
-    suggest-new = true
-
-  [linters-settings.goconst]
-    min-len = 3.0
-    min-occurrences = 3.0
-
-  [linters-settings.misspell]
-    locale = "US"
-
-[linters]
-  enable-all = true
-  disable = [
-    "golint", # deprecated
-    "scopelint", # deprecated
-    "interfacer", # deprecated
-    "maligned", # deprecated
-    "lll",
-    "gas",
-    "dupl",
-    "prealloc",
-    "gocyclo",
-    "cyclop",
-    "gochecknoinits",
-    "gochecknoglobals",
-    "wsl",
-    "nlreturn",
-    "godox",
-    "funlen",
-    "gocognit",
-    "stylecheck",
-    "gomnd",
-    "testpackage",
-    "paralleltest",
-    "tparallel",
-    "goerr113",
-    "wrapcheck",
-    "nestif",
-    "exhaustive",
-    "exhaustivestruct",
-    "forbidigo",
-    "ifshort",
-    "forcetypeassert",
-    "errorlint", # TODO: must be reactivate before fixes
-  ]
-
-[issues]
-  exclude-use-default = false
-  max-per-linter = 0
-  max-same-issues = 0
-  exclude = []
-
-  [[issues.exclude-rules]]
-    path = ".+_test\\.go"
-    linters = ["goconst"]
-  [[issues.exclude-rules]]
-    path = ".+_test\\.go"
-    text = "var-declaration:"
-
-  [[issues.exclude-rules]]
-    path = "interp/interp.go"
-    text = "`in` can be `io.Reader`"
-  [[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"]
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -0,0 +1,166 @@
+run:
+  timeout: 10m
+  skip-files: []
+
+linters-settings:
+  govet:
+    check-shadowing: false
+  gocyclo:
+    min-complexity: 12
+  maligned:
+    suggest-new: true
+  goconst:
+    min-len: 3
+    min-occurrences: 3
+  funlen:
+    lines: -1
+    statements: 50
+  misspell:
+    locale: US
+  depguard:
+    rules:
+      main:
+        files:
+          - $all
+        allow:
+          - $gostd
+          - github.com/traefik/yaegi
+  tagalign:
+    align: false
+    order:
+      - xml
+      - json
+      - yaml
+      - yml
+      - toml
+      - mapstructure
+      - url
+  godox:
+    keywords:
+      - FIXME
+  gocritic:
+    enabled-tags:
+      - diagnostic
+      - style
+      - performance
+    disabled-checks:
+      - paramTypeCombine # already handle by gofumpt.extra-rules
+      - whyNoLint # already handle by nonolint
+      - unnamedResult
+      - hugeParam
+      - sloppyReassign
+      - rangeValCopy
+      - octalLiteral
+      - ptrToRefParam
+      - appendAssign
+      - ruleguard
+      - httpNoBody
+      - exposedSyncMutex
+      - importShadow # TODO should be fixed
+      - commentedOutCode # TODO should be fixed
+  revive:
+    rules:
+      - name: struct-tag
+      - name: blank-imports
+      - name: context-as-argument
+      - name: context-keys-type
+      - name: dot-imports
+      - name: error-return
+      - name: error-strings
+      - name: error-naming
+      - name: exported
+        disabled: true
+      - name: if-return
+      - name: increment-decrement
+      - name: var-naming
+      - name: var-declaration
+      - name: package-comments
+        disabled: true
+      - name: range
+      - name: receiver-naming
+      - name: time-naming
+      - name: unexported-return
+      - name: indent-error-flow
+      - name: errorf
+      - name: empty-block
+      - name: superfluous-else
+      - name: unused-parameter
+        disabled: true
+      - name: unreachable-code
+      - name: redefines-builtin-id
+
+linters:
+  enable-all: true
+  disable:
+    - deadcode # deprecated
+    - exhaustivestruct # deprecated
+    - golint # deprecated
+    - ifshort # deprecated
+    - interfacer # deprecated
+    - maligned # deprecated
+    - nosnakecase # deprecated
+    - scopelint # deprecated
+    - structcheck # deprecated
+    - varcheck # deprecated
+    - cyclop # duplicate of gocyclo
+    - sqlclosecheck # not relevant (SQL)
+    - rowserrcheck # not relevant (SQL)
+    - execinquery # not relevant (SQL)
+    - lll
+    - gas
+    - dupl
+    - prealloc
+    - gocyclo
+    - cyclop
+    - gochecknoinits
+    - gochecknoglobals
+    - wsl
+    - nlreturn
+    - godox
+    - funlen
+    - gocognit
+    - stylecheck
+    - gomnd
+    - testpackage
+    - paralleltest
+    - tparallel
+    - goerr113
+    - wrapcheck
+    - nestif
+    - exhaustive
+    - exhaustruct
+    - forbidigo
+    - ifshort
+    - forcetypeassert
+    - varnamelen
+    - nosnakecase
+    - nonamedreturns
+    - nilnil
+    - maintidx
+    - dupword # false positives
+    - errorlint # TODO: must be reactivate after fixes
+
+issues:
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 0
+  exclude:
+    - 'fmt.Sprintf can be replaced with string'
+  exclude-rules:
+    - path: .+_test\.go
+      linters:
+        - goconst
+    - path: .+_test\.go
+      text: 'var-declaration:'
+    - path: interp/interp.go
+      text: '`in` can be `io.Reader`'
+    - path: interp/interp.go
+      text: '`out` can be `io.Writer`'
+    - path: interp/interp.go
+      text: '`Panic` should conform to the `XxxError` format'
+    - path: interp/interp_eval_test.go
+      linters:
+        - thelper
+    - path: interp/debugger.go
+      linters:
+        - containedctx
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -47,7 +47,7 @@ archives:
      - LICENSE

 brews:
-  - tap:
+  - repository:
      owner: traefik
      name: homebrew-tap
    commit_author:
--- a/13
+++ b/13
@@ -27,4 +27,15 @@ tests:
 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
+generic_list = cmp/cmp.go slices/slices.go slices/sort.go slices/zsortanyfunc.go maps/maps.go \
+			   sync/oncefunc.go sync/atomic/type.go
+
+# get_generic_src imports stdlib files containing generic symbols definitions
+get_generic_src:
+	eval "`go env`"; echo $$GOROOT; gov=$${GOVERSION#*.}; gov=$${gov%.*}; \
+	for f in ${generic_list}; do \
+		nf=stdlib/generic/go1_$${gov}_`echo $$f | tr / _`.txt; echo "nf: $$nf"; \
+		cat "$$GOROOT/src/$$f" > "$$nf"; \
+	done
+
+.PHONY: check gen_all_syscall internal/cmd/extract/extract get_generic_src install
--- a/README.md
+++ b/README.md
@@ -5,7 +5,6 @@
 [![release](https://img.shields.io/github/tag-date/traefik/yaegi.svg?label=alpha)](https://github.com/traefik/yaegi/releases)
 [![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://pkg.go.dev/mod/github.com/traefik/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 +17,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 the latest 2 major releases of Go (Go 1.21 and Go 1.22)

 ## Install

@@ -31,7 +30,7 @@ import "github.com/traefik/yaegi/interp"
 ### Command-line executable

 ```bash
-go get -u github.com/traefik/yaegi/cmd/yaegi
+go install github.com/traefik/yaegi/cmd/yaegi@latest
 ```

 Note that you can use [rlwrap](https://github.com/hanslub42/rlwrap) (install with your favorite package manager),
@@ -173,10 +172,13 @@ Beside the known [bugs] which are supposed to be fixed in the short term, there

 - Assembly files (`.s`) are not supported.
 - Calling C code is not supported (no virtual "C" package).
+- Directives about the compiler, the linker, or embedding files are not supported.
 - Interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers.
 - Representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode.
 - Interpreting computation intensive code is likely to remain significantly slower than in compiled mode.

+Go modules are not supported yet. Until that, it is necessary to install the source into `$GOPATH/src/github.com/traefik/yaegi` to pass all the tests.
+
 ## Contributing

 [Contributing guide](CONTRIBUTING.md).
--- a/_test/addr0.go
+++ b/_test/addr0.go
@@ -15,11 +15,10 @@ func main() {
 	r := extendedRequest{}
 	req := &r.Request

-
-	fmt.Println(r)
-	fmt.Println(req)
+	fmt.Printf("%T\n", r.Request)
+	fmt.Printf("%T\n", 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>}
+// http.Request
+// *http.Request
--- a/_test/alias3/alias3.go
+++ b/_test/alias3/alias3.go
@@ -1,9 +0,0 @@
-package alias3
-
-type T struct {
-	A string
-}
-
-func (t *T) Print() {
-	println(t.A)
-}
--- a/_test/assert2.go
+++ 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)
--- a/_test/assert3.go
+++ b/_test/assert3.go
@@ -0,0 +1,16 @@
+package main
+
+import "crypto/rsa"
+
+func main() {
+	var pKey interface{} = &rsa.PublicKey{}
+
+	if _, ok := pKey.(*rsa.PublicKey); ok {
+		println("ok")
+	} else {
+		println("nok")
+	}
+}
+
+// Output:
+// ok
--- a/_test/assert4.go
+++ b/_test/assert4.go
@@ -0,0 +1,11 @@
+package main
+
+var cc interface{} = 2
+var dd = cc.(int)
+
+func main() {
+	println(dd)
+}
+
+// Output:
+// 2
--- a/_test/assign17.go
+++ b/_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
--- a/_test/assign18.go
+++ b/_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
--- a/_test/break0.go
+++ b/_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
--- a/_test/break1.go
+++ b/_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
--- a/_test/break2.go
+++ b/_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
--- a/_test/break3.go
+++ b/_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
--- a/_test/cli7.go
+++ b/_test/cli7.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+type T struct {
+	http.ResponseWriter
+}
+
+type mw1 struct {
+}
+
+var obj = map[string]interface{}{}
+
+func (m *mw1) ServeHTTP(rw http.ResponseWriter, rq *http.Request) {
+	t := &T{
+		ResponseWriter: rw,
+	}
+	x := t.Header()
+	i := obj["m1"].(*mw1)
+	fmt.Fprint(rw, "Welcome to my website!", x, i)
+}
+
+func main() {
+	m1 := &mw1{}
+
+	obj["m1"] = m1
+
+	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 := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+// Output:
+// Welcome to my website!map[] &{}
--- a/_test/cli8.go
+++ b/_test/cli8.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+)
+
+type T struct {
+	name string
+	next http.Handler
+}
+
+func (t *T) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	println("in T.ServeHTTP")
+	if t.next != nil {
+		t.next.ServeHTTP(rw, req)
+	}
+}
+
+func New(name string, next http.Handler) (http.Handler, error) { return &T{name, next}, nil }
+
+func main() {
+	next := func(rw http.ResponseWriter, req *http.Request) {
+		println("in next")
+	}
+
+	t, err := New("test", http.HandlerFunc(next))
+	if err != nil {
+		panic(err)
+	}
+
+	recorder := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	t.ServeHTTP(recorder, req)
+	println(recorder.Result().Status)
+}
+
+// Output:
+// in T.ServeHTTP
+// in next
+// 200 OK
--- a/_test/closure13.go
+++ b/_test/closure13.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type monkey struct {
+	test func() int
+}
+
+func main() {
+	input := []string{"1", "2", "3"}
+
+	var monkeys []*monkey
+
+	for _, v := range input {
+		kong := monkey{}
+		divisor, err := strconv.Atoi(v)
+		if err != nil {
+			panic(err)
+		}
+		fmt.Print(divisor, " ")
+		kong.test = func() int {
+			return divisor
+		}
+		monkeys = append(monkeys, &kong)
+	}
+
+	for _, mk := range monkeys {
+		fmt.Print(mk.test(), " ")
+	}
+}
+
+// Output:
+// 1 2 3 1 2 3
--- a/_test/closure14.go
+++ b/_test/closure14.go
@@ -0,0 +1,32 @@
+package main
+
+import "fmt"
+
+type monkey struct {
+	test func() int
+}
+
+func getk(k int) (int, error) { return k, nil }
+
+func main() {
+	input := []string{"1", "2", "3"}
+
+	var monkeys []*monkey
+
+	for k := range input {
+		kong := monkey{}
+		divisor, _ := getk(k)
+		fmt.Print(divisor, " ")
+		kong.test = func() int {
+			return divisor
+		}
+		monkeys = append(monkeys, &kong)
+	}
+
+	for _, mk := range monkeys {
+		fmt.Print(mk.test(), " ")
+	}
+}
+
+// Output:
+// 0 1 2 0 1 2
--- a/_test/cont2.go
+++ b/_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
--- a/_test/cont3.go
+++ b/_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
--- a/_test/convert3.go
+++ b/_test/convert3.go
@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func main() {
+	next := func(rw http.ResponseWriter, req *http.Request) {
+		rw.Header().Set("Cache-Control", "max-age=20")
+		rw.WriteHeader(http.StatusOK)
+	}
+	f := http.HandlerFunc(next)
+	fmt.Printf("%T\n", f.ServeHTTP)
+}
+
+// Output:
+// func(http.ResponseWriter, *http.Request)
--- a/_test/fun28.go
+++ b/_test/fun28.go
@@ -0,0 +1,25 @@
+package main
+
+import (
+	"runtime"
+)
+
+type T struct {
+	name string
+}
+
+func finalize(t *T) { println("finalize") }
+
+func newT() *T {
+	t := new(T)
+	runtime.SetFinalizer(t, finalize)
+	return t
+}
+
+func main() {
+	t := newT()
+	println(t != nil)
+}
+
+// Output:
+// true
--- a/_test/gen1.go
+++ b/_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))
+}
--- a/_test/gen10.go
+++ b/_test/gen10.go
@@ -0,0 +1,12 @@
+package main
+
+func genFunc() (f func()) {
+	return f
+}
+
+func main() {
+	println(genFunc() == nil)
+}
+
+// Output:
+// true
--- a/_test/gen11.go
+++ b/_test/gen11.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/netip"
+)
+
+type Slice[T any] struct {
+	x []T
+}
+
+type IPPrefixSlice struct {
+	x Slice[netip.Prefix]
+}
+
+func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v.x) }
+
+// MarshalJSON implements json.Marshaler.
+func (v IPPrefixSlice) MarshalJSON() ([]byte, error) {
+	return v.x.MarshalJSON()
+}
+
+func main() {
+	t := IPPrefixSlice{}
+	fmt.Println(t)
+	b, e := t.MarshalJSON()
+	fmt.Println(string(b), e)
+}
+
+// Output:
+// {{[]}}
+// null <nil>
--- a/_test/gen12.go
+++ b/_test/gen12.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+)
+
+func MapOf[K comparable, V any](m map[K]V) Map[K, V] {
+	return Map[K, V]{m}
+}
+
+type Map[K comparable, V any] struct {
+	ж map[K]V
+}
+
+func (v MapView) Int() Map[string, int] { return MapOf(v.ж.Int) }
+
+type VMap struct {
+	Int map[string]int
+}
+
+type MapView struct {
+	ж *VMap
+}
+
+func main() {
+	mv := MapView{&VMap{}}
+	fmt.Println(mv.ж)
+}
+
+// Output:
+// &{map[]}
--- a/_test/gen13.go
+++ b/_test/gen13.go
@@ -0,0 +1,18 @@
+package main
+
+type Map[K comparable, V any] struct {
+	ж map[K]V
+}
+
+func (m Map[K, V]) Has(k K) bool {
+	_, ok := m.ж[k]
+	return ok
+}
+
+func main() {
+	m := Map[string, float64]{}
+	println(m.Has("test"))
+}
+
+// Output:
+// false
--- a/_test/gen2.go
+++ b/_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
--- a/_test/gen3.go
+++ b/_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
--- a/_test/gen4.go
+++ b/_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]
--- a/_test/gen5.go
+++ b/_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:{}]}
--- a/_test/gen6.go
+++ b/_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
--- a/_test/gen7.go
+++ b/_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
--- a/_test/gen8.go
+++ b/_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
--- a/_test/gen9.go
+++ b/_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
--- a/_test/issue-1332.go
+++ b/_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
--- a/_test/issue-1337.go
+++ b/_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
--- a/_test/issue-1342.go
+++ b/_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
--- a/_test/issue-1344.go
+++ b/_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
--- a/_test/issue-1354.go
+++ b/_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
--- a/_test/issue-1355.go
+++ b/_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
--- a/_test/issue-1360.go
+++ b/_test/issue-1360.go
@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+	. "net"
+)
+
+func main() {
+	v := IP{}
+	fmt.Println(v)
+}
+
+// Output:
+// <nil>
--- a/_test/issue-1361.go
+++ b/_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>
--- a/_test/issue-1364.go
+++ b/_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>
--- a/_test/issue-1365.go
+++ b/_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
--- a/_test/issue-1368.go
+++ b/_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
--- a/_test/issue-1371.go
+++ b/_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}
--- a/_test/issue-1373.go
+++ b/_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
--- a/_test/issue-1375.go
+++ b/_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
--- a/_test/issue-1378.go
+++ b/_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>
--- a/_test/issue-1381.go
+++ b/_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
--- a/_test/issue-1404.go
+++ b/_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
--- a/_test/issue-1408.go
+++ b/_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
--- a/_test/issue-1411.go
+++ b/_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
--- a/_test/issue-1416.go
+++ b/_test/issue-1416.go
@@ -0,0 +1,17 @@
+package main
+
+type Number int32
+
+type Number1 = Number
+
+type Number2 = Number1
+
+func (n Number2) IsValid() bool { return true }
+
+func main() {
+	a := Number(5)
+	println(a.IsValid())
+}
+
+// Output:
+// true
--- a/_test/issue-1421.go
+++ b/_test/issue-1421.go
@@ -0,0 +1,9 @@
+package main
+
+type Number = int
+
+func main() {
+	println(Number(1) < int(2))
+}
+
+// Output: true
--- a/_test/issue-1425.go
+++ b/_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
--- a/_test/issue-1439.go
+++ b/_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
--- a/_test/issue-1442.go
+++ b/_test/issue-1442.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"context"
+)
+
+func main() {
+	ctx, _ := context.WithCancel(context.Background())
+	ch := make(chan string, 20)
+	defer close(ch)
+
+	go func(ctx context.Context, ch <-chan string) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case tmp := <-ch:
+				_ = tmp
+			}
+		}
+	}(ctx, ch)
+
+	for _, i := range "abcdef" {
+		for _, j := range "0123456789" {
+			// i, j := "a", "0"
+			for _, k := range "ABCDEF" {
+				select {
+				case <-ctx.Done():
+					return
+				default:
+					tmp := string(i) + string(j) + string(k)
+					ch <- tmp
+				}
+			}
+		}
+	}
+	return
+}
+
+// Output:
+//
--- a/_test/issue-1447.go
+++ b/_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[]}
--- a/_test/issue-1451.go
+++ b/_test/issue-1451.go
@@ -0,0 +1,19 @@
+package main
+
+type t1 uint8
+
+const (
+	n1 t1 = iota
+	n2
+)
+
+type T struct {
+	elem [n2 + 1]int
+}
+
+func main() {
+	println(len(T{}.elem))
+}
+
+// Output:
+// 2
--- a/_test/issue-1454.go
+++ b/_test/issue-1454.go
@@ -0,0 +1,22 @@
+package main
+
+type I2 interface {
+	I2() string
+}
+
+type I interface {
+	I2
+}
+
+type S struct{}
+
+func (*S) I2() string { return "foo" }
+
+func main() {
+	var i I
+	_, ok := i.(*S)
+	println(ok)
+}
+
+// Output:
+// false
--- a/_test/issue-1459.go
+++ b/_test/issue-1459.go
@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+type funclistItem func()
+
+type funclist struct {
+	list []funclistItem
+}
+
+func main() {
+	funcs := funclist{}
+
+	funcs.list = append(funcs.list, func() { fmt.Println("first") })
+
+	for _, f := range funcs.list {
+		f()
+	}
+}
+
+// Output:
+// first
--- a/_test/issue-1460.go
+++ b/_test/issue-1460.go
@@ -0,0 +1,84 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"net/netip"
+	"reflect"
+)
+
+func unmarshalJSON[T any](b []byte, x *[]T) error {
+	if *x != nil {
+		return errors.New("already initialized")
+	}
+	if len(b) == 0 {
+		return nil
+	}
+	return json.Unmarshal(b, x)
+}
+
+func SliceOfViews[T ViewCloner[T, V], V StructView[T]](x []T) SliceView[T, V] {
+	return SliceView[T, V]{x}
+}
+
+type StructView[T any] interface {
+	Valid() bool
+	AsStruct() T
+}
+
+type SliceView[T ViewCloner[T, V], V StructView[T]] struct {
+	ж []T
+}
+
+type ViewCloner[T any, V StructView[T]] interface {
+	View() V
+	Clone() T
+}
+
+func (v SliceView[T, V]) MarshalJSON() ([]byte, error) { return json.Marshal(v.ж) }
+
+func (v *SliceView[T, V]) UnmarshalJSON(b []byte) error { return unmarshalJSON(b, &v.ж) }
+
+type Slice[T any] struct {
+	ж []T
+}
+
+func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v.ж) }
+
+func (v *Slice[T]) UnmarshalJSON(b []byte) error { return unmarshalJSON(b, &v.ж) }
+
+func SliceOf[T any](x []T) Slice[T] {
+	return Slice[T]{x}
+}
+
+type IPPrefixSlice struct {
+	ж Slice[netip.Prefix]
+}
+
+type viewStruct struct {
+	Int        int
+	Strings    Slice[string]
+	StringsPtr *Slice[string] `json:",omitempty"`
+}
+
+func main() {
+	ss := SliceOf([]string{"bar"})
+	in := viewStruct{
+		Int:        1234,
+		Strings:    ss,
+		StringsPtr: &ss,
+	}
+
+	var buf bytes.Buffer
+	encoder := json.NewEncoder(&buf)
+	encoder.SetIndent("", "")
+	err1 := encoder.Encode(&in)
+	b := buf.Bytes()
+	var got viewStruct
+	err2 := json.Unmarshal(b, &got)
+	println(err1 == nil, err2 == nil, reflect.DeepEqual(got, in))
+}
+
+// Output:
+// true true true
--- a/_test/issue-1465.go
+++ b/_test/issue-1465.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+)
+
+func SomeFunc[T int | string](defaultValue T) T {
+	switch v := any(&defaultValue).(type) {
+	case *string:
+		*v = *v + " abc"
+	case *int:
+		*v -= 234
+	}
+	return defaultValue
+}
+
+func main() {
+	fmt.Println(SomeFunc("test"))
+	fmt.Println(SomeFunc(1234))
+}
+
+// Output:
+// test abc
+// 1000
--- a/_test/issue-1466.go
+++ b/_test/issue-1466.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+)
+
+func SomeFunc(defaultValue interface{}) interface{} {
+	switch v := defaultValue.(type) {
+	case string:
+		return v + " abc"
+	case int:
+		return v - 234
+	}
+	panic("whoops")
+}
+
+func main() {
+	fmt.Println(SomeFunc(1234))
+	fmt.Println(SomeFunc("test"))
+}
+
+// Output:
+// 1000
+// test abc
--- a/_test/issue-1470.go
+++ b/_test/issue-1470.go
@@ -0,0 +1,15 @@
+package main
+
+type T struct {
+	num [tnum + 2]int
+}
+
+const tnum = 23
+
+func main() {
+	t := T{}
+	println(len(t.num))
+}
+
+// Output:
+// 25
--- a/_test/issue-1475.go
+++ b/_test/issue-1475.go
@@ -0,0 +1,12 @@
+package main
+
+type T uint16
+
+func f() T { return 0 }
+
+func main() {
+	println(f())
+}
+
+// Output:
+// 0
--- a/_test/issue-1488.go
+++ b/_test/issue-1488.go
@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+type vector interface {
+	[]int | [3]int
+}
+
+func sum[V vector](v V) (out int) {
+	for i := 0; i < len(v); i++ {
+		out += v[i]
+	}
+	return
+}
+
+func main() {
+	va := [3]int{1, 2, 3}
+	vs := []int{1, 2, 3}
+	fmt.Println(sum[[3]int](va), sum[[]int](vs))
+}
+
+// Output:
+// 6 6
--- a/_test/issue-1496.go
+++ b/_test/issue-1496.go
@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	a := []byte{} == nil
+	b := nil == []byte{}
+	c := nil == &struct{}{}
+	i := 100
+	d := nil == &i
+	var v interface{}
+	f := nil == v
+	g := v == nil
+	println(a, b, c, d, f, g)
+}
+
+// Output:
+// false false false false true true
--- a/_test/issue-1515.go
+++ b/_test/issue-1515.go
@@ -0,0 +1,43 @@
+package main
+
+type I1 interface {
+	I2
+	Wrap() *S3
+}
+
+type I2 interface {
+	F()
+}
+
+type S2 struct {
+	I2
+}
+
+func newS2(i2 I2) I1 {
+	return &S2{i2}
+}
+
+type S3 struct {
+	base *S2
+}
+
+func (s *S2) Wrap() *S3 {
+	i2 := s
+	return &S3{i2}
+}
+
+type T struct {
+	name string
+}
+
+func (t *T) F() { println("in F", t.name) }
+
+func main() {
+	t := &T{"test"}
+	s2 := newS2(t)
+	s3 := s2.Wrap()
+	s3.base.F()
+}
+
+// Output:
+// in F test
--- a/_test/issue-1536.go
+++ b/_test/issue-1536.go
@@ -0,0 +1,15 @@
+package main
+
+var a [len(prefix+path) + 2]int
+
+const (
+	prefix = "/usr/"
+	path   = prefix + "local/bin"
+)
+
+func main() {
+	println(len(a))
+}
+
+// Output:
+// 21
--- a/_test/issue-1571.go
+++ b/_test/issue-1571.go
@@ -0,0 +1,20 @@
+package main
+
+type A struct {
+	*B[string]
+}
+
+type B[T any] struct {
+	data T
+}
+
+func main() {
+	_ = &A{
+		B: &B[string]{},
+	}
+
+	println("PASS")
+}
+
+// Output:
+// PASS
--- a/_test/issue-1594.go
+++ b/_test/issue-1594.go
@@ -0,0 +1,17 @@
+package main
+
+func main() {
+	var fns []func()
+	for _, v := range []int{1, 2, 3} {
+		x := v*100 + v
+		fns = append(fns, func() { println(x) })
+	}
+	for _, fn := range fns {
+		fn()
+	}
+}
+
+// Output:
+// 101
+// 202
+// 303
--- a/_test/issue-1618.go
+++ b/_test/issue-1618.go
@@ -0,0 +1,51 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+)
+
+func humanizeBytes(bytes uint64) string {
+	const (
+		_         = iota
+		kB uint64 = 1 << (10 * iota)
+		mB
+		gB
+		tB
+		pB
+	)
+
+	switch {
+	case bytes < kB:
+		return fmt.Sprintf("%dB", bytes)
+	case bytes < mB:
+		return fmt.Sprintf("%.2fKB", float64(bytes)/float64(kB))
+	case bytes < gB:
+		return fmt.Sprintf("%.2fMB", float64(bytes)/float64(mB))
+	case bytes < tB:
+		return fmt.Sprintf("%.2fGB", float64(bytes)/float64(gB))
+	case bytes < pB:
+		return fmt.Sprintf("%.2fTB", float64(bytes)/float64(tB))
+	default:
+		return fmt.Sprintf("%dB", bytes)
+	}
+}
+
+func main() {
+	i := 0
+	wg := sync.WaitGroup{}
+
+	for {
+		var m runtime.MemStats
+		runtime.ReadMemStats(&m)
+		fmt.Printf("#%d: alloc = %s, routines = %d, gc = %d\n", i, humanizeBytes(m.Alloc), runtime.NumGoroutine(), m.NumGC)
+
+		wg.Add(1)
+		go func() {
+			wg.Done()
+		}()
+		wg.Wait()
+		i = i + 1
+	}
+}
--- a/_test/issue-435.go
+++ b/_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
--- a/_test/method40.go
+++ b/_test/method40.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"bytes"
+	"io"
+)
+
+type TMemoryBuffer struct {
+	*bytes.Buffer
+	size int
+}
+
+func newTMemoryBuffer() *TMemoryBuffer {
+	return &TMemoryBuffer{}
+}
+
+var globalMemoryBuffer = newTMemoryBuffer()
+
+type TTransport interface {
+	io.ReadWriter
+}
+
+func check(t TTransport) {
+	println("ok")
+}
+
+func main() {
+	check(globalMemoryBuffer)
+}
+
+// Output:
+// ok
--- a/_test/named0.go
+++ b/_test/named0.go
--- a/_test/named1.go
+++ b/_test/named1.go
--- a/_test/named2.go
+++ b/_test/named2.go
--- a/_test/named3.go
+++ b/_test/named3.go
@@ -1,6 +1,6 @@
 package main

-import "github.com/traefik/yaegi/_test/alias3"
+import "github.com/traefik/yaegi/_test/named3"

 var globalT *T

@@ -8,10 +8,10 @@ func init() {
 	globalT = &T{A: "test"}
 }

-type T alias3.T
+type T named3.T

 func (t *T) PrintT() {
-	(*alias3.T)(t).Print()
+	(*named3.T)(t).Print()
 }

 func main() {
--- a/_test/named3/named3.go
+++ b/_test/named3/named3.go
@@ -0,0 +1,31 @@
+package named3
+
+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
+}
--- a/_test/named4.go
+++ b/_test/named4.go
@@ -17,11 +17,23 @@ 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
--- a/_test/op10.go
+++ b/_test/op10.go
@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	_ = 1 + 1
+	println("ok")
+}
+
+// Output:
+// ok
--- a/_test/op11.go
+++ b/_test/op11.go
@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	a, b := 1, 2
+	_ = a + b
+	println("ok")
+}
+
+// Output:
+// ok
--- a/_test/p2/p2.go
+++ b/_test/p2/p2.go
@@ -0,0 +1,9 @@
+package p2
+
+type I interface {
+	isI()
+}
+
+type T struct{}
+
+func (t *T) isI() {}
--- a/_test/p3/empty
+++ b/_test/p3/empty
--- a/_test/p4/p4.go
+++ b/_test/p4/p4.go
@@ -0,0 +1,3 @@
+package p4
+
+var Value1 = "value1"
--- a/_test/p5.go
+++ b/_test/p5.go
@@ -0,0 +1,10 @@
+package main
+
+import "github.com/traefik/yaegi/_test/p5"
+
+func main() {
+	println(*p5.Value1)
+}
+
+// Output:
+// value1
--- a/_test/p5/p5.go
+++ b/_test/p5/p5.go
@@ -0,0 +1,8 @@
+package p5
+
+import "github.com/traefik/yaegi/_test/p4"
+
+var (
+	Value1 = &val1
+	val1   = p4.Value1
+)
--- a/_test/p6.go
+++ b/_test/p6.go
@@ -0,0 +1,14 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/traefik/yaegi/_test/p6"
+)
+
+func main() {
+	t := p6.IPPrefixSlice{}
+	fmt.Println(t)
+	b, e := t.MarshalJSON()
+	fmt.Println(string(b), e)
+}
--- a/_test/p6/p6.go
+++ b/_test/p6/p6.go
@@ -0,0 +1,21 @@
+package p6
+
+import (
+	"encoding/json"
+	"net/netip"
+)
+
+type Slice[T any] struct {
+	x []T
+}
+
+type IPPrefixSlice struct {
+	x Slice[netip.Prefix]
+}
+
+func (v Slice[T]) MarshalJSON() ([]byte, error) { return json.Marshal(v.x) }
+
+// MarshalJSON implements json.Marshaler.
+func (v IPPrefixSlice) MarshalJSON() ([]byte, error) {
+	return v.x.MarshalJSON()
+}
--- a/_test/panic0.go
+++ b/_test/panic0.go
@@ -0,0 +1,20 @@
+package main
+
+func main() {
+	foo()
+}
+
+func foo() {
+	bar()
+}
+
+func bar() {
+	baz()
+}
+
+func baz() {
+	panic("stop!")
+}
+
+// Error:
+// stop!
--- a/_test/recurse1.go
+++ b/_test/recurse1.go
@@ -0,0 +1,16 @@
+package main
+
+type F func(a *A)
+
+type A struct {
+	Name string
+	F
+}
+
+func main() {
+	a := &A{"Test", func(a *A) { println("in f", a.Name) }}
+	a.F(a)
+}
+
+// Output:
+// in f Test
--- a/Show More
+++ b/Show More