7be17d393f
The interpreter has its own internal fileset and expects all code to have been parsed using that fileset. If a user creates a fileset, calls `go/parser.Parse*`, then passes the result to `interp.CompileAST`, strange things can happen. The solutions I can see are: 1. Expose the fileset so the user can use it when parsing source. 2. Add the fileset as an option (input to New) so that the user can tell the interpreter to use a specific fileset. 3. Pass the fileset into `CompileAST` There are two ways to implement option 3. One is to add a field to nodes and update every reference to `interp.fset` to use `node.fset`. The other is to add a parameter to every function that references `interp.fset` or calls a function that does. Both of these are significant changes and involve an extra pointer for every node or most function calls. Options 1 and 2 are easy. Option 2 involves adding an option so I went with option 1. I can imagine situations where option 2 could be necessary, but I can open another issue/PR if and when I need that. Fixes #1383
85 lines
1.6 KiB
Go
85 lines
1.6 KiB
Go
package interp
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/parser"
|
|
"go/token"
|
|
"testing"
|
|
|
|
"github.com/traefik/yaegi/stdlib"
|
|
)
|
|
|
|
func TestCompileAST(t *testing.T) {
|
|
i := New(Options{})
|
|
file, err := parser.ParseFile(i.FileSet(), "_.go", `
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
type Foo struct{}
|
|
|
|
var foo Foo
|
|
const bar = "asdf"
|
|
|
|
func main() {
|
|
fmt.Println(1)
|
|
}
|
|
`, 0)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if len(file.Imports) != 1 || len(file.Decls) != 5 {
|
|
panic("wrong number of imports or decls")
|
|
}
|
|
|
|
dType := file.Decls[1].(*ast.GenDecl)
|
|
dVar := file.Decls[2].(*ast.GenDecl)
|
|
dConst := file.Decls[3].(*ast.GenDecl)
|
|
dFunc := file.Decls[4].(*ast.FuncDecl)
|
|
|
|
if dType.Tok != token.TYPE {
|
|
panic("decl[1] is not a type")
|
|
}
|
|
if dVar.Tok != token.VAR {
|
|
panic("decl[2] is not a var")
|
|
}
|
|
if dConst.Tok != token.CONST {
|
|
panic("decl[3] is not a const")
|
|
}
|
|
|
|
cases := []struct {
|
|
desc string
|
|
node ast.Node
|
|
skip string
|
|
}{
|
|
{desc: "file", node: file},
|
|
{desc: "import", node: file.Imports[0]},
|
|
{desc: "type", node: dType},
|
|
{desc: "var", node: dVar, skip: "not supported"},
|
|
{desc: "const", node: dConst},
|
|
{desc: "func", node: dFunc},
|
|
{desc: "block", node: dFunc.Body},
|
|
{desc: "expr", node: dFunc.Body.List[0]},
|
|
}
|
|
|
|
_ = i.Use(stdlib.Symbols)
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.desc, func(t *testing.T) {
|
|
if c.skip != "" {
|
|
t.Skip(c.skip)
|
|
}
|
|
|
|
i := i
|
|
if _, ok := c.node.(*ast.File); ok {
|
|
i = New(Options{})
|
|
_ = i.Use(stdlib.Symbols)
|
|
}
|
|
_, err := i.CompileAST(c.node)
|
|
if err != nil {
|
|
t.Fatalf("Failed to compile %s: %v", c.desc, err)
|
|
}
|
|
})
|
|
}
|
|
}
|