Merge branch 'master' into trace

_test/assign19.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	a, b, c := 1, 2
+	_, _, _ = a, b, c
+}
+
+// Error:
+// _test/assign19.go:4:2: cannot assign 2 values to 3 variables

_test/issue-1640.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"errors"
+)
+
+func ShortVariableDeclarations() (i int, err error) {
+	r, err := 1, errors.New("test")
+	i = r
+	return
+}
+
+func main() {
+	_, er := ShortVariableDeclarations()
+	if er != nil {
+		println("ShortVariableDeclarations ok")
+	} else {
+		println("ShortVariableDeclarations not ok")
+	}
+}
+
+// Output:
+// ShortVariableDeclarations ok

extract/extract.go

@@ -87,8 +87,8 @@ func init() {
 			if W.WString == nil {
 				return ""
 			}
-			{{end -}}
-			{{$m.Ret}} W.W{{$m.Name}}{{$m.Arg}}
+			{{end}}
+			{{- $m.Ret}} W.W{{$m.Name}}{{$m.Arg -}}
 		}
 	{{end}}
 {{end}}

interp/cfg.go

@@ -649,6 +649,14 @@ func (interp *Interpreter) cfg(root *node, sc *scope, importPath, pkgName string
 				sbase = len(n.child) - n.nright
 			}
 
+			// If len(RHS) > 1, each node must be single-valued, and the nth expression
+			// on the right is assigned to the nth operand on the left, so the number of
+			// nodes on the left and right sides must be equal
+			if n.nright > 1 && n.nright != n.nleft {
+				err = n.cfgErrorf("cannot assign %d values to %d variables", n.nright, n.nleft)
+				return
+			}
+
 			wireChild(n)
 			for i := 0; i < n.nleft; i++ {
 				dest, src := n.child[i], n.child[sbase+i]
@@ -683,7 +691,7 @@ func (interp *Interpreter) cfg(root *node, sc *scope, importPath, pkgName string
 					if dest.typ.incomplete {
 						return
 					}
-					if sc.global {
+					if sc.global || sc.isRedeclared(dest) {
 						// Do not overload existing symbols (defined in GTA) in global scope.
 						sym, _, _ = sc.lookup(dest.ident)
 					}

interp/interp_consistent_test.go

@@ -45,6 +45,7 @@ func TestInterpConsistencyBuild(t *testing.T) {
 			file.Name() == "assign11.go" || // expect error
 			file.Name() == "assign12.go" || // expect error
 			file.Name() == "assign15.go" || // expect error
+			file.Name() == "assign19.go" || // expect error
 			file.Name() == "bad0.go" || // expect error
 			file.Name() == "break0.go" || // expect error
 			file.Name() == "cont3.go" || // expect error

interp/interp_issue_1634_test.go

@@ -0,0 +1,59 @@
+package interp
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestExportClosureArg(t *testing.T) {
+	outExp := []byte("0\n1\n2\n")
+	// catch stdout
+	backupStdout := os.Stdout
+	defer func() {
+		os.Stdout = backupStdout
+	}()
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	i := New(Options{})
+	err := i.Use(Exports{
+		"tmp/tmp": map[string]reflect.Value{
+			"Func": reflect.ValueOf(func(s *[]func(), f func()) { *s = append(*s, f) }),
+		},
+	})
+	if err != nil {
+		t.Error(err)
+	}
+	i.ImportUsed()
+
+	_, err = i.Eval(`
+func main() {
+	fs := []func(){}
+	
+	for i := 0; i < 3; i++ {
+		i := i
+		tmp.Func(&fs, func() { println(i) })
+	}
+	for _, f := range fs {
+		f()
+	}
+}
+`)
+	if err != nil {
+		t.Error(err)
+	}
+	// read stdout
+	if err = w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	outInterp, err := io.ReadAll(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(outInterp, outExp) {
+		t.Errorf("\nGot: %q,\n want: %q", string(outInterp), string(outExp))
+	}
+}

interp/run.go

@@ -987,7 +987,20 @@ func genFunctionWrapper(n *node) func(*frame) reflect.Value {
 	}
 	funcType := n.typ.TypeOf()
 
+	value := genValue(n)
+	isDefer := false
+	if n.anc != nil && n.anc.anc != nil && n.anc.anc.kind == deferStmt {
+		isDefer = true
+	}
+
 	return func(f *frame) reflect.Value {
+		v := value(f)
+		if !isDefer && v.Kind() == reflect.Func {
+			// fixes #1634, if v is already a func, then don't re-wrap
+			// because original wrapping cloned the frame but this doesn't
+			return v
+		}
+
 		return reflect.MakeFunc(funcType, func(in []reflect.Value) []reflect.Value {
 			// Allocate and init local frame. All values to be settable and addressable.
 			fr := newFrame(f, len(def.types), f.runid())
@@ -1400,6 +1413,13 @@ func call(n *node) {
 		}
 		runCfg(def.child[3].start, nf, def, n)
 
+		// Set return values
+		for i, v := range rvalues {
+			if v != nil {
+				v(f).Set(nf.data[i])
+			}
+		}
+
 		// Handle branching according to boolean result
 		if fnext != nil && !nf.data[0].Bool() {
 			return fnext

interp/scope.go

@@ -145,6 +145,14 @@ func (s *scope) lookup(ident string) (*symbol, int, bool) {
 	return nil, 0, false
 }
 
+func (s *scope) isRedeclared(n *node) bool {
+	if !isNewDefine(n, s) {
+		return false
+	}
+	// Existing symbol in the scope indicates a redeclaration.
+	return s.sym[n.ident] != nil
+}
+
 func (s *scope) rangeChanType(n *node) *itype {
 	if sym, _, found := s.lookup(n.child[1].ident); found {
 		if t := sym.typ; len(n.child) == 3 && t != nil && (t.cat == chanT || t.cat == chanRecvT) {