fix: avoid memory errors by handling frame indirections (#739)

In all situations where the results are set directly
to the frame, and not using a value helper, the right level of
indirections must be applied, otherwise we may end-up writing
in the wrong frame (the local one, instead of a caller or global).

Fixes #735.

.golangci.toml

@@ -38,6 +38,9 @@
     "gocognit",
     "stylecheck",
     "gomnd",
+    "testpackage",
+    "goerr113",
+    "nestif",
   ]
 
 [issues]

.travis.yml

@@ -39,7 +39,7 @@ install:
   - go mod download
 
 before_script:
-  - rm -f interp/op.go interp/interp_test.go
+  - rm -f interp/op.go
   - make generate
   - git update-index -q --refresh
   - CHANGED=$(git diff-index --name-only HEAD --)

_test/add0.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	var a interface{} = 2 + 5
+	println(a.(int))
+}
+
+// Output:
+// 7

_test/add1.go

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

_test/add2.go

@@ -0,0 +1,12 @@
+package main
+
+type iface interface{}
+
+func main() {
+	b := 2
+	var a iface = 5 + b
+	println(a.(int))
+}
+
+// Output:
+// 7

_test/append0.go

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

_test/assign11.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+	_, _, _ = fmt.Println("test")
+}
+
+// Error:
+// 6:2: assignment mismatch: 3 variables but fmt.Println returns 2 values

_test/assign12.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	a, b, c := fmt.Println("test")
+	println(a, b, c)
+}
+
+// Error:
+// 6:2: assignment mismatch: 3 variables but fmt.Println returns 2 values

_test/assign13.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func getStr() string {
+	return "test"
+}
+
+func main() {
+	m := make(map[string]string, 0)
+	m["a"] = fmt.Sprintf("%v", 0.1)
+	m["b"] = string(fmt.Sprintf("%v", 0.1))
+	m["c"] = getStr()
+
+	fmt.Println(m)
+}
+
+// Output:
+// map[a:0.1 b:0.1 c:test]

_test/assign14.go

@@ -0,0 +1,16 @@
+package main
+
+var optionsG map[string]string = nil
+
+var roundG = 30
+
+func main() {
+	dummy := roundG
+	roundG = dummy + 1
+	println(roundG)
+	println(optionsG == nil)
+}
+
+// Output:
+// 31
+// true

_test/assign15.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var c chan<- struct{} = make(chan struct{})
+	var d <-chan struct{} = c
+
+	_ = d
+}
+
+// Error:
+// _test/assign15.go:5:26: cannot use type chan<- struct{} as type <-chan struct{} in assignment

_test/baz-bat/baz-bat.go

@@ -0,0 +1,3 @@
+package baz
+
+var Name = "baz-bat"

_test/bin4.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func Bar(s string) bool {
+	a := strings.HasPrefix("fas", "f")
+	b := strings.HasPrefix("aaaaa", "a")
+	a_and_b := strings.HasPrefix("fas", "f") && strings.HasPrefix("aaaaa", "a")
+	fmt.Println(a, b, a && b, a_and_b)
+	return a && b
+}
+
+func main() {
+	println(Bar("kung"))
+}

_test/bin5.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"net"
+)
+
+func main() {
+	addr := net.TCPAddr{IP: net.IPv4(1, 1, 1, 1), Port: 80}
+	var s fmt.Stringer = &addr
+	fmt.Println(s.String())
+}
+
+// Output:
+// 1.1.1.1:80

_test/cap0.go

@@ -0,0 +1,13 @@
+package main
+
+func f(a []int) interface{} {
+	return cap(a)
+}
+
+func main() {
+	a := []int{1, 2}
+	println(f(a).(int))
+}
+
+// Output:
+// 2

_test/chan10.go

@@ -0,0 +1,12 @@
+package main
+
+import "time"
+
+func main() {
+	var tick <-chan time.Time = time.Tick(time.Millisecond)
+	_ = tick
+	println("success")
+}
+
+// Output:
+// success

_test/comp1.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	var a interface{} = 1 < 2
+	println(a.(bool))
+}
+
+// Output:
+// true

_test/complex4.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func f(a, b float64) interface{} { return complex(a, b) }
+
+func main() {
+	a := f(3, 2)
+	fmt.Println(a.(complex128))
+}
+
+// Output:
+// (3+2i)

_test/composite10.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := []map[int]int{make(map[int]int)}
+
+	for _, b := range a {
+		fmt.Println(b)
+	}
+}
+
+// Output:
+// map[]

_test/composite9.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := [][]int{make([]int,0)}
+
+	for _, b := range a {
+		fmt.Println(b)
+	}
+}
+
+// Output:
+// []

_test/const11.go

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	const (
+		x = 2 * iota
+		dim
+	)
+	var t [dim * 2]int
+	println(t[0], len(t))
+}
+
+// Output:
+// 0 4

_test/const12.go

@@ -0,0 +1,17 @@
+package main
+
+type Kind int
+
+const (
+	None Kind = 0
+	Left Kind = 1 << iota
+	Right
+	Both Kind = Left | Right
+)
+
+func main() {
+	println(None, Left, Right, Both)
+}
+
+// Output:
+// 0 2 4 6

_test/const13.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	const tooBig = 1267650600228229401496703205376
+	const huge = 1 << 100
+	const large = huge >> 38
+
+	fmt.Println(large)
+}
+
+// Output:
+// 4611686018427387904

_test/const14.go

@@ -0,0 +1,13 @@
+package main
+
+import "compress/flate"
+
+func f1(i int) { println("i:", i) }
+
+func main() {
+	i := flate.BestSpeed
+	f1(i)
+}
+
+// Output:
+// i: 1

_test/copy2.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+func f(a, b []int) interface{} { return copy(a, b) }
+
+func main() {
+	a := []int{10, 20, 30}
+	b := [4]int{}
+	c := b[:]
+	r := f(c, a)
+	fmt.Println(r.(int))
+}
+
+// Output:
+// 3

_test/defer5.go

@@ -0,0 +1,32 @@
+package main
+
+func f1() {
+	defer println("f1-begin")
+	f2()
+	defer println("f1-end")
+}
+
+func f2() {
+	defer println("f2-begin")
+	f3()
+	defer println("f2-end")
+}
+
+func f3() {
+	defer println("f3-begin")
+	println("hello")
+	defer println("f3-end")
+}
+
+func main() {
+	f1()
+}
+
+// Output:
+// hello
+// f3-end
+// f3-begin
+// f2-end
+// f2-begin
+// f1-end
+// f1-begin

_test/defer6.go

@@ -0,0 +1,27 @@
+package main
+
+func f1() {
+	defer print("f1-begin ")
+	f2()
+	defer print("f1-end ")
+}
+
+func f2() {
+	defer print("f2-begin ")
+	f3()
+	defer print("f2-end ")
+}
+
+func f3() {
+	defer print("f3-begin ")
+	print("hello ")
+	defer print("f3-end ")
+}
+
+func main() {
+	f1()
+	println()
+}
+
+// Output:
+// hello f3-end f3-begin f2-end f2-begin f1-end f1-begin

_test/defer7.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func f1(in, out []string) {
+	defer copy(out, in)
+}
+
+func main() {
+	in := []string{"foo", "bar"}
+	out := make([]string, 2)
+	f1(in, out)
+
+	fmt.Println(out)
+}
+
+// Output:
+// [foo bar]

_test/defer8.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func f1(m map[string]string) {
+	defer delete(m, "foo")
+	defer delete(m, "test")
+
+	fmt.Println(m)
+}
+
+func main() {
+	m := map[string]string{
+		"foo": "bar",
+		"baz": "bat",
+	}
+	f1(m)
+
+	fmt.Println(m)
+}
+
+// Output:
+// map[baz:bat foo:bar]
+// map[baz:bat]

_test/defer9.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+func f1(ch chan string) {
+	defer close(ch)
+
+	ch <- "foo"
+}
+
+func main() {
+	ch := make(chan string, 1)
+	f1(ch)
+
+	for s := range ch {
+		fmt.Println(s)
+	}
+}
+
+// Output:
+// foo

_test/fun13.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+type T struct{}
+
+func newT() (T, error) { return T{}, nil }
+
+func main() {
+	var (
+		i   interface{}
+		err error
+	)
+	i, err = newT()
+	fmt.Println(i, err)
+}
+
+// Output:
+// {} <nil>

_test/fun14.go

@@ -0,0 +1,13 @@
+package main
+
+func f() (bool, int) { return true, 2 }
+
+func g() (bool, int) { return f() }
+
+func main() {
+	b, i := g()
+	println(b, i)
+}
+
+// Output:
+// true 2

_test/fun15.go

@@ -0,0 +1,11 @@
+package main
+
+func f1(a int) interface{} { return a + 1 }
+
+func main() {
+	c := f1(3)
+	println(c.(int))
+}
+
+// Output:
+// 4

_test/fun16.go

@@ -0,0 +1,13 @@
+package main
+
+func f1(a int) int { return a + 1 }
+
+func f2(a int) interface{} { return f1(a) }
+
+func main() {
+	c := f2(3)
+	println(c.(int))
+}
+
+// Output:
+// 4

_test/fun17.go

@@ -0,0 +1,13 @@
+package main
+
+func f1(a int) interface{} { return a + 1 }
+
+func f2(a int) interface{} { return f1(a) }
+
+func main() {
+	c := f2(3)
+	println(c.(int))
+}
+
+// Output:
+// 4

_test/fun18.go

@@ -0,0 +1,12 @@
+package main
+
+var m = map[string]int{"foo": 1, "bar": 2}
+
+func f(s string) interface{} { return m[s] }
+
+func main() {
+	println(f("foo").(int))
+}
+
+// Output:
+// 1

_test/fun19.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+)
+
+func foo() ([]string, error) {
+	return nil, fmt.Errorf("bar")
+}
+
+func main() {
+	a, b := foo()
+	fmt.Println(a, b)
+}
+
+// Output:
+// [] bar

_test/fun20.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+var myerr error = fmt.Errorf("bar")
+
+func ferr() error { return myerr }
+
+func foo() ([]string, error) {
+	return nil, ferr()
+}
+
+func main() {
+	a, b := foo()
+	fmt.Println(a, b)
+}
+
+// Output:
+// [] bar

_test/fun21.go

@@ -0,0 +1,12 @@
+package main
+
+func Bar() string {
+	return
+}
+
+func main() {
+	println(Bar())
+}
+
+// Error:
+// 4:2: not enough arguments to return

_test/fun22.go

@@ -0,0 +1,10 @@
+package main
+
+import "time"
+
+func main() {
+	time.Date()
+}
+
+// Error:
+// 6:2: not enough arguments in call to time.Date

_test/imag0.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func f(c complex128) interface{} { return imag(c) }
+
+func main() {
+	c := complex(3, 2)
+	a := f(c)
+	fmt.Println(a.(float64))
+}
+
+// Output:
+// 2

_test/import9.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/containous/yaegi/_test/baz-bat"
+
+func main() {
+	println(baz.Name)
+}
+
+// Output:
+// baz-bat

_test/interface36.go

@@ -0,0 +1,37 @@
+package main
+
+import "fmt"
+
+var (
+	t *S
+	_ I = t
+	_ J = t
+)
+
+type S struct {
+	Name string
+}
+
+func (s *S) F() int { return len(s.Name) }
+func (s *S) G() int { return s.F() }
+func (s *S) Ri() I  { return s }
+func (s *S) Rj() J  { return s }
+
+type J interface {
+	I
+	G() int
+	Rj() J
+}
+
+type I interface {
+	F() int
+	Ri() I
+}
+
+func main() {
+	var j J
+	fmt.Println(j)
+}
+
+// Output:
+// <nil>

_test/interface37.go

@@ -0,0 +1,23 @@
+package main
+
+type I interface {
+	A() string
+	B() string
+}
+
+type s struct{}
+
+func NewS() (I, error) {
+	return &s{}, nil
+}
+
+func (c *s) A() string { return "a" }
+func (c *s) B() string { return "b" }
+
+func main() {
+	s, _ := NewS()
+	println(s.A())
+}
+
+// Output:
+// a

_test/interface38.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+type foo struct {
+	bar string
+}
+
+func (f foo) String() string {
+	return "Hello from " + f.bar
+}
+
+func main() {
+	var f fmt.Stringer = foo{bar: "bar"}
+	fmt.Println(f)
+}
+
+// Output:
+// Hello from bar

_test/interface39.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+type foo struct {
+	bar string
+}
+
+func (f *foo) String() string {
+	return "Hello from " + f.bar
+}
+
+func main() {
+	var f fmt.Stringer = &foo{bar: "bar"}
+	fmt.Println(f)
+}
+
+// Output:
+// Hello from bar

_test/interface40.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+type foo struct {
+	bar string
+}
+
+func (f foo) String() string {
+	return "Hello from " + f.bar
+}
+
+func Foo(s string) fmt.Stringer {
+	return foo{s}
+}
+
+func main() {
+	f := Foo("bar")
+	fmt.Println(f)
+}
+
+// Output:
+// Hello from bar

_test/interface41.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+type foo struct {
+	bar string
+}
+
+func (f *foo) String() string {
+	return "Hello from " + f.bar
+}
+
+func Foo(s string) fmt.Stringer {
+	return &foo{s}
+}
+
+func main() {
+	f := Foo("bar")
+	fmt.Println(f)
+}
+
+// Output:
+// Hello from bar

_test/interface42.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	v := interface{}(0)
+
+	fmt.Println(v)
+}
+
+// Output:
+// 0

_test/interface43.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	v := interface{}(nil)
+
+	fmt.Println(v)
+}
+
+// Output:
+// <nil>

_test/issue-735.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+var optionsG map[string]string
+
+var roundG int = 30
+
+func strToInt(s string, defaultValue int) int {
+	n, err := strconv.ParseInt(s, 10, 0)
+	if err != nil {
+		return defaultValue
+	}
+	return int(n)
+}
+
+func main() {
+	optionsG := map[string]string{"round": "12", "b": "one"}
+	roundG = strToInt(optionsG["round"], 50)
+	fmt.Println(roundG)
+	fmt.Println(optionsG)
+}
+
+// Output:
+// 12
+// map[b:one round:12]

_test/len0.go

@@ -0,0 +1,13 @@
+package main
+
+func f(a []int) interface{} {
+	return len(a)
+}
+
+func main() {
+	a := []int{1, 2}
+	println(f(a).(int))
+}
+
+// Output:
+// 2

_test/make0.go

@@ -0,0 +1,13 @@
+package main
+
+func f() interface{} {
+	return make([]int, 2)
+}
+
+func main() {
+	a := f()
+	println(len(a.([]int)))
+}
+
+// Output:
+// 2

_test/make1.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func f() interface{} {
+	return make(map[int]int)
+}
+
+func main() {
+	a, ok := f().(map[int]int)
+	fmt.Println(a, ok)
+}
+
+// Output:
+// map[] true

_test/make2.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	var s uint = 4
+	t := make([]int, s)
+	fmt.Println(t)
+}
+
+// Output:
+// [0 0 0 0]

_test/map26.go

@@ -0,0 +1,11 @@
+package main
+
+var m = map[string]int{"foo": 1, "bar": 2}
+
+func main() {
+	var a interface{} = m["foo"]
+	println(a.(int))
+}
+
+// Output:
+// 1

_test/map27.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"text/template"
+)
+
+type fm map[string]interface{}
+
+type foo struct{}
+
+func main() {
+	a := make(fm)
+	a["foo"] = &foo{}
+	fmt.Println(a["foo"])
+
+	b := make(template.FuncMap) // type FuncMap map[string]interface{}
+	b["foo"] = &foo{}
+	fmt.Println(b["foo"])
+}
+
+// Output:
+// &{}
+// &{}

_test/map28.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"net/url"
+)
+
+func main() {
+	value1 := url.Values{}
+
+	value1.Set("first", "v1")
+	value1.Set("second", "v2")
+
+	l := 0
+	for k, v := range value1 {
+		l += len(k) + len(v)
+	}
+	println(l)
+}
+
+// Output:
+// 13

_test/map29.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+type Item struct {
+	Object interface{}
+	Expiry time.Duration
+}
+
+func main() {
+	items := map[string]Item{}
+
+	items["test"] = Item{
+		Object: "test",
+		Expiry: time.Second,
+	}
+
+	item := items["test"]
+	fmt.Println(item)
+}
+
+// Output:
+// {test 1s}

_test/method32.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var a = []func(string){bar}
+	 b := a[0]
+	 b("bar")
+}
+
+func bar(a string) {
+	fmt.Println(a)
+}
+
+// Output:
+// bar

_test/method33.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+)
+
+type T1 struct{}
+
+func (t1 T1) f() {
+	fmt.Println("T1.f()")
+}
+
+func (t1 T1) g() {
+	fmt.Println("T1.g()")
+}
+
+type T2 struct {
+	T1
+}
+
+func (t2 T2) f() {
+	fmt.Println("T2.f()")
+}
+
+type I interface {
+	f()
+}
+
+func printType(i I) {
+	if t1, ok := i.(T1); ok {
+		println("T1 ok")
+		t1.f()
+		t1.g()
+	}
+
+	if t2, ok := i.(T2); ok {
+		println("T2 ok")
+		t2.f()
+		t2.g()
+	}
+}
+
+func main() {
+	println("T1")
+	printType(T1{})
+	println("T2")
+	printType(T2{})
+}
+
+// Output:
+// T1
+// T1 ok
+// T1.f()
+// T1.g()
+// T2
+// T2 ok
+// T2.f()
+// T1.g()

_test/method34.go

@@ -0,0 +1,23 @@
+package main
+
+type Root struct {
+	Name string
+}
+
+type One struct {
+	Root
+}
+
+type Hi interface {
+	Hello() string
+}
+
+func (r *Root) Hello() string { return "Hello " + r.Name }
+
+func main() {
+	var one interface{} = &One{Root{Name: "test2"}}
+	println(one.(Hi).Hello())
+}
+
+// Output:
+// Hello test2

_test/new2.go

@@ -0,0 +1,13 @@
+package main
+
+func f() interface{} {
+	return new(int)
+}
+
+func main() {
+	a := f()
+	println(*(a.(*int)))
+}
+
+// Output:
+// 0

_test/nil2.go

@@ -0,0 +1,12 @@
+package main
+
+func test() error { return nil }
+
+func main() {
+	if err := test(); nil == err {
+		println("err is nil")
+	}
+}
+
+// Output:
+// err is nil

_test/not0.go

@@ -1,15 +1,15 @@
 package main
 
 func main() {
-        a := 0
-        b := true
+	a := 0
+	b := true
 	c := false
-        if (b && c) {
-                a = 1
-        } else {
-                a = -1
-        }
-        println(a)
+	if b && c {
+		a = 1
+	} else {
+		a = -1
+	}
+	println(a)
 }
 
 // Output:

_test/not2.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	var b interface{} = !(1 == 2)
+	println(b.(bool))
+}
+
+// Output:
+// true

_test/op6.go

@@ -0,0 +1,17 @@
+package main
+
+type T int
+
+func (t T) Error() string { return "T: error" }
+
+var invalidT T
+
+func main() {
+	var err error
+	if err != invalidT {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/op7.go

@@ -0,0 +1,17 @@
+package main
+
+type T int
+
+func (t T) Error() string { return "T: error" }
+
+var invalidT T
+
+func main() {
+	var err error
+	if err > invalidT {
+		println("ok")
+	}
+}
+
+// Error:
+// _test/op7.go:11:5: invalid operation: operator > not defined on error

_test/op8.go

@@ -0,0 +1,21 @@
+package main
+
+type I interface {
+	Get() interface{}
+}
+
+type T struct{}
+
+func (T) Get() interface{} {
+	return nil
+}
+
+func main() {
+	var i I = T{}
+	var ei interface{}
+
+	println(i != ei)
+}
+
+// Output:
+// true

_test/op9.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var i complex128 = 1i
+	var f complex128 = 0.4i
+
+	print(i > f)
+}
+
+// Error:
+// _test/op9.go:7:8: invalid operation: operator > not defined on complex128

_test/range7.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+)
+
+func someChan() <-chan struct{} {
+	c := make(chan struct{}, 1)
+	c <- struct{}{}
+	return c
+}
+
+func main() {
+	for _ = range someChan() {
+		fmt.Println("success")
+		return
+	}
+}
+
+// Output:
+// success

_test/range8.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	for _ = range time.Tick(time.Millisecond) {
+		fmt.Println("success")
+		return
+	}
+}
+
+// Output:
+// success

_test/range9.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var c chan<- struct{} = make(chan struct{})
+
+	for _ = range c {
+	}
+}
+
+// Error:
+// _test/range9.go:6:16: invalid operation: range c receive from send-only channel

_test/real0.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func f(c complex128) interface{} { return real(c) }
+
+func main() {
+	c := complex(3, 2)
+	a := f(c)
+	fmt.Println(a.(float64))
+}
+
+// Output:
+// 3

_test/recover2.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	println("hello")
+
+	var r interface{} = 1
+	r = recover()
+	if r == nil {
+		println("world")
+	}
+}
+
+// Output:
+// hello
+// world

_test/recover3.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+	println("hello")
+
+	var r interface{} = 1
+	r = recover()
+	fmt.Printf("%v\n", r)
+	if r == nil {
+		println("world")
+	}
+	if r != nil {
+		println("exception")
+	}
+}
+
+// Output:
+// hello
+// <nil>
+// world

_test/recover4.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func div(a, b int) (result int) {
+	defer func() {
+		r := recover()
+
+		fmt.Printf("r = %#v\n", r)
+
+		if r != nil {
+			result = 0
+		}
+	}()
+
+	return a / b
+}
+
+func main() {
+	println(div(30, 2))
+}
+
+// Output:
+// r = <nil>
+// 15

_test/redeclaration-global0.go

@@ -0,0 +1,14 @@
+package main
+
+type time int
+
+var time string
+
+func main() {
+	time = "hello"
+	println(time)
+}
+
+// Error:
+// ../_test/redeclaration-global0.go:5:5: time redeclared in this block
+//	previous declaration at ../_test/redeclaration-global0.go:3:6

_test/redeclaration-global1.go

@@ -0,0 +1,12 @@
+package main
+
+var time int
+
+type time string
+
+func main() {
+	var t time = "hello"
+	println(t)
+}
+
+// TODO: expected redeclaration error.

_test/redeclaration-global2.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"time"
+	"time"
+)
+
+func main() {
+	var t time.Time
+	println(t.String())
+}
+
+// Error:
+// ../_test/redeclaration-global2.go:5:2: time/redeclaration-global2.go redeclared in this block

_test/redeclaration-global3.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"time"
+)
+
+var time string
+
+func main() {
+	time = "hello"
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global3.go:7:5: time redeclared in this block

_test/redeclaration-global4.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"time"
+)
+
+type time string
+
+func main() {
+	var t time = "hello"
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global4.go:7:6: time redeclared in this block

_test/redeclaration-global5.go

@@ -0,0 +1,15 @@
+package main
+
+var time int
+
+func time() string {
+	return "hello"
+}
+
+func main() {
+	t := time()
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global5.go:5:1: time redeclared in this block

_test/redeclaration-global6.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"time"
+)
+
+func time() string {
+	return "hello"
+}
+
+func main() {
+	t := time()
+	println(t)
+}
+
+// Error:
+// ../_test/redeclaration-global6.go:7:1: time redeclared in this block

_test/redeclaration0.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	type foo struct {
+		yolo string
+	}
+
+	var foo int
+	foo = 2
+	println(foo)
+}
+
+// Error:
+// ../_test/redeclaration0.go:8:6: foo redeclared in this block
+//	previous declaration at ../_test/redeclaration0.go:4:7

_test/redeclaration1.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	var foo string
+
+	var foo int
+	foo = 2
+	println(foo)
+}
+
+// Error:
+// ../_test/redeclaration1.go:6:6: foo redeclared in this block

_test/redeclaration2.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	var foo struct {
+		yolo string
+	}
+
+	var foo int
+	foo = 2
+	println(foo)
+}
+
+// Error:
+// ../_test/redeclaration2.go:8:6: foo redeclared in this block
+//	previous declaration at ../_test/redeclaration2.go:4:6

_test/redeclaration3.go

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	var foo int
+	foo = 2
+
+	type foo struct{}
+	var bar foo
+	println(bar)
+}
+
+// Error:
+// ../_test/redeclaration3.go:7:7: foo redeclared in this block

_test/redeclaration4.go

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	var foo struct{
+		yolo string
+	}
+
+	type foo struct{}
+	var bar foo
+	println(bar)
+}
+
+// Error:
+// ../_test/redeclaration4.go:8:7: foo redeclared in this block

_test/redeclaration5.go

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	type foo struct{
+		yolo string
+	}
+
+	type foo struct{}
+	var bar foo
+	println(bar)
+}
+
+// Error:
+// ../_test/redeclaration5.go:8:7: foo redeclared in this block

_test/select10.go

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	c := make(chan string)
+	select {
+	case <-c:
+		println("unexpected")
+	default:
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/select11.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	c := make(chan string)
+	select {
+	case <-c:
+		println("unexpected")
+	default:
+		println("nothing received")
+	}
+	println("bye")
+}
+
+// Output:
+// nothing received
+// bye

_test/select12.go

@@ -0,0 +1,23 @@
+package main
+
+type S struct {
+	q chan struct{}
+}
+
+func (s *S) Send() {
+	select {
+	case s.q <- struct{}{}:
+		println("sent")
+	default:
+		println("unexpected")
+	}
+}
+func main() {
+	s := &S{q: make(chan struct{}, 1)}
+	s.Send()
+	println("bye")
+}
+
+// Output:
+// sent
+// bye

_test/select13.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	var c interface{} = int64(1)
+	q := make(chan struct{})
+	select {
+	case q <- struct{}{}:
+		println("unexpected")
+	default:
+		_ = c.(int64)
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/selector-scope0.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func test(time string, t time.Time) string {
+	return time
+}
+
+func main() {
+	str := test("test", time.Now())
+	fmt.Println(str)
+}
+
+// Output:
+// test

_test/struct23.go

@@ -1,15 +1,23 @@
 package main
 
+import (
+	"encoding/json"
+	"os"
+)
+
 type S struct {
-	Child []*S
 	Name  string
+	Child []*S
 }
 
 func main() {
-	s := &S{Name: "root"}
-	s.Child = append(s.Child, &S{Name: "child"})
-	println(s.Child[0].Name)
+	a := S{Name: "hello"}
+	a.Child = append(a.Child, &S{Name: "world"})
+	json.NewEncoder(os.Stdout).Encode(a)
+	a.Child[0].Child = append([]*S{}, &S{Name: "sunshine"})
+	json.NewEncoder(os.Stdout).Encode(a)
 }
 
 // Output:
-// child
+// {"Name":"hello","Child":[{"Name":"world","Child":null}]}
+// {"Name":"hello","Child":[{"Name":"world","Child":[{"Name":"sunshine","Child":null}]}]}

_test/struct37.go

@@ -15,3 +15,6 @@ func main() {
 	_, err := c.Get("url")
 	println(strings.Contains(err.Error(), "unsupported protocol scheme"))
 }
+
+// Output:
+// true

_test/struct45.go

@@ -14,4 +14,5 @@ func main() {
 	println(t.b)
 }
 
-// Output: true
+// Output:
+// true

_test/struct46.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+type A struct {
+	B string
+	C D
+}
+
+type D struct {
+	E *A
+}
+
+func main() {
+	a := &A{B: "b"}
+	a.C = D{E: a}
+	fmt.Println(a.C.E.B)
+}
+
+// Output:
+// b

_test/struct47.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+type A struct {
+	B string
+	C D
+}
+
+func (a *A) Test() string {
+	return "test"
+}
+
+type D struct {
+	E *A
+}
+
+func main() {
+	a := &A{B: "b"}
+	d := D{E: a}
+	a.C = d
+	fmt.Println(a.C.E.Test())
+}
+
+// Output:
+// test