fix: correct branch action in parenthesis expression

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
```

.github/ISSUE_TEMPLATE/bug_report.md

@@ -17,11 +17,11 @@ func main() {
 Expected result:
 ```console
 $ go run ./sample.go
-// ouput
+// output
 ```
 
 Got:
 ```console
 $ yaegi ./sample.go
-// ouput
+// output
 ```

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+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? -->

.gitignore

@@ -6,3 +6,4 @@
 cmd/goexports/goexports
 example/inception/inception
 _test/tmp/
+/dist

.golangci.toml

@@ -5,7 +5,7 @@
 [linters-settings]
 
   [linters-settings.govet]
-    check-shadowing = true
+    check-shadowing = false
 
   [linters-settings.gocyclo]
     min-complexity = 12.0
@@ -32,6 +32,12 @@
     "gocyclo",
     "gochecknoinits",
     "gochecknoglobals",
+    "wsl",
+    "godox",
+    "funlen",
+    "gocognit",
+    "stylecheck",
+    "gomnd",
   ]
 
 [issues]
@@ -41,10 +47,12 @@
   exclude = []
 
   [[issues.exclude-rules]]
-    path = "cmd/goexports/goexports.go"
-    text = "SA1019: importer.For is deprecated: use ForCompiler, which populates a FileSet with the positions of objects created by the importer."
+    path = "interp/.+_test\\.go"
+    linters = ["goconst"]
 
-  # structcheck false-positive
   [[issues.exclude-rules]]
     path = "interp/interp.go"
-    text = "`(astDot|cfgDot|noRun)` is unused"
+    text = "`in` can be `io.Reader`"
+  [[issues.exclude-rules]]
+    path = "interp/interp.go"
+    text = "`out` can be `io.Writer`"

.goreleaser.yml

@@ -1,7 +1,8 @@
 project_name: yaegi
 
 builds:
-  - binary: yaegi
+  - id: yaegi
+    binary: yaegi
     main: ./cmd/yaegi/yaegi.go
 
     goos:
@@ -25,6 +26,31 @@ builds:
       - goos: darwin
         goarch: 386
 
+  - id: goexports
+    binary: goexports
+    main: ./cmd/goexports/goexports.go
+
+    goos:
+      - darwin
+      - linux
+#      - windows
+      - freebsd
+      - openbsd
+      - solaris
+    goarch:
+      - amd64
+      - 386
+      - arm
+      - arm64
+    goarm:
+      - 7
+      - 6
+      - 5
+
+    ignore:
+      - goos: darwin
+        goarch: 386
+
 changelog:
   sort: asc
   filters:
@@ -35,11 +61,12 @@ changelog:
       - '^test:'
       - '^tests:'
 
-archive:
-  name_template: '{{ .ProjectName }}_v{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
-  format: tar.gz
-  format_overrides:
-    - goos: windows
-      format: zip
-  files:
-    - LICENSE
+archives:
+  - id: archive
+    name_template: '{{ .ProjectName }}_v{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
+    format: tar.gz
+    format_overrides:
+      - goos: windows
+        format: zip
+    files:
+      - LICENSE

.travis.yml

@@ -2,23 +2,36 @@ language: go
 
 dist: xenial
 
-env:
-  - GO111MODULE=on
+branches:
+  only:
+    - master
+    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
 
 notifications:
   email:
     on_success: never
     on_failure: change
 
-go:
-  - 1.11.x
-  - 1.12.x
+cache:
+  directories:
+    - $GOPATH/pkg/mod
+
+matrix:
+  fast_finish: true
+  include:
+    - go: 1.13.x
+    - go: 1.14.x
+      env: STABLE=true
+
+env:
+  global:
+    - GO111MODULE=on
 
 go_import_path: github.com/containous/yaegi
 
 before_install:
   # Install linters and misspell
-  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s -- -b $GOPATH/bin v1.16.0
+  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | bash -s -- -b $GOPATH/bin ${GOLANGCI_LINT_VERSION}
   - golangci-lint --version
 
 install:
@@ -36,7 +49,7 @@ before_script:
 script:
   - make check
   - go build -v ./...
-  - GO111MODULE=off go test -v ./...
+  - make tests
 
 deploy:
   - provider: script
@@ -44,4 +57,4 @@ deploy:
     script: curl -sL https://git.io/goreleaser | bash
     on:
       tags: true
-      condition: $TRAVIS_GO_VERSION =~ ^1\.12\.x$
+      condition: $STABLE = true

CONTRIBUTING.md

@@ -0,0 +1,24 @@
+# Contributing
+
+Yaegi is an open source project, and your feedback and contributions
+are needed and always welcome.
+
+[Issues] and [Pull Requests] are opened at https://github.com/containous/yaegi.
+
+Non trivial changes should be discussed with the project maintainers by
+opening a [Feature Request] clearly explaining rationale, background
+and possible implementation ideas. Feel free to provide code in such
+discussions.
+
+Once the proposal is approved, a Pull Request can be opened. If you want
+to provide early visibility to reviewers, create a [Draft Pull Request].
+
+We will also require you to sign the [Containous Contributor License Agreement]
+after you submit your first pull request to this project. The link to sign the
+agreement will be presented to you in the web interface of the pull request.
+
+[Issues]: https://github.com/containous/yaegi/issues
+[Pull Requests]: https://github.com/containous/yaegi/issues
+[Feature Request]: https://github.com/containous/yaegi/issues/new?template=feature_request.md
+[Draft Pull Request]: https://github.blog/2019-02-14-introducing-draft-pull-requests/
+[Containous Contributor License Agreement]: https://cla-assistant.io/containous/yaegi

Makefile

@@ -16,4 +16,8 @@ cmd/goexports/goexports: cmd/goexports/goexports.go
 generate: gen_all_syscall
 	go generate
 
+tests:
+	GO111MODULE=off go test -v ./...
+	GO111MODULE=off go test -race ./interp
+
 .PHONY: check gen_all_syscall gen_tests

README.md

@@ -4,6 +4,8 @@
 
 [![release](https://img.shields.io/github/tag-date/containous/yaegi.svg?label=alpha)](https://github.com/containous/yaegi/releases)
 [![Build Status](https://travis-ci.com/containous/yaegi.svg?branch=master)](https://travis-ci.com/containous/yaegi)
+[![GoDoc](https://godoc.org/github.com/containous/yaegi?status.svg)](https://godoc.org/github.com/containous/yaegi)
+[![Discourse status](https://img.shields.io/discourse/https/community.containo.us/status?label=Community&style=social)](https://community.containo.us/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.
@@ -11,49 +13,32 @@ It powers executable Go scripts and plugins, in embedded interpreters or interac
 ## Features
 
 * Complete support of [Go specification][specs]
-* In pure Go, using only standard library
+* Written in pure Go, using only the standard library
 * Simple interpreter API: `New()`, `Eval()`, `Use()`
-* works everywhere Go works
+* Works everywhere Go works
 * All Go & runtime resources accessible from script (with control)
-* Security: `unsafe` and `syscall` packages not used or exported by default
+* Security: `unsafe` and `syscall` packages neither used nor exported by default
+* Support Go 1.13 and Go 1.14 (the latest 2 major releases)
 
 ## Install
 
-### As library
+### Go package
 
 ```go
 import "github.com/containous/yaegi/interp"
 ```
 
-### REPL
+### Command-line executable
 
 ```bash
-go get -u github.com/containous/yaegi/cmd
+go get -u github.com/containous/yaegi/cmd/yaegi
 ```
 
+Note that you can use [rlwrap](https://github.com/hanslub42/rlwrap) (install with your favorite package manager),
+and alias the `yaegi` command in `alias yaegi='rlwrap yaegi'` in your `~/.bashrc`, to have history and command line edition.
+
 ## Usage
 
-### As a command line interpreter
-
-The Yaegi command can run an interactive Read-Eval-Print-Loop:
-
-```console
-$ yaegi
-> 1 + 2
-3
-> import "fmt"
-> fmt.Println("Hello World")
-Hello World
->
-```
-
-Or interpret Go files:
-
-```console
-$ yaegi cmd/yaegi/yaegi.go
->
-```
-
 ### As an embedded interpreter
 
 Create an interpreter with `New()`, run Go code with `Eval()`:
@@ -76,13 +61,15 @@ func main() {
 		panic(err)
 	}
 
-	_, err = i.Eval(`fmt.Println("hello")`)
+	_, err = i.Eval(`fmt.Println("Hello Yaegi")`)
 	if err != nil {
 		panic(err)
 	}
 }
 ```
 
+[Go Playground](https://play.golang.org/p/zzvw4VlerLP)
+
 ### As a dynamic extension framework
 
 The following program is compiled ahead of time, except `bar()` which is interpreted, with the following steps:
@@ -119,15 +106,64 @@ func main() {
 }
 ```
 
+[Go Playground](https://play.golang.org/p/6SEAoaO7n0U)
+
+### As a command-line interpreter
+
+The Yaegi command can run an interactive Read-Eval-Print-Loop:
+
+```console
+$ yaegi
+> 1 + 2
+3
+> import "fmt"
+> fmt.Println("Hello World")
+Hello World
+>
+```
+
+Or interpret Go files:
+
+```console
+$ yaegi cmd/yaegi/yaegi.go
+>
+```
+
+Or for Go scripting in the shebang line:
+
+```console
+$ cat /tmp/test
+#!/usr/bin/env yaegi
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("test")
+}
+$ ls -la /tmp/test
+-rwxr-xr-x 1 dow184 dow184 93 Jan  6 13:38 /tmp/test
+$ /tmp/test
+test
+```
+
 ## Documentation
 
 Documentation about Yaegi commands and libraries can be found at usual [godoc.org][docs].
 
+## Limitations
+
+Beside the known [bugs] which are supposed to be fixed in the short term, there are some limitations not planned to be addressed soon:
+
+- assembly files (`.s`) are not supported
+- calling C code is not supported (no virtual "C" package)
+- interfaces to be used from the pre-compiled code can not be added dynamically, as it is required to pre-compile interface wrappers
+- representation of types by `reflect` and printing values using %T may give different results between compiled mode and interpreted mode
+- interpreting computation intensive code is likely to remain significantly slower than in compiled mode
+
 ## Contributing
 
-Yaegi is an open source project, and your feedback and contributions are needed and always welcome.
-
-[Issues] and [pull requests] are opened at https://github.com/containous/yaegi
+[Contributing guide](CONTRIBUTING.md).
 
 ## License
 
@@ -137,5 +173,4 @@ Yaegi is an open source project, and your feedback and contributions are needed
 [docs]: https://godoc.org/github.com/containous/yaegi
 [license]: https://github.com/containous/yaegi/blob/master/LICENSE
 [github]: https://github.com/containous/yaegi
-[Issues]: https://github.com/containous/yaegi/issues
-[pull requests]: https://github.com/containous/yaegi/issues
+[bugs]: https://github.com/containous/yaegi/issues?q=is%3Aissue+is%3Aopen+label%3Abug

_test/a30.go

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	for range []struct{}{} {
+	}
+	println("ok")
+}
+
+// Output:
+// ok

_test/a31.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	for range []int{0, 1, 2} {
+		print("hello ")
+	}
+	println("")
+}
+
+// Output:
+// hello hello hello

_test/a32.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+type T struct{}
+
+var a = []T{{}}
+
+func main() {
+	fmt.Println(a)
+}
+
+// Output:
+// [{}]

_test/a33.go

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

_test/a34.go

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

_test/a35.go

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

_test/a36.go

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

_test/a37.go

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

_test/a38.go

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

_test/a39.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	a := [...]byte{}
+	b := a
+	fmt.Printf("%T %T\n", a, b)
+}
+
+// Output:
+// [0]uint8 [0]uint8

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

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+type MyT T
+
+type T struct {
+	Name string
+}
+
+func main() {
+	fmt.Println(MyT{})
+}
+
+// Output:
+// {}

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

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

_test/assign8.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	_ = 1
+	println(1)
+}
+
+// Output:
+// 1

_test/assign9.go

@@ -0,0 +1,15 @@
+package main
+
+type foo func(b int)
+
+func boo(b int) { println("boo", b) }
+
+func main() {
+	var f foo
+
+	f = boo
+	f(4)
+}
+
+// Output:
+// boo 4

_test/b1/foo/foo.go

@@ -0,0 +1,7 @@
+package foo
+
+import bar "github.com/containous/yaegi/_test/b2/foo"
+
+var Desc = "in b1/foo"
+
+var Desc2 = Desc + bar.Desc

_test/b2/foo/foo.go

@@ -0,0 +1,3 @@
+package foo
+
+var Desc = "in b2/foo"

_test/bad0.go

@@ -0,0 +1,4 @@
+println("Hello")
+
+// Error:
+// 1:1: expected 'package', found println

_test/bin2.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	fmt.Println(math.Abs(-5))
+}
+
+// Output:
+// 5

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

@@ -0,0 +1,5 @@
+package c1
+
+import "github.com/containous/yaegi/_test/c2"
+
+var C1 = c2.C2 + "x"

_test/c2/c2.go

@@ -0,0 +1,5 @@
+package c2
+
+import "github.com/containous/yaegi/_test/c1"
+
+var C2 = c1.C1 + "Y"

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

@@ -0,0 +1,10 @@
+package main
+
+var f = func(a int) int { return 2 + a }
+
+func main() {
+	println(f(3))
+}
+
+// Output:
+// 5

_test/complex1.go

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

_test/complex2.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	c := complex(1, 0)
+	c += 1
+	fmt.Printf("%T %v\n", c, c)
+}
+
+// Output:
+// complex128 (2+0i)

_test/complex3.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	var s int = 1 + complex(1, 0)
+	fmt.Printf("%T %v\n", s, s)
+}
+
+// Output:
+// int 2

_test/composite0.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+var a = &[]*T{}
+
+type T struct{ name string }
+
+func main() {
+	fmt.Println(a)
+}
+
+// Output:
+// &[]

_test/composite1.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+var a = &[]*T{{}}
+
+type T struct{ name string }
+
+func main() {
+	fmt.Println((*a)[0])
+}
+
+// Output:
+// &{}

_test/composite2.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+var a = &[]*T{{"hello"}}
+
+type T struct{ name string }
+
+func main() {
+	fmt.Println((*a)[0])
+}
+
+// Output:
+// &{hello}

_test/composite3.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	var err error
+	var ok bool
+
+	_, ok = err.(interface{ IsSet() bool })
+	println(ok)
+}
+
+// Output:
+// false

_test/composite4.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	var err error
+
+	_, ok := err.(interface{ IsSet() bool })
+	println(ok)
+}
+
+// Output:
+// false

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

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

_test/ct/ct1.go

@@ -0,0 +1,3 @@
+package ct
+
+func init() { println("hello from ct1") }

_test/ct/ct2.go

@@ -0,0 +1,5 @@
+// +build !dummy
+
+package ct
+
+func init() { println("hello from ct2") }

_test/ct/ct3.go

@@ -0,0 +1,5 @@
+// +build dummy
+
+package ct
+
+func init() { println("hello from ct3") }

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

@@ -0,0 +1,3 @@
+package bar
+
+var Name = "foo-bar"

_test/foo/bar.go

@@ -1,6 +1,8 @@
 package foo
 
-import "./boo"
+import "github.com/containous/yaegi/_test/foo/boo"
 
 var Bar = "BARR"
 var Boo = boo.Boo
+
+func init() { println("init foo") }

_test/foo/bir.go

@@ -0,0 +1,5 @@
+package foo
+
+import "github.com/containous/yaegi/_test/foo/boo"
+
+var Bir = boo.Boo + "22"

_test/foo/boo/boo.go

@@ -1,3 +1,5 @@
 package boo
 
 var Boo = "Boo"
+
+func init() { println("init boo") }

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

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := "三"
+	for i := 0; i < len(s); i++ {
+		fmt.Printf("byte %d: %d\n", i, s[i])
+	}
+	for i, r := range s {
+		fmt.Printf("rune %d: %d\n", i, r)
+	}
+}
+
+// Output:
+// byte 0: 228
+// byte 1: 184
+// byte 2: 137
+// rune 0: 19977

_test/for7.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	for i := 0; i; {
+	}
+}
+
+// Error:
+// 4:14: non-bool used as for condition

_test/for8.go

@@ -0,0 +1,18 @@
+package main
+
+func main() {
+	for i := 0; i < 4; i++ {
+		for {
+			break
+		}
+		if i == 1 {
+			continue
+		}
+		println(i)
+	}
+}
+
+// Output:
+// 0
+// 2
+// 3

_test/for9.go

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

_test/fun10.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func f() func() {
+	return nil
+}
+
+func main() {
+	g := f()
+	fmt.Printf("%T %v\n", g, g)
+	if g == nil {
+		fmt.Println("nil func")
+	}
+}
+
+// Output:
+// func() <nil>
+// nil func

_test/fun11.go

@@ -0,0 +1,12 @@
+package main
+
+var f F
+
+type F func(int)
+
+func main() {
+	println("ok")
+}
+
+// Output:
+// ok

_test/fun6.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func NewPool() Pool { return Pool{} }
+
+type Pool struct {
+	p *sync.Pool
+}
+
+var _pool = NewPool()
+
+func main() {
+	fmt.Println(_pool)
+}
+
+// Output:
+// {<nil>}

_test/fun7.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	goflag "flag"
+	"fmt"
+)
+
+func Foo(goflag *goflag.Flag) {
+	fmt.Println(goflag)
+}
+
+func main() {
+	g := &goflag.Flag{}
+	Foo(g)
+}
+
+// Output:
+// &{  <nil> }

_test/fun8.go

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

_test/fun9.go

@@ -0,0 +1,12 @@
+package main
+
+type T uint
+
+func main() {
+	type myint int
+	var i = myint(1)
+	println(i)
+}
+
+// Output:
+// 1

_test/if2.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func main() {
+	var i int
+	if i % 1000000 {
+		fmt.Println("oops")
+	}
+}
+
+// Error:
+// 7:5: non-bool used as if condition

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

@@ -1,8 +1,10 @@
 package main
 
-import "./foo"
+import "github.com/containous/yaegi/_test/foo"
 
 func main() { println(foo.Bar, foo.Boo) }
 
 // Output:
+// init boo
+// init foo
 // BARR Boo

_test/import4.go

@@ -1,6 +1,6 @@
 package main
 
-import "./p1"
+import "github.com/containous/yaegi/_test/p1"
 
 func main() { println("num:", p1.Uint32()) }
 

_test/import5.go

@@ -0,0 +1,10 @@
+package main
+
+import boo "github.com/containous/yaegi/_test/foo"
+
+func main() { println(boo.Bar, boo.Boo, boo.Bir) }
+
+// Output:
+// init boo
+// init foo
+// BARR Boo Boo22

_test/import6.go

@@ -0,0 +1,11 @@
+package main
+
+import "github.com/containous/yaegi/_test/c1"
+
+func main() {
+	println(c1.C1)
+}
+
+// Error:
+// import cycle not allowed
+//	imports github.com/containous/yaegi/_test/c1

_test/import7.go

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

_test/import8.go

@@ -0,0 +1,10 @@
+package main
+
+import "github.com/containous/yaegi/_test/b1/foo"
+
+func main() {
+	println(foo.Desc)
+}
+
+// Output:
+// in b1/foo

_test/interface10.go

@@ -0,0 +1,12 @@
+package main
+
+type Edge interface {
+	ReverseEdge() Edge
+}
+
+func main() {
+	println("hello")
+}
+
+// Output:
+// hello

_test/interface11.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+type Error interface {
+	error
+	Code() string
+}
+
+type MyError Error
+
+type T struct {
+	Name string
+}
+
+func (t *T) Error() string { return "err: " + t.Name }
+func (t *T) Code() string  { return "code: " + t.Name }
+
+func newT(s string) MyError { return &T{s} }
+
+func main() {
+	t := newT("foo")
+	fmt.Println(t.Code())
+}
+
+// Output:
+// code: foo

_test/interface12.go

@@ -0,0 +1,18 @@
+package main
+
+type I1 interface {
+	Truc()
+}
+
+type T1 struct{}
+
+func (T1) Truc() { println("in T1 truc") }
+
+var x I1 = T1{}
+
+func main() {
+	x.Truc()
+}
+
+// Output:
+// in T1 truc

_test/interface13.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+)
+
+type X struct{}
+
+func (X) Foo() int {
+	return 1
+}
+func (X) Bar() int {
+	return 2
+}
+
+type Foo interface {
+	Foo() int
+}
+type Bar interface {
+	Bar() int
+}
+
+func main() {
+	var x X
+	var i Foo = x
+	j := i.(Bar)
+
+	fmt.Println(j.Bar())
+}
+
+// Output:
+// 2

_test/interface14.go

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

_test/interface15.go

@@ -0,0 +1,28 @@
+package main
+
+type Fooer interface {
+	Foo() string
+}
+
+type Barer interface {
+	//fmt.Stringer
+	Fooer
+	Bar()
+}
+
+type T struct{}
+
+func (t *T) Foo() string { return "T: foo" }
+func (*T) Bar()          { println("in bar") }
+
+var t = &T{}
+
+func main() {
+	var f Barer
+	if f != t {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/interface16.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+type Barer interface {
+	fmt.Stringer
+	Bar()
+}
+
+type T struct{}
+
+func (*T) String() string { return "T: nothing" }
+func (*T) Bar()           { println("in bar") }
+
+var t = &T{}
+
+func main() {
+	var f Barer
+	if f != t {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/interface17.go

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

_test/interface18.go

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

_test/interface19.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+var I interface{}
+
+func main() {
+	fmt.Printf("%T %v\n", I, I)
+}
+
+// Output:
+// <nil> <nil>