interp: fix processing of aliased types

For a long time, there was a confusion between aliased types and named types (due to my misunderstanding of alias types in Go at that time). The type category `aliasT` has been renamed into `linkedT`, which is correct semantically. 

Aliased types are only declared using `typeSpecAssign`, and its processing is now distinct from `typeSpec` statement, used for named types.

A `linkedT` type is obtained by a statement like `type A uint32`, where `A` type category is therefore `linkedT`.

An aliased type is obtained by a statement like `type A = uint32` (notice the `=` sign, translating into `typeSpecAssign`).

The semantic difference is that in the first linkedT form, `A` and `uint32` are 2 distinct types, instead of being strictly equivalent in the `typeSpecAssign` form (the 2 names lead to one type definition).


Fixes #1416.

.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

@@ -0,0 +1,73 @@
+name: Build Cross OS
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+
+  cross:
+    name: Go
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
+
+    strategy:
+      matrix:
+        go-version: [ 1.18, 1.19 ]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+        include:
+          - os: ubuntu-latest
+            go-path-suffix: /go
+          - os: macos-latest
+            go-path-suffix: /go
+          - os: windows-latest
+            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 }}
+          stable: true
+
+      # https://github.com/marketplace/actions/checkout
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          path: go/src/github.com/traefik/yaegi
+
+      # https://github.com/marketplace/actions/cache
+      - name: Cache Go modules
+        uses: actions/cache@v3
+        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-
+
+      - name: Setup GOPATH
+        run: go env -w GOPATH=${{ github.workspace }}${{ matrix.go-path-suffix }}
+
+# TODO fail on windows
+#      - name: Tests
+#        run: go test -v -cover ./...
+#        env:
+#          GOPATH: ${{ github.workspace }}${{ matrix.go-path }}
+
+      - name: Build
+        run: go build -race -v -ldflags "-s -w" -trimpath

.github/workflows/main.yml

@@ -0,0 +1,112 @@
+name: Main
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+env:
+  GO_VERSION: 1.18
+  GOLANGCI_LINT_VERSION: v1.47.1
+
+jobs:
+
+  linting:
+    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
+        with:
+          fetch-depth: 0
+
+      - name: Check and get dependencies
+        run: |
+          go mod tidy
+          git diff --exit-code go.mod
+          # git diff --exit-code go.sum
+          go mod download
+
+      - name: Install golangci-lint ${{ env.GOLANGCI_LINT_VERSION }}
+        run: curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin ${GOLANGCI_LINT_VERSION}
+
+      - name: Run golangci-lint ${{ env.GOLANGCI_LINT_VERSION }}
+        run: make check
+
+  generate:
+    name: Checks code and generated code
+    runs-on: ubuntu-latest
+    needs: linting
+    strategy:
+      matrix:
+        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
+        with:
+          fetch-depth: 0
+
+      - name: Check generated code
+        run: |
+          rm -f interp/op.go
+          make generate
+          git update-index -q --refresh
+          CHANGED=$(git diff-index --name-only HEAD --)
+          test -z "$CHANGED" || echo $CHANGED
+          test -z "$CHANGED"
+
+  main:
+    name: Build and Test
+    runs-on: ubuntu-latest
+    needs: linting
+    defaults:
+      run:
+        working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
+    strategy:
+      matrix:
+        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
+        with:
+          path: go/src/github.com/traefik/yaegi
+          fetch-depth: 0
+
+      # https://github.com/marketplace/actions/cache
+      - name: Cache Go modules
+        uses: actions/cache@v3
+        with:
+          path: ./_test/tmp
+          key: ${{ runner.os }}-yaegi-${{ hashFiles('**//_test/tmp/') }}
+          restore-keys: |
+            ${{ runner.os }}-yaegi-
+
+      - name: Setup GOPATH
+        run: go env -w GOPATH=${{ github.workspace }}/go
+
+      - name: Build
+        run: go build -v ./...
+
+      - name: Run tests
+        run: make tests
+        env:
+          GOPATH: ${{ github.workspace }}/go

.github/workflows/release.yml

@@ -0,0 +1,42 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v[0-9]+.[0-9]+*
+
+env:
+  GO_VERSION: 1.19
+
+jobs:
+
+  release:
+    name: Create a release
+    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
+        with:
+          fetch-depth: 0
+
+      - name: Cache Go modules
+        uses: actions/cache@v3
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v2
+        with:
+          version: latest
+          args: release --rm-dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_TOKEN_REPO }}

.golangci.toml

@@ -23,26 +23,43 @@
 [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",
+    "nlreturn",
     "godox",
     "funlen",
     "gocognit",
     "stylecheck",
     "gomnd",
     "testpackage",
+    "paralleltest",
+    "tparallel",
     "goerr113",
+    "wrapcheck",
     "nestif",
     "exhaustive",
-    "nlreturn",
+    "exhaustruct",
+    "forbidigo",
+    "ifshort",
+    "forcetypeassert",
+    "varnamelen",
+    "nosnakecase",
+    "nonamedreturns",
+    "nilnil",
+    "maintidx",
+    "errorlint", # TODO: must be reactivate before fixes
   ]
 
 [issues]
@@ -52,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"
@@ -61,3 +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"]

.goreleaser.yml

@@ -47,7 +47,7 @@ archives:
       - LICENSE
 
 brews:
-  - github:
+  - tap:
       owner: traefik
       name: homebrew-tap
     commit_author:

.travis.yml

@@ -1,60 +0,0 @@
-language: go
-
-dist: xenial
-
-branches:
-  only:
-    - master
-    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
-
-notifications:
-  email:
-    on_success: never
-    on_failure: change
-
-cache:
-  directories:
-    - $GOPATH/pkg/mod
-
-matrix:
-  fast_finish: true
-  include:
-    - go: 1.14.x
-    - go: 1.15.x
-      env: STABLE=true
-
-env:
-  global:
-    - GO111MODULE=on
-
-go_import_path: github.com/traefik/yaegi
-
-before_install:
-  # Install linters and misspell
-  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s -- -b $GOPATH/bin ${GOLANGCI_LINT_VERSION}
-  - golangci-lint --version
-
-install:
-  - echo "TRAVIS_GO_VERSION=$TRAVIS_GO_VERSION"
-  - go mod download
-
-before_script:
-  - rm -f interp/op.go
-  - make generate
-  - git update-index -q --refresh
-  - CHANGED=$(git diff-index --name-only HEAD --)
-  - test -z "$CHANGED" || echo $CHANGED
-  - test -z "$CHANGED"
-
-script:
-  - make check
-  - go build -v ./...
-  - make tests
-
-deploy:
-  - provider: script
-    skip_cleanup: true
-    script: curl -sL https://git.io/goreleaser | bash
-    on:
-      tags: true
-      condition: $STABLE = true

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",
 		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

@@ -1,10 +1,41 @@
 package main
 
 func main() {
-	b := 2
+	b := 2 // int
-	var a interface{} = 5 + b
+
+	var c int = 5 + b
+	println(c)
+
+	var d int32 = 6 + int32(b)
+	println(d)
+
+	var a interface{} = 7 + b
 	println(a.(int))
+
+	var e int32 = 2
+	var f interface{} = 8 + e
+	println(f.(int32))
+
+	a = 9 + e
+	println(a.(int32))
+
+	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:
 // 7
+// 8
+// 9
+// 10
+// 11
+// 12
+// 13
+// hello

_test/addr2.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/xml"
+	"errors"
 	"fmt"
 )
 
@@ -10,7 +11,30 @@ type Email struct {
 	Addr  string
 }
 
-func f(s string, r interface{}) error {
+func f(r interface{}) error {
+	return withPointerAsInterface(&r)
+}
+
+func withPointerAsInterface(r interface{}) error {
+	_ = (r).(*interface{})
+	rp, ok := (r).(*interface{})
+	if !ok {
+		return errors.New("cannot assert to *interface{}")
+	}
+	em, ok := (*rp).(*Email)
+	if !ok {
+		return errors.New("cannot assert to *Email")
+	}
+	em.Where = "work"
+	em.Addr = "bob@work.com"
+	return nil
+}
+
+func ff(s string, r interface{}) error {
+	return xml.Unmarshal([]byte(s), r)
+}
+
+func fff(s string, r interface{}) error {
 	return xml.Unmarshal([]byte(s), &r)
 }
 
@@ -21,9 +45,19 @@ func main() {
 		</Email>
 	`
 	v := Email{}
-	err := f(data, &v)
+	err := f(&v)
 	fmt.Println(err, v)
+
+	vv := Email{}
+	err = ff(data, &vv)
+	fmt.Println(err, vv)
+
+	vvv := Email{}
+	err = ff(data, &vvv)
+	fmt.Println(err, vvv)
 }
 
-// Ouput:
+// Output:
+// <nil> {work bob@work.com}
+// <nil> {work bob@work.com}
 // <nil> {work bob@work.com}

_test/addr3.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var a interface{}
+	a = 2
+	fmt.Println(a)
+
+	var b *interface{}
+	b = &a
+	fmt.Println(*b)
+
+	var c **interface{}
+	c = &b
+	fmt.Println(**c)
+}
+
+// Output:
+// 2
+// 2
+// 2

_test/addr4.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+)
+
+const jsonData = `[
+  "foo",
+  "bar"
+]`
+
+const jsonData2 = `[
+  {"foo": "foo"},
+  {"bar": "bar"}
+]`
+
+const jsonData3 = `{
+  "foo": "foo",
+  "bar": "bar"
+}`
+
+func fromSlice() {
+	var a []interface{}
+	var c, d interface{}
+	c = 2
+	d = 3
+	a = []interface{}{c, d}
+
+	if err := json.Unmarshal([]byte(jsonData), &a); err != nil {
+		log.Fatalln(err)
+	}
+
+	for k, v := range a {
+		fmt.Println(k, ":", v)
+	}
+}
+
+func fromEmpty() {
+	var a interface{}
+	var c, d interface{}
+	c = 2
+	d = 3
+	a = []interface{}{c, d}
+
+	if err := json.Unmarshal([]byte(jsonData), &a); err != nil {
+		log.Fatalln(err)
+	}
+
+	b := a.([]interface{})
+
+	for k, v := range b {
+		fmt.Println(k, ":", v)
+	}
+}
+
+func sliceOfObjects() {
+	var a interface{}
+
+	if err := json.Unmarshal([]byte(jsonData2), &a); err != nil {
+		log.Fatalln(err)
+	}
+
+	b := a.([]interface{})
+
+	for k, v := range b {
+		fmt.Println(k, ":", v)
+	}
+}
+
+func intoMap() {
+	var a interface{}
+
+	if err := json.Unmarshal([]byte(jsonData3), &a); err != nil {
+		log.Fatalln(err)
+	}
+
+	b := a.(map[string]interface{})
+
+	seenFoo := false
+	for k, v := range b {
+		vv := v.(string)
+		if vv != "foo" {
+			if seenFoo {
+				fmt.Println(k, ":", vv)
+				break
+			}
+			kk := k
+			vvv := vv
+			defer fmt.Println(kk, ":", vvv)
+			continue
+		}
+		seenFoo = true
+		fmt.Println(k, ":", vv)
+	}
+}
+
+func main() {
+	fromSlice()
+	fromEmpty()
+	sliceOfObjects()
+	intoMap()
+}
+
+// Output:
+// 0 : foo
+// 1 : bar
+// 0 : foo
+// 1 : bar
+// 0 : map[foo:foo]
+// 1 : map[bar:bar]
+// foo : foo
+// bar : bar

_test/addr5.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+func main() {
+	body := []byte(`{
+		"BODY_1": "VALUE_1",
+		"BODY_2": "VALUE_2",
+		"BODY_3": null,
+		"BODY_4": {
+			"BODY_1": "VALUE_1",
+			"BODY_2": "VALUE_2",
+			"BODY_3": null
+		},
+		"BODY_5": [
+			"VALUE_1",
+			"VALUE_2",
+			"VALUE_3"
+		]
+	}`)
+
+	values := url.Values{}
+
+	var rawData map[string]interface{}
+	err := json.Unmarshal(body, &rawData)
+	if err != nil {
+		fmt.Println("can't parse body")
+		return
+	}
+
+	for key, val := range rawData {
+		switch val.(type) {
+		case string, bool, float64:
+			values.Add(key, fmt.Sprint(val))
+		case nil:
+			values.Add(key, "")
+		case map[string]interface{}, []interface{}:
+			jsonVal, err := json.Marshal(val)
+			if err != nil {
+				fmt.Println("can't encode json")
+				return
+			}
+			values.Add(key, string(jsonVal))
+		}
+	}
+	fmt.Println(values.Get("BODY_1"))
+	fmt.Println(values.Get("BODY_2"))
+	fmt.Println(values.Get("BODY_3"))
+	fmt.Println(values.Get("BODY_4"))
+	fmt.Println(values.Get("BODY_5"))
+}
+
+// Output:
+// VALUE_1
+// VALUE_2
+// 
+// {"BODY_1":"VALUE_1","BODY_2":"VALUE_2","BODY_3":null}
+// ["VALUE_1","VALUE_2","VALUE_3"]

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

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"reflect"
 	"time"
 )
 
@@ -10,6 +9,10 @@ type MyWriter interface {
 	Write(p []byte) (i int, err error)
 }
 
+type DummyWriter interface {
+	Write(p []byte) (i int, err error)
+}
+
 type TestStruct struct{}
 
 func (t TestStruct) Write(p []byte) (n int, err error) {
@@ -25,14 +28,18 @@ type MyStringer interface {
 	String() string
 }
 
+type DummyStringer interface {
+	String() string
+}
+
 func usesStringer(s MyStringer) {
 	fmt.Println(s.String())
 }
 
 func main() {
-	aType := reflect.TypeOf((*MyWriter)(nil)).Elem()
+	// TODO(mpl): restore when we can deal with empty interface.
-
+//	var t interface{}
-	var t interface{}
+	var t DummyWriter
 	t = TestStruct{}
 	var tw MyWriter
 	var ok bool
@@ -45,8 +52,6 @@ func main() {
 	}
 	n, _ := t.(MyWriter).Write([]byte("hello world"))
 	fmt.Println(n)
-	bType := reflect.TypeOf(TestStruct{})
-	fmt.Println(bType.Implements(aType))
 
 	// not redundant with the above, because it goes through a slightly different code path.
 	if _, ok := t.(MyWriter); !ok {
@@ -56,6 +61,8 @@ func main() {
 		fmt.Println("TestStruct implements MyWriter")
 	}
 
+	// TODO(mpl): restore
+	/*
 	t = 42
 	foo, ok := t.(MyWriter)
 	if !ok {
@@ -70,8 +77,10 @@ func main() {
 	} else {
 		fmt.Println("42 implements MyWriter")
 	}
+	*/
 
-	var tt interface{}
+	// var tt interface{}
+	var tt DummyStringer
 	tt = time.Nanosecond
 	var myD MyStringer
 	myD, ok = tt.(MyStringer)
@@ -82,9 +91,6 @@ func main() {
 		usesStringer(myD)
 	}
 	fmt.Println(tt.(MyStringer).String())
-	cType := reflect.TypeOf((*MyStringer)(nil)).Elem()
-	dType := reflect.TypeOf(time.Nanosecond)
-	fmt.Println(dType.Implements(cType))
 
 	if _, ok := tt.(MyStringer); !ok {
 		fmt.Println("time.Nanosecond does not implement MyStringer")
@@ -92,6 +98,8 @@ func main() {
 		fmt.Println("time.Nanosecond implements MyStringer")
 	}
 
+	// TODO(mpl): restore
+	/*
 	tt = 42
 	bar, ok := tt.(MyStringer)
 	if !ok {
@@ -106,20 +114,15 @@ func main() {
 	} else {
 		fmt.Println("42 implements MyStringer")
 	}
+	*/
 }
 
 // Output:
 // TestStruct implements MyWriter
 // 11
 // 11
-// true
 // TestStruct implements MyWriter
-// 42 does not implement MyWriter
-// 42 does not implement MyWriter
 // time.Nanosecond implements MyStringer
 // 1ns
 // 1ns
-// true
 // time.Nanosecond implements MyStringer
-// 42 does not implement MyStringer
-// 42 does not implement MyStringer

_test/assert1.go

@@ -12,6 +12,10 @@ func (t TestStruct) String() string {
 	return "hello world"
 }
 
+type DummyStringer interface{
+	String() string
+}
+
 func main() {
 	aType := reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
 
@@ -52,7 +56,9 @@ func main() {
 		return
 	}
 
-	var tt interface{}
+	// TODO(mpl): restore when fixed
+	// var tt interface{}
+	var tt DummyStringer
 	tt = TestStruct{}
 	ss, ok := tt.(fmt.Stringer)
 	if !ok {
@@ -61,9 +67,6 @@ func main() {
 	}
 	fmt.Println(ss.String())
 	fmt.Println(tt.(fmt.Stringer).String())
-	// TODO(mpl): uncomment when fixed
-	// cType := reflect.TypeOf(TestStruct{})
-	// fmt.Println(cType.Implements(aType))
 
 	if _, ok := tt.(fmt.Stringer); !ok {
 		fmt.Println("TestStuct does not implement fmt.Stringer")

_test/assert2.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"strings"
+	"sync"
+)
+
+// 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)
+	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/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/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/cap0.go

@@ -4,10 +4,16 @@ func f(a []int) interface{} {
 	return cap(a)
 }
 
+func g(a []int) int {
+	return cap(a)
+}
+
 func main() {
 	a := []int{1, 2}
+	println(g(a))
 	println(f(a).(int))
 }
 
 // Output:
 // 2
+// 2

_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/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[] &{}

_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

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

@@ -32,6 +32,7 @@ func interfaceAsInterfaces() {
 		println("nope")
 		return
 	}
+	fmt.Println(d)
 
 	for _, v := range d {
 		fmt.Println(v)
@@ -46,5 +47,6 @@ func main() {
 // Output:
 // 2
 // 3
+// [2 3]
 // 2
 // 3

_test/composite17.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"html/template"
+)
+
+var str = `{{ stringOr .Data "test" }}`
+
+func main() {
+	_, err := template.New("test").
+		Funcs(template.FuncMap{
+			"stringOr": stringOr,
+		}).
+		Parse(str)
+	if err != nil {
+		println(err.Error())
+		return
+	}
+	println("success")
+}
+
+func stringOr(v, def string) string {
+	if v == "" {
+		return def
+	}
+	return v
+}
+
+// Output:
+// success

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

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

_test/const23.go

@@ -0,0 +1,12 @@
+package main
+
+const maxlen = len("hello")
+
+var gfm = [maxlen]byte{}
+
+func main() {
+	println(len(gfm))
+}
+
+// Output:
+// 5

_test/const24.go

@@ -0,0 +1,14 @@
+package main
+
+var aa = [...]int{1, 2, 3}
+
+const maxlen = cap(aa)
+
+var gfm = [maxlen]byte{}
+
+func main() {
+	println(len(gfm))
+}
+
+// Output:
+// 3

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

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

@@ -2,10 +2,15 @@ package main
 
 func f1(a int) interface{} { return a + 1 }
 
+func f2(a int64) interface{} { return a + 1 }
+
 func main() {
 	c := f1(3)
 	println(c.(int))
+	b := f2(3)
+	println(b.(int64))
 }
 
 // Output:
 // 4
+// 4

_test/fun16.go

@@ -2,7 +2,13 @@ package main
 
 func f1(a int) int { return a + 1 }
 
-func f2(a int) interface{} { return f1(a) }
+func f2(a int) interface{} {
+	// TODO: re-enable the optimized case below, once we've figured out why it
+	// interferes with the empty interface model.
+	// return f1(a)
+	var foo interface{} = f1(a)
+	return foo
+}
 
 func main() {
 	c := f2(3)

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

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

_test/interface49.go

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

_test/interface50.go

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	a := true
+	var b interface{} = 5
+	println(b.(int))
+	b = a == true
+	println(b.(bool))
+}
+
+// Output:
+// 5
+// true

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

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

_test/issue-1010.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type MyJsonMarshaler struct{ n int }
+
+func (m MyJsonMarshaler) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf(`{"num": %d}`, m.n)), nil
+}
+
+func main() {
+	ch := make(chan json.Marshaler, 1)
+	ch <- MyJsonMarshaler{2}
+	m, err := json.Marshal(<-ch)
+	fmt.Println(string(m), err)
+}
+
+// Output:
+// {"num":2} <nil>

_test/issue-1022.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	defer func() {
+		r := recover()
+		if r != nil {
+			fmt.Println(r)
+		}
+	}()
+
+	panic("Ho Ho Ho!")
+}
+
+// Output:
+// Ho Ho Ho!

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