fix: correct handling of interface types in composite literals

Option "-e" allows to set the command to be executed:

```
echo '6001d5ff0000000003000000000107000000dcff' | \
	yaegi -e 'import "fmt"; import "os"; import "encoding/hex"; import "io/ioutil"; func main() { in, _ := ioutil.ReadAll(os.Stdin); decoded, _ := hex.DecodeString(string(in));fmt.Println(string(decoded)) }' 2>/dev/null | \
	hexdump -C
00000000  60 01 d5 ff 00 00 00 00  03 00 00 00 00 01 07 00  |`...............|
00000010  00 00 dc ff 0a                                    |.....|
00000015
```

.golangci.toml

@@ -37,6 +37,7 @@
     "funlen",
     "gocognit",
     "stylecheck",
+    "gomnd",
   ]
 
 [issues]

.travis.yml

@@ -19,8 +19,8 @@ cache:
 matrix:
   fast_finish: true
   include:
-    - go: 1.12.x
     - go: 1.13.x
+    - go: 1.14.x
       env: STABLE=true
 
 env:

README.md

@@ -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.12 and Go 1.13 (the latest 2 major releases)
+* Support Go 1.13 and Go 1.14 (the latest 2 major releases)
 
 ## Install
 

_test/a40.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+type rule uint8
+
+const (
+	r0 rule = iota
+	r1
+	r2
+)
+
+var a = [...]int{
+	r0: 1,
+	r1: 12,
+}
+
+func main() {
+	fmt.Println(a)
+}
+
+// Output:
+// [1 12]

_test/a41.go

@@ -0,0 +1,10 @@
+package main
+
+var a = [...]bool{true, true}
+
+func main() {
+	println(a[0] && true)
+}
+
+// Output:
+// true

_test/and3.go

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

_test/assign1.go

@@ -9,5 +9,5 @@ func main() {
 	fmt.Println(buf)
 }
 
-// Output
+// Output:
 // []

_test/bad0.go

@@ -1,4 +1,4 @@
 println("Hello")
 
 // Error:
-// _test/bad0.go:1:1: expected 'package', found println
+// 1:1: expected 'package', found println

_test/bin3.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	str := "part1"
+	str += fmt.Sprintf("%s", "part2")
+	fmt.Println(str)
+}
+
+// Output:
+// part1part2

_test/chan8.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	messages := make(chan bool)
+
+	go func() { messages <- true }()
+
+	println(<-messages && true)
+}
+
+// Output:
+// true

_test/chan9.go

@@ -0,0 +1,20 @@
+package main
+
+type Channel chan string
+
+type T struct {
+	Channel
+}
+
+func send(c Channel) { c <- "ping" }
+
+func main() {
+	t := &T{}
+	t.Channel = make(Channel)
+	go send(t.Channel)
+	msg := <-t.Channel
+	println(msg)
+}
+
+// Output:
+// ping

_test/cli2.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+)
+
+type T struct {
+	ln net.Listener
+}
+
+func (t *T) Close() {
+	t.ln.Close()
+}
+
+func client(uri string) {
+	resp, err := http.Get(uri)
+	if err != nil {
+		log.Fatal(err)
+	}
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(body))
+}
+
+func server(ln net.Listener, ready chan bool) {
+	http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
+		var r1 *http.Request = r
+		fmt.Fprintln(w, "Welcome to my website!", r1.RequestURI)
+	})
+
+	go http.Serve(ln, nil)
+	ready <- true
+}
+
+func main() {
+	ln, err := net.Listen("tcp", "localhost:0")
+	t := &T{ln}
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer t.Close()
+	//	defer ln.Close()
+
+	ready := make(chan bool)
+	go server(ln, ready)
+	<-ready
+
+	client(fmt.Sprintf("http://%s/hello", ln.Addr().String()))
+	http.DefaultServeMux = &http.ServeMux{}
+}
+
+// Output:
+// Welcome to my website! /hello

_test/complex3.go

@@ -7,5 +7,5 @@ func main() {
 	fmt.Printf("%T %v\n", s, s)
 }
 
-// Output
+// Output:
 // int 2

_test/composite5.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+type T struct {
+	m uint16
+}
+
+var t = T{1<<2 | 1<<3}
+
+func main() {
+	fmt.Println(t)
+}
+
+// Output:
+// {12}

_test/composite6.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/containous/yaegi/_test/ct1"
+)
+
+type T struct {
+	m uint16
+}
+
+var t = T{1 << ct1.R}
+
+func main() {
+	fmt.Println(t)
+}
+
+// Output:
+// {2}

_test/composite7.go

@@ -0,0 +1,20 @@
+package main
+
+type T struct {
+	name string
+}
+
+var tab = []*T{{
+	name: "foo",
+}, {
+	name: "bar",
+}}
+
+func main() {
+	println(len(tab))
+	println(tab[0].name)
+}
+
+// Output:
+// 2
+// foo

_test/composite8.go

@@ -0,0 +1,16 @@
+package main
+
+type T struct{ I int }
+
+func main() {
+	t := []*T{}
+	s := []int{1, 2}
+	for _, e := range s {
+		x := &T{e}
+		t = append(t, x)
+	}
+	println(t[0].I, t[1].I)
+}
+
+// Output:
+// 1 2

_test/const10.go

@@ -0,0 +1,17 @@
+package main
+
+const (
+	a = 2
+	b = c + d
+	c = a + d
+	d = e + f
+	e = 3
+	f = 4
+)
+
+func main() {
+	println(b)
+}
+
+// Output:
+// 16

_test/const6.go

@@ -0,0 +1,22 @@
+package main
+
+const (
+	maxNonStarters = 30
+	maxBufferSize  = maxNonStarters + 2
+)
+
+type reorderBuffer struct {
+	rune [maxBufferSize]Properties
+}
+
+type Properties struct {
+	pos  uint8
+	size uint8
+}
+
+func main() {
+	println(len(reorderBuffer{}.rune))
+}
+
+// Output:
+// 32

_test/const7.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+const (
+	a = iota
+	b
+	c
+	d
+)
+
+type T [c]int
+
+func main() {
+	fmt.Println(T{})
+}
+
+// Output:
+// [0 0]

_test/const8.go

@@ -0,0 +1,15 @@
+package main
+
+const (
+	a = 2
+	b = c + d
+	c = 4
+	d = 5
+)
+
+func main() {
+	println(a, b, c, d)
+}
+
+// Output:
+// 2 9 4 5

_test/const9.go

@@ -0,0 +1,17 @@
+package main
+
+const (
+	a = 2
+	b = c + d
+	c = a + d
+	d = e + f
+	e = b + 2
+	f = 4
+)
+
+func main() {
+	println(b)
+}
+
+// Error:
+// 5:2: constant definition loop

_test/ct1/ct1.go

@@ -0,0 +1,9 @@
+package ct1
+
+type Class uint
+
+const (
+	L Class = iota
+	R
+	AL
+)

_test/defer4.go

@@ -0,0 +1,23 @@
+package main
+
+import "sync"
+
+type T struct {
+	mu   sync.RWMutex
+	name string
+}
+
+func (t *T) get() string {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	return t.name
+}
+
+var d = T{name: "test"}
+
+func main() {
+	println(d.get())
+}
+
+// Output:
+// test

_test/for10.go

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	for a := 0; false; {
+		println("nok", a)
+		a++
+		break
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/for11.go

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	a := 0
+	for ; true; a++ {
+		println("nok", a)
+		break
+	}
+	println("bye", a)
+}
+
+// Output:
+// nok 0
+// bye 0

_test/for12.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	for a := 0; false; a++ {
+		println("nok", a)
+		break
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/for13.go

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	a := 0
+	for ; false; a++ {
+		println("nok", a)
+		break
+	}
+	println("bye", a)
+}
+
+// Output:
+// bye 0

_test/for14.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	for a := 0; true; a++ {
+		println(a)
+		if a > 0 {
+			break
+		}
+	}
+	println("bye")
+}
+
+// Output:
+// 0
+// 1
+// bye

_test/for9.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	for false {
+		println("nok")
+		break
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/if3.go

@@ -0,0 +1,17 @@
+package main
+
+func main() {
+	a := 0
+	if false {
+		println("false")
+		a = 1
+	} else {
+		println("true")
+		a = -1
+	}
+	println(a)
+}
+
+// Output:
+// true
+// -1

_test/if4.go

@@ -0,0 +1,19 @@
+package main
+
+const bad = false
+
+func main() {
+	a := 0
+	if bad {
+		println("false")
+		a = 1
+	} else {
+		println("true")
+		a = -1
+	}
+	println(a)
+}
+
+// Output:
+// true
+// -1

_test/if5.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	if true {
+		println("ok")
+	}
+	println("bye")
+}
+
+// Output:
+// ok
+// bye

_test/if6.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	if false {
+		println("nok")
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/if7.go

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

_test/interface20.go

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

_test/interface21.go

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

_test/interface22.go

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

_test/interface23.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := make(map[string]interface{})
+	m["A"] = string("A")
+	fmt.Println(m["A"])
+}
+
+// Output:
+// A

_test/interface24.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := make(map[string]interface{})
+	fmt.Println(m["B"])
+}
+
+// Output:
+// <nil>

_test/interface25.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := make(map[string]interface{})
+	m["A"] = 1
+	for _, v := range m {
+		fmt.Println(v)
+	}
+}
+
+// Output:
+// 1

_test/interface26.go

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

_test/interface27.go

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

_test/interface28.go

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

_test/interface29.go

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

_test/interface30.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	var a interface{}
+	println(a != nil)
+}
+
+// Output:
+// false

_test/interface31.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := []interface{}{"test", 2}
+	fmt.Println(s[0], s[1])
+}
+
+// Output:
+// test 2

_test/interface32.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := [2]interface{}{"test", 2}
+	fmt.Println(s[0], s[1])
+}
+
+// Output:
+// test 2

_test/interface33.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var a = map[string]interface{}{"test": "test"}
+	fmt.Println(a["test"])
+}
+
+// Output:
+// test

_test/interface34.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := [2]interface{}{1: "test", 0: 2}
+	fmt.Println(s[0], s[1])
+}
+
+// Output:
+// 2 test

_test/interface35.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+type T struct {
+	I interface{}
+}
+
+func main() {
+	t := T{"test"}
+	fmt.Println(t)
+}
+
+// Output:
+// {test}

_test/issue-558.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"strings"
+)
+
+type readAutoCloser struct {
+	r io.ReadCloser
+}
+
+func (a readAutoCloser) Read(b []byte) (n int, err error) {
+	if a.r == nil {
+		return 0, io.EOF
+	}
+	n, err = a.r.Read(b)
+	if err == io.EOF {
+		a.Close()
+	}
+	return n, err
+}
+
+func (a readAutoCloser) Close() error {
+	if a.r == nil {
+		return nil
+	}
+	return a.r.(io.Closer).Close()
+}
+
+type pipe struct {
+	Reader readAutoCloser
+}
+
+func newReadAutoCloser(r io.Reader) readAutoCloser {
+	if _, ok := r.(io.Closer); !ok {
+		return readAutoCloser{ioutil.NopCloser(r)}
+	}
+	return readAutoCloser{r.(io.ReadCloser)}
+}
+
+func main() {
+	p := &pipe{}
+	p.Reader = newReadAutoCloser(strings.NewReader("test"))
+	b, err := ioutil.ReadAll(p.Reader)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(string(b))
+}
+
+// Output:
+// test

_test/map19.go

@@ -14,3 +14,6 @@ func main() {
 	m := cmap{}
 	fmt.Println(m)
 }
+
+// Output:
+// {map[]}

_test/map20.go

@@ -0,0 +1,10 @@
+package main
+
+var a = map[int]bool{1: true, 2: true}
+
+func main() {
+	println(a[1] && true)
+}
+
+// Output:
+// true

_test/map21.go

@@ -0,0 +1,15 @@
+package main
+
+var m = map[int]string{
+	1: "foo",
+}
+
+func main() {
+	var ok bool
+	if _, ok = m[1]; ok {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/map22.go

@@ -0,0 +1,14 @@
+package main
+
+var m = map[int]string{
+	1: "foo",
+}
+
+func main() {
+	var s string
+	s, _ = m[1]
+	println(s)
+}
+
+// Output:
+// foo

_test/map23.go

@@ -0,0 +1,13 @@
+package main
+
+var m = map[int]string{
+	1: "foo",
+}
+
+func main() {
+	_, _ = m[1]
+	println("ok")
+}
+
+// Output:
+// ok

_test/method31.go

@@ -0,0 +1,29 @@
+package main
+
+import "fmt"
+
+var db dbWrapper
+
+type dbWrapper struct {
+	DB *cmap
+}
+
+func (d *dbWrapper) get() *cmap {
+	return d.DB
+}
+
+type cmap struct {
+	name string
+}
+
+func (c *cmap) f() {
+	fmt.Println("in f, c", c)
+}
+
+func main() {
+	db.DB = &cmap{name: "test"}
+	db.get().f()
+}
+
+// Output:
+// in f, c &{test}

_test/or2.go

@@ -0,0 +1,10 @@
+package main
+
+var a = false || true
+
+func main() {
+	println(a)
+}
+
+// Output:
+// true

_test/ptr8.go

@@ -0,0 +1,10 @@
+package main
+
+var a = func() *bool { b := true; return &b }()
+
+func main() {
+	println(*a && true)
+}
+
+// Output:
+// true

_test/select4.go

@@ -0,0 +1,17 @@
+package main
+
+func main() {
+	c1 := make(chan string)
+
+	go func() { c1 <- "done" }()
+
+	select {
+	case msg1 := <-c1:
+		println("received from c1:", msg1)
+	}
+	println("Bye")
+}
+
+// Output:
+// received from c1: done
+// Bye

_test/select5.go

@@ -0,0 +1,22 @@
+package main
+
+type T struct {
+	c1 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c1 = make(chan string)
+
+	go func(c chan string) { c <- "done" }(t.c1)
+
+	select {
+	case msg1 := <-t.c1:
+		println("received from c1:", msg1)
+	}
+	println("Bye")
+}
+
+// Output:
+// received from c1: done
+// Bye

_test/select6.go

@@ -0,0 +1,22 @@
+package main
+
+type T struct {
+	c1 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c1 = make(chan string)
+
+	go func(c chan string) { c <- "done" }(t.c1)
+
+	select {
+	case <-t.c1:
+		println("received from c1")
+	}
+	println("Bye")
+}
+
+// Output:
+// received from c1
+// Bye

_test/select7.go

@@ -0,0 +1,24 @@
+package main
+
+type T struct {
+	c1 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c1 = make(chan string)
+	a := 0
+
+	go func() {
+		select {
+		case t.c1 <- "done":
+			a++
+		}
+	}()
+
+	msg1 := <-t.c1
+	println("received from c1:", msg1)
+}
+
+// Output:
+// received from c1: done

_test/select8.go

@@ -0,0 +1,24 @@
+package main
+
+type T struct {
+	c1 chan string
+	c2 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c1 = make(chan string)
+
+	go func(c chan string) { c <- "done" }(t.c1)
+
+	select {
+	case msg := <-t.c1:
+		println("received from c1:", msg)
+	case <-t.c2:
+	}
+	println("Bye")
+}
+
+// Output:
+// received from c1: done
+// Bye

_test/select9.go

@@ -0,0 +1,22 @@
+package main
+
+type T struct {
+	c1 chan string
+}
+
+func main() {
+	t := &T{}
+	t.c1 = make(chan string)
+
+	go func() {
+		select {
+		case t.c1 <- "done":
+		}
+	}()
+
+	msg1 := <-t.c1
+	println("received from c1:", msg1)
+}
+
+// Output:
+// received from c1: done

_test/struct31.go

@@ -0,0 +1,14 @@
+package main
+
+type T struct {
+	bool
+}
+
+var t = T{true}
+
+func main() {
+	println(t.bool && true)
+}
+
+// Output:
+// true

_test/struct32.go

@@ -0,0 +1,39 @@
+package main
+
+type T0 struct {
+	name string
+}
+
+type lookupFunc func(s string) T0
+
+type T1 struct {
+	name string
+	info lookupFunc
+}
+
+func (t T0) F1() bool { println("in F1"); return true }
+
+type T2 struct {
+	t1 T1
+}
+
+func (t2 *T2) f() {
+	info := t2.t1.info("foo")
+	println(info.F1())
+}
+
+var t0 = T0{"t0"}
+
+func main() {
+	t := &T2{T1{
+		"bar", func(s string) T0 { return t0 },
+	}}
+
+	println("hello")
+	println(t.t1.info("foo").F1())
+}
+
+// Output:
+// hello
+// in F1
+// true

_test/struct33.go

@@ -0,0 +1,34 @@
+package main
+
+type T0 struct {
+	name string
+}
+
+type lookupFunc func(s string) T0
+
+type T1 struct {
+	name string
+	info lookupFunc
+}
+
+func (t T0) F1() bool { println("in F1"); return true }
+
+var t0 = T0{"t0"}
+
+func look(s string) T0 { println("in look"); return t0 }
+
+var table = []*T1{{
+	name: "bar",
+	info: look,
+},
+}
+
+func main() {
+	info := table[0].info
+	println(info("foo").F1())
+}
+
+// Output:
+// in look
+// in F1
+// true

_test/struct34.go

@@ -0,0 +1,16 @@
+package main
+
+type T struct {
+	f func(*T)
+}
+
+func f1(t *T) { t.f = f2 }
+
+func f2(t *T) { t.f = f1 }
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct35.go

@@ -0,0 +1,16 @@
+package main
+
+type T struct {
+	f func(*T)
+}
+
+func f1(t *T) { t.f = f1 }
+
+func main() {
+	t := &T{}
+	f1(t)
+	println(t.f != nil)
+}
+
+// Output:
+// true

_test/struct36.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"net/http"
+	"strings"
+)
+
+type S struct {
+	http.Client
+}
+
+func main() {
+	var s S
+	if _, err := s.Get("url"); err != nil {
+		println(strings.Contains(err.Error(), "unsupported protocol scheme"))
+	}
+	return
+}
+
+// Output:
+// true

_test/struct37.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"net/http"
+	"strings"
+)
+
+type MyHttpClient struct {
+	*http.Client
+}
+
+func main() {
+	c := new(MyHttpClient)
+	c.Client = new(http.Client)
+	_, err := c.Get("url")
+	println(strings.Contains(err.Error(), "unsupported protocol scheme"))
+}

_test/struct38.go

@@ -0,0 +1,24 @@
+package main
+
+type T struct {
+	f func(t *T1)
+	y *xxx
+}
+
+type T1 struct {
+	T
+}
+
+type xxx struct{}
+
+var (
+	x1 *T1 = x
+	x      = &T1{}
+)
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct39.go

@@ -0,0 +1,22 @@
+package main
+
+type T struct {
+	t *T1
+	y *xxx
+}
+
+type T1 struct {
+	T
+}
+
+var x = &T1{}
+var t = &T{}
+
+type xxx struct{}
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct40.go

@@ -0,0 +1,23 @@
+package main
+
+type T struct {
+	t *T1
+	y *xxx
+}
+
+type T1 struct {
+	T
+}
+
+func f(t *T) { println("in f") }
+
+var x = &T1{}
+
+type xxx struct{}
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct41.go

@@ -0,0 +1,26 @@
+package main
+
+type Ti func(*T)
+
+type T1 struct {
+	t Ti
+}
+
+type T struct {
+	t Ti
+	y *xxx
+}
+
+func f(t *T) { println("in f") }
+
+type xxx struct{}
+
+var x = &T1{t: f}
+
+func main() {
+	x.t = f
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct42.go

@@ -0,0 +1,19 @@
+package main
+
+type T struct {
+	t func(*T)
+	y *xxx
+}
+
+func f(t *T) { println("in f") }
+
+var x = &T{t: f}
+
+type xxx struct{}
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct43.go

@@ -0,0 +1,19 @@
+package main
+
+type T struct {
+	t func(*T)
+	y *xxx
+}
+
+func f(t *T) { println("in f") }
+
+type xxx struct{}
+
+func main() {
+	x := &T{}
+	x.t = f
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct44.go

@@ -0,0 +1,27 @@
+package main
+
+type Ti func(*T) X
+
+type T1 struct {
+	t Ti
+}
+
+type T struct {
+	t Ti
+	y *xxx
+}
+
+func f(t *T) X { println("in f"); return X{} }
+
+type X struct{ Name string }
+
+type xxx struct{}
+
+var x = &T1{t: f}
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/struct45.go

@@ -0,0 +1,17 @@
+package main
+
+type T struct {
+	b bool
+}
+
+type T1 struct {
+	T
+}
+
+func main() {
+	t := &T1{}
+	t.b = true
+	println(t.b)
+}
+
+// Output: true

_test/switch23.go

@@ -0,0 +1,15 @@
+package main
+
+func getType() string { return "T1" }
+
+func main() {
+	switch getType() {
+	case "T1":
+		println("T1")
+	default:
+		println("default")
+	}
+}
+
+// Output:
+// T1

_test/switch24.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	a := 3
+	switch a + 2 {
+	case 5:
+		println(5)
+	default:
+		println("default")
+	}
+	println("bye")
+}
+
+// Output:
+// 5
+// bye

_test/switch25.go

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	a := 2
+	switch {
+	case a == 1:
+		println(1)
+	case a == 2:
+		println(2)
+	default:
+		println("default")
+	}
+	println("bye")
+}
+
+// Output:
+// 2
+// bye

_test/switch26.go

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	a := 1
+	switch a := 2; {
+	case a == 1:
+		println(1)
+	case a == 2:
+		println(2)
+	default:
+		println("default")
+	}
+	println(a)
+}
+
+// Output:
+// 2
+// 1

_test/switch27.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	//a := false
+	switch false {
+	case true:
+		println("true")
+	case false:
+		println("false")
+	}
+	println("bye")
+}
+
+// Output:
+// false
+// bye

_test/switch28.go

@@ -0,0 +1,15 @@
+package main
+
+func main() {
+	switch {
+	case true:
+		println("true")
+	case false:
+		println("false")
+	}
+	println("bye")
+}
+
+// Output:
+// true
+// bye

_test/switch29.go

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	a := 3
+	switch a {
+	case 3:
+		println("three")
+	}
+	println("bye")
+}
+
+// Output:
+// three
+// bye

_test/switch30.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	a := 3
+	switch a {
+	default:
+		//println("default")
+	case 3:
+		println("three")
+	}
+	println("bye")
+}
+
+// Output:
+// three
+// bye

_test/switch31.go

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	switch {
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/switch32.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	a := 1
+	switch a {
+	}
+	println("bye", a)
+}
+
+// Output:
+// bye 1

_test/switch33.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var a interface{}
+	switch a.(type) {
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/type15.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	err := error(nil)
+	println(err == nil)
+}
+
+// Output:
+// true

_test/type16.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := uint8(15) ^ byte(0)
+	fmt.Printf("%T %v\n", a, a)
+}
+
+// Output:
+// uint8 15

_test/type17.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := int32(15) ^ rune(0)
+	fmt.Printf("%T %v\n", a, a)
+}
+
+// Output:
+// int32 15

_test/type18.go

@@ -0,0 +1,20 @@
+package main
+
+type T struct {
+	name string
+	size int
+}
+
+var table = []*T{{
+	name: "foo",
+	size: 2,
+}}
+
+var s = table[0].size
+
+func main() {
+	println(s)
+}
+
+// Output:
+// 2

_test/type19.go

@@ -0,0 +1,21 @@
+package main
+
+type T struct {
+	name string
+	size int
+}
+
+var table = map[int]*T{
+	0: {
+		name: "foo",
+		size: 2,
+	}}
+
+var s = table[0].size
+
+func main() {
+	println(s)
+}
+
+// Output:
+// 2

_test/type20.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"io"
+	"strings"
+)
+
+func isCloser(r io.Reader) bool {
+	_, ok := r.(io.Closer)
+	return ok
+}
+
+func main() {
+	println(isCloser(strings.NewReader("test")))
+}
+
+// Output:
+// false

cmd/yaegi/yaegi.go

@@ -47,8 +47,10 @@ import (
 func main() {
 	var interactive bool
 	var tags string
+	var cmd string
 	flag.BoolVar(&interactive, "i", false, "start an interactive REPL")
 	flag.StringVar(&tags, "tags", "", "set a list of build tags")
+	flag.StringVar(&cmd, "e", "", "set the command to be executed (instead of script or/and shell)")
 	flag.Usage = func() {
 		fmt.Println("Usage:", os.Args[0], "[options] [script] [args]")
 		fmt.Println("Options:")
@@ -62,31 +64,41 @@ func main() {
 	i.Use(stdlib.Symbols)
 	i.Use(interp.Symbols)
 
-	if len(args) > 0 {
-		// Skip first os arg to set command line as expected by interpreted main
-		os.Args = os.Args[1:]
-		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+	if cmd != `` {
+		i.REPL(strings.NewReader(cmd), os.Stderr)
+	}
 
-		b, err := ioutil.ReadFile(args[0])
-		if err != nil {
-			log.Fatal("Could not read file: ", args[0])
-		}
-
-		s := string(b)
-		if s[:2] == "#!" {
-			// Allow executable go scripts, but fix them prior to parse
-			s = strings.Replace(s, "#!", "//", 1)
-		}
-
-		i.Name = args[0]
-		if _, err := i.Eval(s); err != nil {
-			fmt.Println(err)
-		}
-
-		if interactive {
+	if len(args) == 0 {
+		if interactive || cmd == `` {
 			i.REPL(os.Stdin, os.Stdout)
 		}
-	} else {
+		return
+	}
+
+	// Skip first os arg to set command line as expected by interpreted main
+	os.Args = os.Args[1:]
+	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+
+	b, err := ioutil.ReadFile(args[0])
+	if err != nil {
+		log.Fatal("Could not read file: ", args[0])
+	}
+
+	s := string(b)
+	if s[:2] == "#!" {
+		// Allow executable go scripts, but fix them prior to parse
+		s = strings.Replace(s, "#!", "//", 1)
+	}
+
+	i.Name = args[0]
+	if _, err := i.Eval(s); err != nil {
+		fmt.Println(err)
+		if p, ok := err.(interp.Panic); ok {
+			fmt.Println(string(p.Stack))
+		}
+	}
+
+	if interactive {
 		i.REPL(os.Stdin, os.Stdout)
 	}
 }

interp/ast.go

@@ -75,8 +75,6 @@ const (
 	parenExpr
 	rangeStmt
 	returnStmt
-	rvalueExpr
-	rtypeExpr
 	selectStmt
 	selectorExpr
 	selectorImport
@@ -154,8 +152,6 @@ var kinds = [...]string{
 	parenExpr:        "parenExpr",
 	rangeStmt:        "rangeStmt",
 	returnStmt:       "returnStmt",
-	rvalueExpr:       "rvalueExpr",
-	rtypeExpr:        "rtypeExpr",
 	selectStmt:       "selectStmt",
 	selectorExpr:     "selectorExpr",
 	selectorImport:   "selectorImport",
@@ -204,7 +200,6 @@ const (
 	aCase
 	aCompositeLit
 	aDec
-	aDefer
 	aEqual
 	aGreater
 	aGreaterEqual
@@ -262,7 +257,6 @@ var actions = [...]string{
 	aCase:         "case",
 	aCompositeLit: "compositeLit",
 	aDec:          "--",
-	aDefer:        "defer",
 	aEqual:        "==",
 	aGreater:      ">",
 	aGetFunc:      "getFunc",
@@ -573,7 +567,7 @@ func (interp *Interpreter) ast(src, name string) (string, *node, error) {
 			st.push(addChild(&root, anc, pos, declStmt, aNop), nod)
 
 		case *ast.DeferStmt:
-			st.push(addChild(&root, anc, pos, deferStmt, aDefer), nod)
+			st.push(addChild(&root, anc, pos, deferStmt, aNop), nod)
 
 		case *ast.Ellipsis:
 			st.push(addChild(&root, anc, pos, ellipsisExpr, aNop), nod)