fix: apply automatic type conversion to constant expressions (#484)

Generate wrappers for the following packages:

- crypto/ed25519 (go1.13 only)
- debug/dwarf
- debug/elf
- debug/gosym
- debug/pe
- debug/plan9obj
- net/http/pprof
- runtime/pprof
- runtime/trace

.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,11 @@
     "gocyclo",
     "gochecknoinits",
     "gochecknoglobals",
+    "wsl",
+    "godox",
+    "funlen",
+    "gocognit",
+    "stylecheck",
   ]
 
 [issues]
@@ -41,10 +46,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.12.x
+    - go: 1.13.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:
@@ -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

@@ -18,5 +18,6 @@ generate: gen_all_syscall
 
 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,22 +13,22 @@ 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
-* Support Go 1.11 and Go 1.12 (the latest 2 major releases)
+* Security: `unsafe` and `syscall` packages neither used nor exported by default
+* Support Go 1.12 and Go 1.13 (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/yaegi
@@ -37,27 +39,6 @@ and alias the `yaegi` command in `alias yaegi='rlwrap yaegi'` in your `~/.bashrc
 
 ## 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()`:
@@ -80,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:
@@ -123,15 +106,46 @@ 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
+>
+```
+
 ## 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
 
@@ -141,5 +155,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/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/assign10.go

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

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

@@ -0,0 +1,4 @@
+println("Hello")
+
+// Error:
+// _test/bad0.go: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/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/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/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/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/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/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/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/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/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/interface9.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+type Int int
+
+func (I Int) String() string {
+	return "foo"
+}
+
+func main() {
+	var i Int
+	var st fmt.Stringer = i
+	fmt.Println(st.String())
+}
+
+// Output:
+// foo

_test/map18.go

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

_test/math1.go

@@ -0,0 +1,13 @@
+package main
+
+import "math"
+
+func main() {
+	var f float32
+	if f < math.MaxFloat32 {
+		println("ok")
+	}
+}
+
+// Output:
+// ok

_test/method21.go

@@ -13,3 +13,6 @@ func (*Hello) Hi() string {
 func main() {
 	fmt.Println(&Hello{})
 }
+
+// Output:
+// &{}

_test/method22.go

@@ -0,0 +1,19 @@
+package main
+
+func Bar() {
+	s := Obj.Foo()
+	println(s)
+}
+
+var Obj = &T{}
+
+type T struct{}
+
+func (t *T) Foo() bool { return t != nil }
+
+func main() {
+	Bar()
+}
+
+// Output:
+// true

_test/method23.go

@@ -0,0 +1,21 @@
+package main
+
+func Bar() {
+	s := Obj.Foo()
+	println(s)
+}
+
+var Obj = NewT()
+
+func NewT() *T { return &T{} }
+
+type T struct{}
+
+func (t *T) Foo() bool { return t != nil }
+
+func main() {
+	Bar()
+}
+
+// Output:
+// true

_test/method24.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+type Pool struct {
+	p *sync.Pool
+}
+
+func (p Pool) Get() *Buffer { return &Buffer{} }
+
+func NewPool() Pool { return Pool{} }
+
+type Buffer struct {
+	bs   []byte
+	pool Pool
+}
+
+var (
+	_pool = NewPool()
+	Get   = _pool.Get
+)
+
+func main() {
+	fmt.Println(_pool)
+	fmt.Println(Get())
+}
+
+// Output:
+// {<nil>}
+// &{[] {<nil>}}

_test/method25.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func (p Pool) Get() *Buffer { return &Buffer{} }
+
+func NewPool() Pool { return Pool{} }
+
+type Buffer struct {
+	bs   []byte
+	pool Pool
+}
+
+type Pool struct {
+	p *sync.Pool
+}
+
+var (
+	_pool = NewPool()
+	Get   = _pool.Get
+)
+
+func main() {
+	fmt.Println(_pool)
+	fmt.Println(Get())
+}
+
+// Output:
+// {<nil>}
+// &{[] {<nil>}}

_test/method26.go

@@ -0,0 +1,18 @@
+package main
+
+func NewT(name string) *T { return &T{name} }
+
+var C = NewT("test")
+
+func (t *T) f() { println(t == C) }
+
+type T struct {
+	Name string
+}
+
+func main() {
+	C.f()
+}
+
+// Output:
+// true

_test/method27.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type AuthenticatedRequest struct {
+	http.Request
+	Username string
+}
+
+func main() {
+	a := &AuthenticatedRequest{}
+	fmt.Println("ua:", a.UserAgent())
+
+}
+
+// Output:
+// ua:

_test/method28.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+type T struct {
+	Name string
+}
+
+func (T) create() *T {
+	return &T{"Hello"}
+}
+
+func main() {
+	fmt.Println(T{}.create())
+}
+
+// Output:
+// &{Hello}

_test/nil0.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func f() (host, port string, err error) {
+	return "", "", nil
+}
+
+func main() {
+	h, p, err := f()
+	fmt.Println(h, p, err)
+}
+
+// Output:
+//   <nil>

_test/nil1.go

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	var a error = nil
+
+	if a == nil || a.Error() == "nil" {
+		println("a is nil")
+	}
+}
+
+// Output:
+// a is nil

_test/op4.go

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

_test/or0.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	c := false
+	println(c || !c)
+}
+
+// Output:
+// true

_test/or1.go

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+	c := false
+	println(!c || c)
+}
+
+// Output:
+// true

_test/ptr7.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"net"
+	"strings"
+)
+
+type ipNetValue net.IPNet
+
+func (ipnet *ipNetValue) Set(value string) error {
+	_, n, err := net.ParseCIDR(strings.TrimSpace(value))
+	if err != nil {
+		return err
+	}
+	*ipnet = ipNetValue(*n)
+	return nil
+}
+
+func main() {
+	v := ipNetValue{}
+	fmt.Println(v)
+}
+
+// Output:
+// {<nil> <nil>}

_test/ptr_array0.go

@@ -0,0 +1,13 @@
+package main
+
+type T [2]int
+
+func F0(t *T) int { return t[0] }
+
+func main() {
+	t := &T{1, 2}
+	println(F0(t))
+}
+
+// Output:
+// 1

_test/ptr_array1.go

@@ -0,0 +1,19 @@
+package main
+
+type T [3]int
+
+func F0(t *T) {
+	for i, v := range t {
+		println(i, v)
+	}
+}
+
+func main() {
+	t := &T{1, 2, 3}
+	F0(t)
+}
+
+// Output:
+// 0 1
+// 1 2
+// 2 3

_test/ptr_array2.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+type T [2]int
+
+func F1(t *T) { t[0] = 1 }
+
+func main() {
+	t := &T{}
+	F1(t)
+	fmt.Println(t)
+}
+
+// Output:
+// &[1 0]

_test/ptr_array3.go

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

_test/range0.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	v := []int{1, 2, 3}
+	for i := range v {
+		v = append(v, i)
+	}
+	fmt.Println(v)
+}
+
+// Output:
+// [1 2 3 0 1 2]

_test/range1.go

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

_test/range2.go

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

_test/range3.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := map[int]bool{1: true, 3: true, 5: true}
+	for k := range m {
+		m[k*2] = true
+	}
+	fmt.Println("ok")
+}
+
+// Output:
+// ok

_test/range4.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := map[int]bool{1: true, 3: true, 5: true}
+	for _, v := range m {
+		fmt.Println(v)
+	}
+}
+
+// Output:
+// true
+// true
+// true

_test/range5.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := map[int]bool{1: true, 3: true, 5: true}
+	var n int
+	for range m {
+		n++
+	}
+	fmt.Println(n)
+}
+
+// Output:
+// 3

_test/range6.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	m := map[float64]bool{math.NaN(): true, math.NaN(): true, math.NaN(): true}
+	for _, v := range m {
+		fmt.Println(v)
+	}
+}
+
+// Output:
+// true
+// true
+// true

_test/recurse0.go

@@ -0,0 +1,39 @@
+package main
+
+import "fmt"
+
+type T struct {
+	a []T
+	b []*T
+	c map[string]T
+	d map[string]*T
+	e chan T
+	f chan *T
+	h *T
+	i func(T) T
+	j func(*T) *T
+	U
+}
+
+type U struct {
+	k []T
+	l []*T
+	m map[string]T
+	n map[string]*T
+	o chan T
+	p chan *T
+	q *T
+	r func(T) T
+	s func(*T) *T
+}
+
+func main() {
+	t := T{}
+	u := U{}
+	fmt.Println(t)
+	fmt.Println(u)
+}
+
+// Output:
+// {[] [] map[] map[] <nil> <nil> <nil> <nil> <nil> {[] [] map[] map[] <nil> <nil> <nil> <nil> <nil>}}
+// {[] [] map[] map[] <nil> <nil> <nil> <nil> <nil>}

_test/ret7.go

@@ -0,0 +1,11 @@
+package main
+
+func one() uint {
+	return 1
+}
+func main() {
+	println(one())
+}
+
+// Output:
+// 1

_test/select0.go

@@ -9,6 +9,9 @@ func forever() {
 
 func main() {
 	go forever()
-	time.Sleep(1e9)
+	time.Sleep(1e4)
 	println("bye")
 }
+
+// Output:
+// bye

_test/shift1.go

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+const a1 = 0x7f8 >> 3
+
+func main() {
+	fmt.Printf("%T %v\n", a1, a1)
+}
+
+// Output:
+// int 255

_test/shift2.go

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+	var u uint64
+	var v uint32
+	println(u << v)
+}
+
+// Output:
+// 0

_test/shift3.go

@@ -0,0 +1,10 @@
+package main
+
+const a = 1.0
+
+const b = a + 3
+
+func main() { println(b << (1)) }
+
+// Output:
+// 8

_test/str3.go

@@ -0,0 +1,11 @@
+package main
+
+import "strconv"
+
+func main() {
+	str := strconv.Itoa(101)
+	println(str[0] == '1')
+}
+
+// Output:
+// true