interp: do not export RealFS, used internally only

The current `nodeType` selector precedence is heavy handed in favour of package type. It seems to often create `typeSym` symbols as variable types in the scope will never be found. To fix this if the ancestor node is a field expression, the package type is searched for. After this, if the type is still `nil` the normal scope is searched using `nodeType2`.

Fixes #1158

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/bug_report.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/ISSUE_TEMPLATE/feature_request.yml

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

.github/workflows/go-cross.yml

@@ -17,7 +17,7 @@ jobs:
 
     strategy:
       matrix:
-        go-version: [ 1.15, 1.16 ]
+        go-version: [ 1.16, 1.17 ]
         os: [ubuntu-latest, macos-latest, windows-latest]
 
         include:
@@ -45,11 +45,16 @@ jobs:
       - name: Cache Go modules
         uses: actions/cache@v2
         with:
+          # In order:
+          # * Module download cache
+          # * Build cache (Linux)
+          # * Build cache (Mac)
+          # * Build cache (Windows)
           path: |
-            ~/go/pkg/mod              # Module download cache
-            ~/.cache/go-build         # Build cache (Linux)
-            ~/Library/Caches/go-build # Build cache (Mac)
-            '%LocalAppData%\go-build' # Build cache (Windows)
+            ~/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-

.github/workflows/main.yml

@@ -7,8 +7,8 @@ on:
   pull_request:
 
 env:
-  GO_VERSION: 1.16
-  GOLANGCI_LINT_VERSION: v1.36.0
+  GO_VERSION: 1.17
+  GOLANGCI_LINT_VERSION: v1.41.1
 
 jobs:
 
@@ -45,7 +45,7 @@ jobs:
     needs: linting
     strategy:
       matrix:
-        go-version: [ 1.15, 1.16 ]
+        go-version: [ 1.16, 1.17 ]
     steps:
       - name: Set up Go ${{ matrix.go-version }}
         uses: actions/setup-go@v2
@@ -75,7 +75,7 @@ jobs:
         working-directory: ${{ github.workspace }}/go/src/github.com/traefik/yaegi
     strategy:
       matrix:
-        go-version: [ 1.15, 1.16 ]
+        go-version: [ 1.16, 1.17 ]
 
     steps:
       - name: Set up Go ${{ matrix.go-version }}

.github/workflows/release.yml

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

.golangci.toml

@@ -23,13 +23,16 @@
 [linters]
   enable-all = true
   disable = [
-    "maligned",
+    "golint", # deprecated
+    "scopelint", # deprecated
+    "interfacer", # deprecated
+    "maligned", # deprecated
     "lll",
     "gas",
     "dupl",
     "prealloc",
-    "scopelint",
     "gocyclo",
+    "cyclop",
     "gochecknoinits",
     "gochecknoglobals",
     "wsl",
@@ -49,6 +52,7 @@
     "exhaustivestruct",
     "forbidigo",
     "ifshort",
+    "forcetypeassert",
     "errorlint", # TODO: must be reactivate before fixes
   ]
 
@@ -59,8 +63,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"

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)
-[![GoDoc](https://godoc.org/github.com/traefik/yaegi?status.svg)](https://godoc.org/github.com/traefik/yaegi)
-[![Discourse status](https://img.shields.io/discourse/https/community.containo.us/status?label=Community&style=social)](https://community.containo.us/c/yaegi)
+[![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 +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.16 and Go 1.17 (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/add1.go

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

_test/addr2.go

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

_test/addr4.go

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

_test/alias2.go

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

_test/alias3.go

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

_test/alias3/alias3.go

@@ -0,0 +1,9 @@
+package alias3
+
+type T struct {
+	A string
+}
+
+func (t *T) Print() {
+	println(t.A)
+}

_test/append3.go

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

_test/append4.go

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

_test/assert2.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"strings"
+	"sync"
+)
+
+// Defined an interface of stringBuilder that compatible with
+// strings.Builder(go 1.10) and bytes.Buffer(< go 1.10)
+type stringBuilder interface {
+	WriteRune(r rune) (n int, err error)
+	WriteString(s string) (int, error)
+	Reset()
+	Grow(n int)
+	String() string
+}
+
+var builderPool = sync.Pool{New: func() interface{} {
+	return newStringBuilder()
+}}
+
+func newStringBuilder() stringBuilder {
+	return &strings.Builder{}
+}
+
+func main() {
+	i := builderPool.Get()
+	sb := i.(stringBuilder)
+	_, _ = sb.WriteString("hello")
+
+	println(sb.String())
+
+	builderPool.Put(i)
+}
+
+// Output:
+// hello

_test/assign15.go

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

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

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

_test/closure11.go

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

_test/closure12.go

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

_test/closure9.go

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

_test/composite18.go

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

_test/composite19.go

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

_test/const13.go

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

_test/const20.go

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

_test/const25.go

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

_test/const26.go

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

_test/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/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/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/issue-1052.go

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

_test/issue-1065.go

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

_test/issue-1068.go

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

_test/issue-1088.go

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

_test/issue-1089.go

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

_test/issue-1093.go

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

_test/issue-1094.go

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

_test/issue-1101.go

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

_test/issue-1115.go

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

_test/issue-1126.go

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

_test/issue-1128.go

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

_test/issue-1134.go

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

_test/issue-1136.go

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

_test/issue-1145.go

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

_test/issue-1156.go

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

_test/issue-1163.go

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

_test/issue-1166.go

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

_test/issue-1167.go

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

_test/issue-1173.go

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

_test/issue-1175.go

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

_test/issue-1177.go

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

_test/issue-1179.go

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

_test/issue-1181.go

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

_test/issue-1185.go

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

_test/issue-1187.go

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

_test/issue-1189.go

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

_test/issue-1202.go

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

_test/issue-1205.go

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

_test/issue-1208.go

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

_test/map30.go

@@ -0,0 +1,27 @@
+package main
+
+import "strings"
+
+func f(s string) string { return "hello " + s }
+
+func g(s string) string { return "hi " + s }
+
+var methods = map[string]func(string) string{
+	"f": f,
+	"h": strings.ToLower,
+}
+
+func main() {
+	methods["i"] = strings.ToUpper
+	methods["g"] = g
+	println(methods["f"]("test"))
+	println(methods["g"]("test"))
+	println(methods["i"]("test"))
+	println(methods["h"]("TEST"))
+}
+
+// Output:
+// hello test
+// hi test
+// TEST
+// test

_test/method36.go

@@ -0,0 +1,26 @@
+package main
+
+type I interface{ Hello() }
+
+type T struct{ Name string }
+
+func (t *T) Hello() { println("Hello", t.Name) }
+
+type FT func(i I)
+
+type ST struct{ Handler FT }
+
+func newF() FT {
+	return func(i I) {
+		i.Hello()
+	}
+}
+
+func main() {
+	st := &ST{}
+	st.Handler = newF()
+	st.Handler(&T{"test"})
+}
+
+// Output:
+// Hello test

_test/method37.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"net"
+	"os"
+)
+
+func writeBufs(bufs ...[]byte) error {
+	b := net.Buffers(bufs)
+	_, err := b.WriteTo(os.Stdout)
+	return err
+}
+
+func main() {
+	writeBufs([]byte("hello"))
+}
+
+// Output:
+// hello

_test/op1.go

@@ -7,4 +7,4 @@ func main() {
 }
 
 // Error:
-// 5:2: invalid operation: mismatched types int and float64
+// 5:2: invalid operation: mismatched types int and untyped float

_test/ret8.go

@@ -0,0 +1,28 @@
+package main
+
+import "fmt"
+
+type CustomError string
+
+func (s CustomError) Error() string {
+	return string(s)
+}
+
+func NewCustomError(errorText string) CustomError {
+	return CustomError(errorText)
+}
+
+func fail() (err error) {
+	return NewCustomError("Everything is going wrong!")
+}
+
+func main() {
+	fmt.Println(fail())
+	var myError error
+	myError = NewCustomError("ok")
+	fmt.Println(myError)
+}
+
+// Output:
+// Everything is going wrong!
+// ok

_test/rune2.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+const majorVersion = '2'
+
+type hashed struct {
+	major byte
+}
+
+func main() {
+	fmt.Println(majorVersion)
+
+	p := new(hashed)
+	p.major = majorVersion
+
+	fmt.Println(p)
+}
+
+// Output:
+// 50
+// &{50}

_test/select14.go

@@ -7,7 +7,7 @@ import (
 
 const (
 	period    = 100 * time.Millisecond
-	precision = 5 * time.Millisecond
+	precision = 7 * time.Millisecond
 )
 
 func main() {

_test/selector-scope0.go

@@ -9,10 +9,20 @@ func test(time string, t time.Time) string {
 	return time
 }
 
+var zero = time.Time{}
+
+func test2(time string) time.Time {
+	return zero
+}
+
 func main() {
 	str := test("test", time.Now())
 	fmt.Println(str)
+
+	str2 := test2("test2")
+	fmt.Println(str2)
 }
 
 // Output:
 // test
+// 0001-01-01 00:00:00 +0000 UTC

_test/struct60.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+)
+
+type data struct {
+	S string
+}
+
+func render(v interface{}) {
+	fmt.Println(v)
+}
+
+func main() {
+	render(data{})
+}
+
+// Output:
+// {}

_test/unsafe3.go

@@ -1,11 +1,14 @@
 package main
 
 import (
-	"fmt"
+	"math/bits"
 	"unsafe"
 )
 
-const SSize = 16
+const (
+	SSize = 16
+	WSize = bits.UintSize / 8
+)
 
 type S struct {
 	X int
@@ -13,14 +16,19 @@ type S struct {
 }
 
 func main() {
+	bigEndian := (*(*[2]uint8)(unsafe.Pointer(&[]uint16{1}[0])))[0] == 0
 	var sBuf [SSize]byte
 	s := (*S)(unsafe.Pointer(&sBuf[0]))
 
 	s.X = 2
 	s.Y = 4
 
-	fmt.Println(sBuf)
+	if bigEndian {
+		println(sBuf[0+WSize-1], sBuf[WSize+WSize-1])
+	} else {
+		println(sBuf[0], sBuf[WSize])
+	}
 }
 
 // Output:
-// [2 0 0 0 0 0 0 0 4 0 0 0 0 0 0 0]
+// 2 4

_test/unsafe4.go

@@ -2,10 +2,11 @@ package main
 
 import (
 	"fmt"
+	"math/bits"
 	"unsafe"
 )
 
-const SSize = 24
+const WSize = bits.UintSize / 8
 
 type S struct {
 	X int
@@ -20,7 +21,8 @@ func main() {
 		{X: 3},
 	}
 	addr := unsafe.Pointer(&arr[0])
-	s := *(*S)(unsafe.Pointer(uintptr(addr) + SSize*2))
+	// s := *(*S)(unsafe.Pointer(uintptr(addr) + SSize*2))
+	s := *(*S)(unsafe.Pointer(uintptr(addr) + WSize*6))
 
 	fmt.Println(s.X)
 }

_test/unsafe5.go

@@ -1,10 +1,12 @@
 package main
 
 import (
-	"fmt"
+	"math/bits"
 	"unsafe"
 )
 
+const WSize = bits.UintSize / 8
+
 type S struct {
 	X int
 	Y int
@@ -12,11 +14,13 @@ type S struct {
 }
 
 func main() {
-	size := unsafe.Sizeof(S{})
-	align := unsafe.Alignof(S{})
+	x := S{}
+	size := unsafe.Sizeof(x) / WSize
+	align := unsafe.Alignof(x.Y) / WSize
+	offset := unsafe.Offsetof(x.Z) / WSize
 
-	fmt.Println(size, align)
+	println(size, align, offset)
 }
 
 // Output:
-// 24 8
+// 3 1 2

_test/unsafe6.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+type S struct {
+	X int
+	Y int
+	Z int
+}
+
+func main() {
+	x := S{Z: 5}
+	ptr := unsafe.Pointer(&x)
+	offset := int(unsafe.Offsetof(x.Z))
+	p := unsafe.Add(ptr, offset)
+
+	i := *(*int)(p)
+
+	fmt.Println(i)
+}

_test/unsafe7.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+type S struct {
+	X int
+	Y int
+	Z int
+}
+
+func main() {
+	x := [2]S{{Z: 5}, {Z: 10}}
+
+	s := unsafe.Slice(&x[0], 2)
+
+	fmt.Println(s)
+}

cmd/yaegi/run.go

@@ -6,6 +6,7 @@ import (
 	"go/build"
 	"io/ioutil"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 
@@ -18,6 +19,7 @@ import (
 
 func run(arg []string) error {
 	var interactive bool
+	var noAutoImport bool
 	var tags string
 	var cmd string
 	var err error
@@ -33,6 +35,7 @@ func run(arg []string) error {
 	rflag.BoolVar(&useUnrestricted, "unrestricted", useUnrestricted, "include unrestricted symbols")
 	rflag.StringVar(&tags, "tags", "", "set a list of build tags")
 	rflag.BoolVar(&useUnsafe, "unsafe", useUnsafe, "include unsafe symbols")
+	rflag.BoolVar(&noAutoImport, "noautoimport", false, "do not auto import pre-compiled packages. Import names that would result in collisions (e.g. rand from crypto/rand and rand from math/rand) are automatically renamed (crypto_rand and math_rand)")
 	rflag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
 	rflag.Usage = func() {
 		fmt.Println("Usage: yaegi run [options] [path] [args]")
@@ -45,48 +48,68 @@ func run(arg []string) error {
 	args := rflag.Args()
 
 	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
-	i.Use(stdlib.Symbols)
-	i.Use(interp.Symbols)
+	if err := i.Use(stdlib.Symbols); err != nil {
+		return err
+	}
+	if err := i.Use(interp.Symbols); err != nil {
+		return err
+	}
 	if useSyscall {
-		i.Use(syscall.Symbols)
+		if err := i.Use(syscall.Symbols); err != nil {
+			return err
+		}
 		// Using a environment var allows a nested interpreter to import the syscall package.
 		if err := os.Setenv("YAEGI_SYSCALL", "1"); err != nil {
 			return err
 		}
 	}
 	if useUnsafe {
-		i.Use(unsafe.Symbols)
+		if err := i.Use(unsafe.Symbols); err != nil {
+			return err
+		}
 		if err := os.Setenv("YAEGI_UNSAFE", "1"); err != nil {
 			return err
 		}
 	}
 	if useUnrestricted {
 		// Use of unrestricted symbols should always follow stdlib and syscall symbols, to update them.
-		i.Use(unrestricted.Symbols)
+		if err := i.Use(unrestricted.Symbols); err != nil {
+			return err
+		}
 		if err := os.Setenv("YAEGI_UNRESTRICTED", "1"); err != nil {
 			return err
 		}
 	}
 
 	if cmd != "" {
-		_, err = i.Eval(cmd)
+		if !noAutoImport {
+			i.ImportUsed()
+		}
+		var v reflect.Value
+		v, err = i.Eval(cmd)
+		if len(args) == 0 && v.IsValid() {
+			fmt.Println(v)
+		}
 	}
 
 	if len(args) == 0 {
-		if interactive || cmd == "" {
+		if cmd == "" || interactive {
 			showError(err)
+			if !noAutoImport {
+				i.ImportUsed()
+			}
 			_, err = i.REPL()
 		}
 		return err
 	}
 
-	// Skip first os arg to set command line as expected by interpreted main
+	// Skip first os arg to set command line as expected by interpreted main.
 	path := args[0]
 	os.Args = arg
 	flag.CommandLine = flag.NewFlagSet(path, flag.ExitOnError)
 
 	if isFile(path) {
-		err = runFile(i, path)
+		err = runFile(i, path, noAutoImport)
 	} else {
 		_, err = i.EvalPath(path)
 	}
@@ -106,7 +129,7 @@ func isFile(path string) bool {
 	return err == nil && fi.Mode().IsRegular()
 }
 
-func runFile(i *interp.Interpreter, path string) error {
+func runFile(i *interp.Interpreter, path string, noAutoImport bool) error {
 	b, err := ioutil.ReadFile(path)
 	if err != nil {
 		return err
@@ -115,6 +138,9 @@ func runFile(i *interp.Interpreter, path string) error {
 	if s := string(b); strings.HasPrefix(s, "#!") {
 		// Allow executable go scripts, Have the same behavior as in interactive mode.
 		s = strings.Replace(s, "#!", "//", 1)
+		if !noAutoImport {
+			i.ImportUsed()
+		}
 		_, err = i.Eval(s)
 		return err
 	}

cmd/yaegi/test.go

@@ -117,23 +117,33 @@ func test(arg []string) (err error) {
 	}
 
 	i := interp.New(interp.Options{GoPath: build.Default.GOPATH, BuildTags: strings.Split(tags, ",")})
-	i.Use(stdlib.Symbols)
-	i.Use(interp.Symbols)
+	if err := i.Use(stdlib.Symbols); err != nil {
+		return err
+	}
+	if err := i.Use(interp.Symbols); err != nil {
+		return err
+	}
 	if useSyscall {
-		i.Use(syscall.Symbols)
+		if err := i.Use(syscall.Symbols); err != nil {
+			return err
+		}
 		// Using a environment var allows a nested interpreter to import the syscall package.
 		if err := os.Setenv("YAEGI_SYSCALL", "1"); err != nil {
 			return err
 		}
 	}
 	if useUnrestricted {
-		i.Use(unrestricted.Symbols)
+		if err := i.Use(unrestricted.Symbols); err != nil {
+			return err
+		}
 		if err := os.Setenv("YAEGI_UNRESTRICTED", "1"); err != nil {
 			return err
 		}
 	}
 	if useUnsafe {
-		i.Use(unsafe.Symbols)
+		if err := i.Use(unsafe.Symbols); err != nil {
+			return err
+		}
 		if err := os.Setenv("YAEGI_UNSAFE", "1"); err != nil {
 			return err
 		}

cmd/yaegi/yaegi_test.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"strings"
 	"testing"
@@ -49,7 +50,15 @@ func TestYaegiCmdCancel(t *testing.T) {
 	}()
 
 	yaegi := filepath.Join(tmp, "yaegi")
-	build := exec.Command("go", "build", "-race", "-o", yaegi, ".")
+
+	args := []string{"build"}
+	if raceDetectorSupported(runtime.GOOS, runtime.GOARCH) {
+		args = append(args, "-race")
+	}
+	args = append(args, "-o", yaegi, ".")
+
+	build := exec.Command("go", args...)
+
 	out, err := build.CombinedOutput()
 	if err != nil {
 		t.Fatalf("failed to build yaegi command: %v: %s", err, out)
@@ -82,7 +91,7 @@ func TestYaegiCmdCancel(t *testing.T) {
 		if err != nil {
 			t.Errorf("failed pipe test source to yaegi command: %v", err)
 		}
-		Sleep(200 * time.Millisecond)
+		Sleep(500 * time.Millisecond)
 		err = cmd.Process.Signal(os.Interrupt)
 		if err != nil {
 			t.Errorf("failed to send os.Interrupt to yaegi command: %v", err)
@@ -115,3 +124,16 @@ func TestYaegiCmdCancel(t *testing.T) {
 		}
 	}
 }
+
+func raceDetectorSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64"
+	case "darwin":
+		return goarch == "amd64" || goarch == "arm64"
+	case "freebsd", "netbsd", "openbsd", "windows":
+		return goarch == "amd64"
+	default:
+		return false
+	}
+}

example/closure/closure_test.go

@@ -9,7 +9,9 @@ import (
 
 func TestFunctionCall(t *testing.T) {
 	i := interp.New(interp.Options{GoPath: "./_pkg"})
-	i.Use(stdlib.Symbols)
+	if err := i.Use(stdlib.Symbols); err != nil {
+		t.Fatal(err)
+	}
 
 	_, err := i.Eval(`import "foo/bar"`)
 	if err != nil {

example/fs/fs_test.go

@@ -0,0 +1,67 @@
+package fs1
+
+import (
+	"testing"
+
+	// only available from 1.16.
+	"testing/fstest"
+
+	"github.com/traefik/yaegi/interp"
+	"github.com/traefik/yaegi/stdlib"
+)
+
+var testFilesystem = fstest.MapFS{
+	"main.go": &fstest.MapFile{
+		Data: []byte(`package main
+
+import (
+	"foo/bar"
+	"./localfoo"
+)
+
+func main() {
+	bar.PrintSomething()
+	localfoo.PrintSomethingElse()
+}
+`),
+	},
+	"_pkg/src/foo/bar/bar.go": &fstest.MapFile{
+		Data: []byte(`package bar
+
+import (
+	"fmt"
+)
+
+func PrintSomething() {
+	fmt.Println("I am a virtual filesystem printing something from _pkg/src/foo/bar/bar.go!")
+}
+`),
+	},
+	"localfoo/foo.go": &fstest.MapFile{
+		Data: []byte(`package localfoo
+
+import (
+	"fmt"
+)
+
+func PrintSomethingElse() {
+	fmt.Println("I am virtual filesystem printing else from localfoo/foo.go!")
+}
+`),
+	},
+}
+
+func TestFilesystemMapFS(t *testing.T) {
+	i := interp.New(interp.Options{
+		GoPath:               "./_pkg",
+		SourcecodeFilesystem: testFilesystem,
+	})
+	if err := i.Use(stdlib.Symbols); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := i.EvalPath(`main.go`)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

example/getfunc/getfunc_test.go

@@ -10,7 +10,9 @@ import (
 
 func TestGetFunc(t *testing.T) {
 	i := interp.New(interp.Options{GoPath: "./_gopath/"})
-	i.Use(stdlib.Symbols)
+	if err := i.Use(stdlib.Symbols); err != nil {
+		t.Fatal(err)
+	}
 
 	if _, err := i.Eval(`import "github.com/foo/bar"`); err != nil {
 		t.Fatal(err)

example/pkg/pkg_test.go

@@ -111,7 +111,10 @@ func TestPackages(t *testing.T) {
 
 			var stdout, stderr bytes.Buffer
 			i := interp.New(interp.Options{GoPath: goPath, Stdout: &stdout, Stderr: &stderr})
-			i.Use(stdlib.Symbols) // Use binary standard library
+			// Use binary standard library
+			if err := i.Use(stdlib.Symbols); err != nil {
+				t.Fatal(err)
+			}
 
 			var msg string
 			if test.evalFile != "" {
@@ -170,7 +173,10 @@ func TestPackagesError(t *testing.T) {
 		t.Run(test.desc, func(t *testing.T) {
 			// Init go interpreter
 			i := interp.New(interp.Options{GoPath: test.goPath})
-			i.Use(stdlib.Symbols) // Use binary standard library
+			// Use binary standard library
+			if err := i.Use(stdlib.Symbols); err != nil {
+				t.Fatal(err)
+			}
 
 			// Load pkg from sources
 			_, err := i.Eval(`import "github.com/foo/pkg"`)

extract/extract.go

@@ -25,7 +25,7 @@ import (
 	"text/template"
 )
 
-const model = `// Code generated by 'yaegi extract {{.PkgName}}'. DO NOT EDIT.
+const model = `// Code generated by 'yaegi extract {{.ImportPath}}'. DO NOT EDIT.
 
 {{.License}}
 
@@ -39,7 +39,7 @@ import (
 	"{{$key}}"
 	{{- end}}
 {{- end}}
-	"{{.PkgName}}"
+	"{{.ImportPath}}"
 	"reflect"
 )
 
@@ -74,6 +74,7 @@ func init() {
 {{range $key, $value := .Wrap -}}
 	// {{$value.Name}} is an interface wrapper for {{$key}} type
 	type {{$value.Name}} struct {
+		IValue interface{}
 		{{range $m := $value.Method -}}
 		W{{$m.Name}} func{{$m.Param}} {{$m.Result}}
 		{{end}}
@@ -167,8 +168,8 @@ func (e *Extractor) genContent(importPath string, p *types.Package) ([]byte, err
 			continue
 		}
 
-		pname := path.Base(importPath) + "." + name
-		if rname := path.Base(importPath) + name; restricted[rname] {
+		pname := p.Name() + "." + name
+		if rname := p.Name() + name; restricted[rname] {
 			// Restricted symbol, locally provided by stdlib wrapper.
 			pname = rname
 		}
@@ -203,7 +204,15 @@ func (e *Extractor) genContent(importPath string, p *types.Package) ([]byte, err
 						if args[j] = v.Name(); args[j] == "" {
 							args[j] = fmt.Sprintf("a%d", j)
 						}
-						params[j] = args[j] + " " + types.TypeString(v.Type(), qualify)
+						// process interface method variadic parameter
+						if sign.Variadic() && j == len(args)-1 { // check is last arg
+							// only replace the first "[]" to "..."
+							at := types.TypeString(v.Type(), qualify)[2:]
+							params[j] = args[j] + " ..." + at
+							args[j] += "..."
+						} else {
+							params[j] = args[j] + " " + types.TypeString(v.Type(), qualify)
+						}
 					}
 					arg := "(" + strings.Join(args, ", ") + ")"
 					param := "(" + strings.Join(params, ", ") + ")"
@@ -263,14 +272,15 @@ func (e *Extractor) genContent(importPath string, p *types.Package) ([]byte, err
 
 	b := new(bytes.Buffer)
 	data := map[string]interface{}{
-		"Dest":      e.Dest,
-		"Imports":   imports,
-		"PkgName":   importPath,
-		"Val":       val,
-		"Typ":       typ,
-		"Wrap":      wrap,
-		"BuildTags": buildTags,
-		"License":   e.License,
+		"Dest":       e.Dest,
+		"Imports":    imports,
+		"ImportPath": importPath,
+		"PkgName":    path.Join(importPath, p.Name()),
+		"Val":        val,
+		"Typ":        typ,
+		"Wrap":       wrap,
+		"BuildTags":  buildTags,
+		"License":    e.License,
 	}
 	err = parse.Execute(b, data)
 	if err != nil {
@@ -436,7 +446,7 @@ func GetMinor(part string) string {
 	return minor
 }
 
-const defaultMinorVersion = 16
+const defaultMinorVersion = 17
 
 func genBuildTags() (string, error) {
 	version := runtime.Version()

extract/extract_test.go

@@ -18,7 +18,7 @@ import (
 )
 
 func init() {
-	Symbols["guthib.com/baz"] = map[string]reflect.Value{
+	Symbols["guthib.com/baz/baz"] = map[string]reflect.Value{
 		// function, constant and variable definitions
 		"Hello": reflect.ValueOf(baz.Hello),
 	}
@@ -43,7 +43,7 @@ func TestPackages(t *testing.T) {
 			// We check this one because it shows both defects when we break it: the value
 			// gets corrupted, and the type becomes token.INT
 			// TODO(mpl): if the ident between key and value becomes annoying, be smarter about it.
-			contains: `"MaxFloat64":             reflect.ValueOf(constant.MakeFromLiteral("179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", token.FLOAT, 0)),`,
+			contains: `"MaxFloat32":             reflect.ValueOf(constant.MakeFromLiteral("340282346638528859811704183484516925440", token.FLOAT, 0)),`,
 		},
 		{
 			desc:     "using relative path, using go.mod",
@@ -78,6 +78,49 @@ func TestPackages(t *testing.T) {
 			importPath: "guthib.com/baz",
 			expected:   expectedOutput,
 		},
+		{
+			desc:       "using relative path, package name is not same as import path",
+			wd:         "./testdata/6/src/guthib.com/bar",
+			arg:        "../baz-baz",
+			importPath: "guthib.com/baz",
+			expected:   expectedOutput,
+		},
+		{
+			desc:       "using relative path, interface method parameter is variadic",
+			wd:         "./testdata/7/src/guthib.com/variadic",
+			arg:        "../variadic",
+			importPath: "guthib.com/variadic",
+			expected: `
+// Code generated by 'yaegi extract guthib.com/variadic'. DO NOT EDIT.
+
+package variadic
+
+import (
+	"guthib.com/variadic"
+	"reflect"
+)
+
+func init() {
+	Symbols["guthib.com/variadic/variadic"] = map[string]reflect.Value{
+		// type definitions
+		"Variadic": reflect.ValueOf((*variadic.Variadic)(nil)),
+
+		// interface wrapper definitions
+		"_Variadic": reflect.ValueOf((*_guthib_com_variadic_Variadic)(nil)),
+	}
+}
+
+// _guthib_com_variadic_Variadic is an interface wrapper for Variadic type
+type _guthib_com_variadic_Variadic struct {
+	IValue interface{}
+	WCall  func(method string, args ...[]interface{}) (interface{}, error)
+}
+
+func (W _guthib_com_variadic_Variadic) Call(method string, args ...[]interface{}) (interface{}, error) {
+	return W.WCall(method, args...)
+}
+`[1:],
+		},
 	}
 
 	for _, test := range testCases {

extract/testdata/6/src/guthib.com/bar/main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"guthib.com/baz"
+)
+
+func main() {
+	baz.Hello()
+}

extract/testdata/6/src/guthib.com/baz-baz/baz.go

@@ -0,0 +1,5 @@
+package baz
+
+func Hello() {
+	println("HELLO")
+}

extract/testdata/6/src/guthib.com/baz-baz/go.mod

@@ -0,0 +1 @@
+module guthib.com/baz-baz

extract/testdata/7/src/guthib.com/variadic/go.mod

@@ -0,0 +1 @@
+module guthib.com/baz-baz/variadic

extract/testdata/7/src/guthib.com/variadic/variadic.go

@@ -0,0 +1,5 @@
+package variadic
+
+type Variadic interface {
+	Call(method string, args ...[]interface{}) (interface{}, error)
+}

go.mod

@@ -1,3 +1,3 @@
 module github.com/traefik/yaegi
 
-go 1.12
+go 1.16

internal/cmd/genop/genop.go

@@ -289,6 +289,13 @@ func {{$name}}Assign(n *node) {
 	next := getExec(n.tnext)
 	typ := n.typ.TypeOf()
 	c0, c1 := n.child[0], n.child[1]
+	setMap := isMapEntry(c0)
+	var mapValue, indexValue func(*frame) reflect.Value
+
+	if setMap {
+        mapValue = genValue(c0.child[0])
+        indexValue = genValue(c0.child[1])
+    }
 
 	if c1.rval.IsValid() {
 		switch typ.Kind() {
@@ -299,6 +306,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v, s := v0(f)
 				v.SetString(s {{$op.Name}} v1)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- end}}
@@ -312,6 +322,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v, i := v0(f)
 				v.SetInt(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
@@ -320,6 +333,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v, i := v0(f)
 				v.SetUint(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- if $op.Float}}
@@ -329,6 +345,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v, i := v0(f)
 				v.SetFloat(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		case reflect.Complex64, reflect.Complex128:
@@ -337,6 +356,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v := v0(f)
 				v.SetComplex(v.Complex() {{$op.Name}} v1)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- end}}
@@ -350,6 +372,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v, s := v0(f)
 				v.SetString(s {{$op.Name}} v1(f).String())
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- end}}
@@ -364,6 +389,9 @@ func {{$name}}Assign(n *node) {
 				v, i := v0(f)
 				_, j := v1(f)
 				v.SetInt(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
@@ -373,6 +401,9 @@ func {{$name}}Assign(n *node) {
 				v, i := v0(f)
 				_, j := v1(f)
 				v.SetUint(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- if $op.Float}}
@@ -383,6 +414,9 @@ func {{$name}}Assign(n *node) {
 				v, i := v0(f)
 				_, j := v1(f)
 				v.SetFloat(i {{$op.Name}} j)
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		case reflect.Complex64, reflect.Complex128:
@@ -391,6 +425,9 @@ func {{$name}}Assign(n *node) {
 			n.exec = func(f *frame) bltn {
 				v := v0(f)
 				v.SetComplex(v.Complex() {{$op.Name}} v1(f).Complex())
+				if setMap {
+					mapValue(f).SetMapIndex(indexValue(f), v)
+				}
 				return next
 			}
 		{{- end}}
@@ -402,34 +439,54 @@ func {{$name}}Assign(n *node) {
 func {{$name}}(n *node) {
 	next := getExec(n.tnext)
 	typ := n.typ.TypeOf()
+	c0 := n.child[0]
+	setMap := isMapEntry(c0)
+	var mapValue, indexValue func(*frame) reflect.Value
+
+	if setMap {
+        mapValue = genValue(c0.child[0])
+        indexValue = genValue(c0.child[1])
+    }
 
 	switch typ.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		v0 := genValueInt(n.child[0])
+		v0 := genValueInt(c0)
 		n.exec = func(f *frame) bltn {
 			v, i := v0(f)
 			v.SetInt(i {{$op.Name}} 1)
+			if setMap {
+                mapValue(f).SetMapIndex(indexValue(f), v)
+            }
 			return next
 		}
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		v0 := genValueUint(n.child[0])
+		v0 := genValueUint(c0)
 		n.exec = func(f *frame) bltn {
 			v, i := v0(f)
 			v.SetUint(i {{$op.Name}} 1)
+			if setMap {
+                mapValue(f).SetMapIndex(indexValue(f), v)
+            }
 			return next
 		}
 	case reflect.Float32, reflect.Float64:
-		v0 := genValueFloat(n.child[0])
+		v0 := genValueFloat(c0)
 		n.exec = func(f *frame) bltn {
 			v, i := v0(f)
 			v.SetFloat(i {{$op.Name}} 1)
+			if setMap {
+                mapValue(f).SetMapIndex(indexValue(f), v)
+            }
 			return next
 		}
 	case reflect.Complex64, reflect.Complex128:
-		v0 := genValue(n.child[0])
+		v0 := genValue(c0)
 		n.exec = func(f *frame) bltn {
 			v := v0(f)
 			v.SetComplex(v.Complex() {{$op.Name}} 1)
+			if setMap {
+                mapValue(f).SetMapIndex(indexValue(f), v)
+            }
 			return next
 		}
 	}

internal/unsafe2/unsafe.go

@@ -0,0 +1,52 @@
+package unsafe2
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+type dummy struct{}
+
+// DummyType represents a stand-in for a recursive type.
+var DummyType = reflect.TypeOf(dummy{})
+
+type rtype struct {
+	_ [48]byte
+}
+
+type emptyInterface struct {
+	typ *rtype
+	_   unsafe.Pointer
+}
+
+type structField struct {
+	_   int64
+	typ *rtype
+	_   uintptr
+}
+
+type structType struct {
+	rtype
+	_      int64
+	fields []structField
+}
+
+// SwapFieldType swaps the type of the struct field with the given type.
+//
+// The struct type must have been created at runtime. This is very unsafe.
+func SwapFieldType(s reflect.Type, idx int, t reflect.Type) {
+	if s.Kind() != reflect.Struct || idx >= s.NumField() {
+		return
+	}
+
+	rtyp := unpackType(s)
+	styp := (*structType)(unsafe.Pointer(rtyp))
+	f := styp.fields[idx]
+	f.typ = unpackType(t)
+	styp.fields[idx] = f
+}
+
+func unpackType(t reflect.Type) *rtype {
+	v := reflect.New(t).Elem().Interface()
+	return (*emptyInterface)(unsafe.Pointer(&v)).typ
+}

internal/unsafe2/unsafe_test.go

@@ -0,0 +1,33 @@
+package unsafe2_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/traefik/yaegi/internal/unsafe2"
+)
+
+func TestSwapFieldType(t *testing.T) {
+	f := []reflect.StructField{
+		{
+			Name: "A",
+			Type: reflect.TypeOf(int(0)),
+		},
+		{
+			Name: "B",
+			Type: reflect.PtrTo(unsafe2.DummyType),
+		},
+		{
+			Name: "C",
+			Type: reflect.TypeOf(int64(0)),
+		},
+	}
+	typ := reflect.StructOf(f)
+	ntyp := reflect.PtrTo(typ)
+
+	unsafe2.SwapFieldType(typ, 1, ntyp)
+
+	if typ.Field(1).Type != ntyp {
+		t.Fatalf("unexpected field type: want %s; got %s", ntyp, typ.Field(1).Type)
+	}
+}

interp/ast.go

@@ -357,7 +357,7 @@ func ignoreError(err error, src string) bool {
 }
 
 func wrapInMain(src string) string {
-	return fmt.Sprintf("package main; func main() {%s}", src)
+	return fmt.Sprintf("package main; func main() {%s\n}", src)
 }
 
 // Note: no type analysis is performed at this stage, it is done in pre-order
@@ -680,6 +680,7 @@ func (interp *Interpreter) ast(src, name string, inc bool) (string, *node, error
 
 		case *ast.FuncDecl:
 			n := addChild(&root, anc, pos, funcDecl, aNop)
+			n.val = n
 			if a.Recv == nil {
 				// function is not a method, create an empty receiver list
 				addChild(&root, astNode{n, nod}, pos, fieldList, aNop)
@@ -716,7 +717,7 @@ func (interp *Interpreter) ast(src, name string, inc bool) (string, *node, error
 			n := addChild(&root, anc, pos, identExpr, aNop)
 			n.ident = a.Name
 			st.push(n, nod)
-			if n.anc.kind == defineStmt && n.anc.nright == 0 {
+			if n.anc.kind == defineStmt && n.anc.anc.kind == constDecl && n.anc.nright == 0 {
 				// Implicit assign expression (in a ConstDecl block).
 				// Clone assign source and type from previous
 				a := n.anc
@@ -858,7 +859,8 @@ func (interp *Interpreter) ast(src, name string, inc bool) (string, *node, error
 		case *ast.ValueSpec:
 			kind := valueSpec
 			act := aNop
-			if a.Values != nil {
+			switch {
+			case a.Values != nil:
 				if len(a.Names) > 1 && len(a.Values) == 1 {
 					if anc.node.kind == constDecl || anc.node.kind == varDecl {
 						kind = defineXStmt
@@ -874,7 +876,9 @@ func (interp *Interpreter) ast(src, name string, inc bool) (string, *node, error
 					}
 					act = aAssign
 				}
-			} else if anc.node.kind == constDecl {
+			case anc.node.kind == constDecl:
+				kind, act = defineStmt, aAssign
+			case anc.node.kind == varDecl && anc.node.anc.kind != fileStmt:
 				kind, act = defineStmt, aAssign
 			}
 			n := addChild(&root, anc, pos, kind, act)
@@ -897,6 +901,7 @@ func (interp *Interpreter) ast(src, name string, inc bool) (string, *node, error
 	if pkgName == "" {
 		return "", root, errors.New("no package name found")
 	}
+	interp.roots = append(interp.roots, root)
 	return pkgName, root, err
 }
 

interp/build.go

@@ -178,6 +178,7 @@ var knownArch = map[string]bool{
 	"amd64":    true,
 	"arm":      true,
 	"arm64":    true,
+	"loong64":  true,
 	"mips":     true,
 	"mips64":   true,
 	"mips64le": true,