fix: assign an element in a map from runtime

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/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/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/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/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/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/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/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/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/fun12.go

@@ -0,0 +1,12 @@
+package main
+
+func use(interface{}) {}
+
+func main() {
+	z := map[string]interface{}{"a": 5}
+	use(z)
+	println("bye")
+}
+
+// Output:
+// bye

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

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+func main() {
+	jb := []byte(`{"property": "test"}`)
+	params := map[string]interface{}{"foo": 1}
+	if err := json.Unmarshal(jb, &params); err != nil {
+		panic("marshal failed.")
+	}
+	fmt.Println(params["foo"], params["property"])
+}
+
+// Output:
+// 1 test

_test/map25.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"encoding/json"
+	"strconv"
+)
+
+func main() {
+	jb := []byte(`{"num": "2"}`)
+	params := map[string]interface{}{"foo": "1"}
+	if err := json.Unmarshal(jb, &params); err != nil {
+		panic(err)
+	}
+	sum := 0
+	for _, v := range params {
+		i, err := strconv.Atoi(v.(string))
+		if err != nil {
+			panic(err)
+		}
+		sum += i
+	}
+	println(sum)
+}
+
+// Output:
+// 3

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

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

_test/not1.go

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

_test/not2.go

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

_test/num0.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Printf("%g\n", 1.0)
+}
+
+// Output:
+// 1

_test/op4.go

@@ -1,9 +1,9 @@
 package main
 
 func main() {
-	i := 100
-	println(i % 1e2)
+	i := 102
+	println(i % -1e2)
 }
 
 // Output:
-// 0
+// 2

_test/op5.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	i := 100
+	j := i % 1e2
+	fmt.Printf("%T %v\n", j, j)
+}
+
+// Output:
+// int 0

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

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

_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,18 @@
+package main
+
+type T struct {
+	b bool
+}
+
+type T1 struct {
+	T
+}
+
+func main() {
+	t := &T1{}
+	t.b = true
+	println(t.b)
+}
+
+// Output:
+// true

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

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	var a interface{}
+	switch a.(type) {
+	case []int:
+	case []string:
+	}
+	println("bye")
+}
+
+// Output:
+// bye

_test/time12.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+var twentyFourHours = time.Duration(24 * time.Hour)
+
+func main() {
+	fmt.Println(twentyFourHours.Hours())
+}
+
+// Output:
+// 24

_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

_test/type21.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"reflect"
+	"time"
+)
+
+func main() {
+	t := time.Date(2009, time.November, 10, 23, 4, 5, 0, time.UTC)
+	v := reflect.ValueOf(t.String)
+	f := v.Interface().(func() string)
+	println(f())
+}
+
+// Output:
+// 2009-11-10 23:04:05 +0000 UTC

_test/type22.go

@@ -0,0 +1,18 @@
+package main
+
+type T1 T
+
+func foo() T1 {
+	return T1(T{"foo"})
+}
+
+type T struct {
+	Name string
+}
+
+func main() {
+	println(foo().Name)
+}
+
+// Output:
+// foo

_test/variadic6.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type A struct {
+}
+
+func (a A) f(vals ...bool) {
+	for _, v := range vals {
+		fmt.Println(v)
+	}
+}
+func main() {
+	bools := []bool{true}
+	a := A{}
+	a.f(bools...)
+}
+
+// Output:
+// true

cmd/yaegi/yaegi.go

@@ -1,22 +1,66 @@
 /*
 Yaegi interprets Go programs.
 
-Yaegi reads Go language programs from its standard input or from a file
-and evaluates them.
+Yaegi reads Go language programs from standard input, string
+parameters or files and run them.
 
-If invoked with no arguments, it processes the standard input
-in a Read-Eval-Print-Loop. A prompt is displayed if standard input
-is a terminal.
+If invoked with no arguments, it processes the standard input in
+a Read-Eval-Print-Loop. A prompt is displayed if standard input is
+a terminal.
 
-Given a file, it operates on that file. If the first line starts with
-"#!/usr/bin/env yaegi", and the file has exec permission, then the file
-can be invoked directly from the shell.
+File Mode
 
-In file mode, as in standard Go, files are read entirely, then parsed,
-then evaluated. In REPL mode, each line is parsed and evaluated separately,
-at global level in an implicit main package.
+In file mode, as in a standard Go compiler, source files are read entirely
+before being parsed, then evaluated. It allows to handle forward
+declarations and to have package code split in multiple source files.
+
+Go specifications fully apply in this mode.
+
+All files are interpreted in file mode except the initial file if it
+starts with "#!" characters (the shebang pattern to allow executable
+scripts), for example "#!/usr/bin/env yaegi". In that case, the initial
+file is interpreted in REPL mode.
+
+REPL mode
+
+In REPL mode, the interpreter parses the code incrementally. As soon
+as a statement is complete, it evaluates it. This makes the interpreter
+suitable for interactive command line and scripts.
+
+Go specifications apply with the following differences:
+
+All local and global declarations (const, var, type, func) are allowed,
+including in short form, except that all identifiers must be defined
+before use (as declarations inside a standard Go function).
+
+The statements are evaluated in the global space, within an implicit
+"main" package.
+
+It is not necessary to have a package statement, or a main function in
+REPL mode. Import statements for preloaded binary packages can also
+be avoided (i.e. all the standard library except the few packages
+where default names collide, as "math/rand" and "crypto/rand", for which
+an explicit import is still necessary).
+
+Note that the source packages are always interpreted in file mode,
+even if imported from REPL.
+
+The following extract is a valid executable script:
+
+	#!/usr/bin/env yaegi
+	helloHandler := func(w http.ResponseWriter, req *http.Request) {
+	   io.WriteString(w, "Hello, world!\n")
+	}
+	http.HandleFunc("/hello", helloHandler)
+	log.Fatal(http.ListenAndServe(":8080", nil))
+
+Example of a one liner:
+
+	$ yaegi -e 'println(reflect.TypeOf(fmt.Print))'
 
 Options:
+	-e string
+	   evaluate the string and return.
     -i
 	   start an interactive REPL after file execution.
 	-tags tag,list
@@ -86,15 +130,18 @@ func main() {
 
 	s := string(b)
 	if s[:2] == "#!" {
-		// Allow executable go scripts, but fix them prior to parse
+		// Allow executable go scripts, Have the same behavior as in interactive mode.
 		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))
+		i.REPL(strings.NewReader(s), os.Stdout)
+	} else {
+		// Files not starting with "#!" are supposed to be pure Go, directly Evaled.
+		i.Name = args[0]
+		_, err := i.Eval(s)
+		if err != nil {
+			fmt.Println(err)
+			if p, ok := err.(interp.Panic); ok {
+				fmt.Println(string(p.Stack))
+			}
 		}
 	}
 

cmd/yaegi/yaegi_test.go

@@ -84,7 +84,7 @@ func TestYaegiCmdCancel(t *testing.T) {
 			continue
 		}
 
-		if outBuf.String() != "context canceled\n2\n" {
+		if outBuf.String() != "context canceled\n" {
 			t.Errorf("unexpected output: %q", &outBuf)
 		}
 	}

internal/genop/genop.go

@@ -17,9 +17,9 @@ import "reflect"
 // Arithmetic operators
 {{range $name, $op := .Arithmetic}}
 func {{$name}}(n *node) {
-	dest := genValue(n)
 	next := getExec(n.tnext)
-	typ := n.typ.TypeOf()
+	typ := n.typ.concrete().TypeOf()
+	dest := genValueOutput(n, typ)
 	c0, c1 := n.child[0], n.child[1]
 
 	switch typ.Kind() {
@@ -379,7 +379,7 @@ func {{$name}}Const(n *node) {
 {{range $name, $op := .Comparison}}
 func {{$name}}(n *node) {
 	tnext := getExec(n.tnext)
-	dest := genValue(n)
+	dest := genValueOutput(n, reflect.TypeOf(true))
 	c0, c1 := n.child[0], n.child[1]
 
 	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {

interp/ast.go

@@ -6,7 +6,6 @@ import (
 	"go/parser"
 	"go/scanner"
 	"go/token"
-	"math"
 	"reflect"
 	"strconv"
 	"sync/atomic"
@@ -196,15 +195,18 @@ const (
 	aAndNot
 	aAndNotAssign
 	aBitNot
+	aBranch
 	aCall
 	aCase
 	aCompositeLit
+	aConvert
 	aDec
 	aEqual
 	aGreater
 	aGreaterEqual
 	aGetFunc
 	aGetIndex
+	aGetSym
 	aInc
 	aLand
 	aLor
@@ -253,14 +255,17 @@ var actions = [...]string{
 	aAndNot:       "&^",
 	aAndNotAssign: "&^=",
 	aBitNot:       "^",
+	aBranch:       "branch",
 	aCall:         "call",
 	aCase:         "case",
 	aCompositeLit: "compositeLit",
+	aConvert:      "convert",
 	aDec:          "--",
 	aEqual:        "==",
 	aGreater:      ">",
 	aGetFunc:      "getFunc",
 	aGetIndex:     "getIndex",
+	aGetSym:       ".",
 	aInc:          "++",
 	aLand:         "&&",
 	aLor:          "||",
@@ -464,11 +469,7 @@ func (interp *Interpreter) ast(src, name string) (string, *node, error) {
 				n.rval = reflect.ValueOf(v)
 			case token.FLOAT:
 				v, _ := strconv.ParseFloat(a.Value, 64)
-				if math.Trunc(v) == v {
-					n.rval = reflect.ValueOf(int(v))
-				} else {
-					n.rval = reflect.ValueOf(v)
-				}
+				n.rval = reflect.ValueOf(v)
 			case token.IMAG:
 				v, _ := strconv.ParseFloat(a.Value[:len(a.Value)-1], 64)
 				n.rval = reflect.ValueOf(complex(0, v))