--- /dev/null
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gcimporter_test
+
+import (
+ "fmt"
+ "go/ast"
+ "go/build"
+ "go/constant"
+ "go/parser"
+ "go/token"
+ "go/types"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "strings"
+ "testing"
+
+ "golang.org/x/tools/go/buildutil"
+ "golang.org/x/tools/go/internal/gcimporter"
+ "golang.org/x/tools/go/loader"
+)
+
+var isRace = false
+
+func TestBExportData_stdlib(t *testing.T) {
+ if runtime.Compiler == "gccgo" {
+ t.Skip("gccgo standard library is inaccessible")
+ }
+ if runtime.GOOS == "android" {
+ t.Skipf("incomplete std lib on %s", runtime.GOOS)
+ }
+ if isRace {
+ t.Skipf("stdlib tests take too long in race mode and flake on builders")
+ }
+
+ // Load, parse and type-check the program.
+ ctxt := build.Default // copy
+ ctxt.GOPATH = "" // disable GOPATH
+ conf := loader.Config{
+ Build: &ctxt,
+ AllowErrors: true,
+ }
+ for _, path := range buildutil.AllPackages(conf.Build) {
+ conf.Import(path)
+ }
+
+ // Create a package containing type and value errors to ensure
+ // they are properly encoded/decoded.
+ f, err := conf.ParseFile("haserrors/haserrors.go", `package haserrors
+const UnknownValue = "" + 0
+type UnknownType undefined
+`)
+ if err != nil {
+ t.Fatal(err)
+ }
+ conf.CreateFromFiles("haserrors", f)
+
+ prog, err := conf.Load()
+ if err != nil {
+ t.Fatalf("Load failed: %v", err)
+ }
+
+ numPkgs := len(prog.AllPackages)
+ if want := 248; numPkgs < want {
+ t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want)
+ }
+
+ for pkg, info := range prog.AllPackages {
+ if info.Files == nil {
+ continue // empty directory
+ }
+ exportdata, err := gcimporter.BExportData(conf.Fset, pkg)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ imports := make(map[string]*types.Package)
+ fset2 := token.NewFileSet()
+ n, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg.Path())
+ if err != nil {
+ t.Errorf("BImportData(%s): %v", pkg.Path(), err)
+ continue
+ }
+ if n != len(exportdata) {
+ t.Errorf("BImportData(%s) decoded %d bytes, want %d",
+ pkg.Path(), n, len(exportdata))
+ }
+
+ // Compare the packages' corresponding members.
+ for _, name := range pkg.Scope().Names() {
+ if !ast.IsExported(name) {
+ continue
+ }
+ obj1 := pkg.Scope().Lookup(name)
+ obj2 := pkg2.Scope().Lookup(name)
+ if obj2 == nil {
+ t.Errorf("%s.%s not found, want %s", pkg.Path(), name, obj1)
+ continue
+ }
+
+ fl1 := fileLine(conf.Fset, obj1)
+ fl2 := fileLine(fset2, obj2)
+ if fl1 != fl2 {
+ t.Errorf("%s.%s: got posn %s, want %s",
+ pkg.Path(), name, fl2, fl1)
+ }
+
+ if err := equalObj(obj1, obj2); err != nil {
+ t.Errorf("%s.%s: %s\ngot: %s\nwant: %s",
+ pkg.Path(), name, err, obj2, obj1)
+ }
+ }
+ }
+}
+
+func fileLine(fset *token.FileSet, obj types.Object) string {
+ posn := fset.Position(obj.Pos())
+ filename := filepath.Clean(strings.ReplaceAll(posn.Filename, "$GOROOT", runtime.GOROOT()))
+ return fmt.Sprintf("%s:%d", filename, posn.Line)
+}
+
+// equalObj reports how x and y differ. They are assumed to belong to
+// different universes so cannot be compared directly.
+func equalObj(x, y types.Object) error {
+ if reflect.TypeOf(x) != reflect.TypeOf(y) {
+ return fmt.Errorf("%T vs %T", x, y)
+ }
+ xt := x.Type()
+ yt := y.Type()
+ switch x.(type) {
+ case *types.Var, *types.Func:
+ // ok
+ case *types.Const:
+ xval := x.(*types.Const).Val()
+ yval := y.(*types.Const).Val()
+ // Use string comparison for floating-point values since rounding is permitted.
+ if constant.Compare(xval, token.NEQ, yval) &&
+ !(xval.Kind() == constant.Float && xval.String() == yval.String()) {
+ return fmt.Errorf("unequal constants %s vs %s", xval, yval)
+ }
+ case *types.TypeName:
+ xt = xt.Underlying()
+ yt = yt.Underlying()
+ default:
+ return fmt.Errorf("unexpected %T", x)
+ }
+ return equalType(xt, yt)
+}
+
+func equalType(x, y types.Type) error {
+ if reflect.TypeOf(x) != reflect.TypeOf(y) {
+ return fmt.Errorf("unequal kinds: %T vs %T", x, y)
+ }
+ switch x := x.(type) {
+ case *types.Interface:
+ y := y.(*types.Interface)
+ // TODO(gri): enable separate emission of Embedded interfaces
+ // and ExplicitMethods then use this logic.
+ // if x.NumEmbeddeds() != y.NumEmbeddeds() {
+ // return fmt.Errorf("unequal number of embedded interfaces: %d vs %d",
+ // x.NumEmbeddeds(), y.NumEmbeddeds())
+ // }
+ // for i := 0; i < x.NumEmbeddeds(); i++ {
+ // xi := x.Embedded(i)
+ // yi := y.Embedded(i)
+ // if xi.String() != yi.String() {
+ // return fmt.Errorf("mismatched %th embedded interface: %s vs %s",
+ // i, xi, yi)
+ // }
+ // }
+ // if x.NumExplicitMethods() != y.NumExplicitMethods() {
+ // return fmt.Errorf("unequal methods: %d vs %d",
+ // x.NumExplicitMethods(), y.NumExplicitMethods())
+ // }
+ // for i := 0; i < x.NumExplicitMethods(); i++ {
+ // xm := x.ExplicitMethod(i)
+ // ym := y.ExplicitMethod(i)
+ // if xm.Name() != ym.Name() {
+ // return fmt.Errorf("mismatched %th method: %s vs %s", i, xm, ym)
+ // }
+ // if err := equalType(xm.Type(), ym.Type()); err != nil {
+ // return fmt.Errorf("mismatched %s method: %s", xm.Name(), err)
+ // }
+ // }
+ if x.NumMethods() != y.NumMethods() {
+ return fmt.Errorf("unequal methods: %d vs %d",
+ x.NumMethods(), y.NumMethods())
+ }
+ for i := 0; i < x.NumMethods(); i++ {
+ xm := x.Method(i)
+ ym := y.Method(i)
+ if xm.Name() != ym.Name() {
+ return fmt.Errorf("mismatched %dth method: %s vs %s", i, xm, ym)
+ }
+ if err := equalType(xm.Type(), ym.Type()); err != nil {
+ return fmt.Errorf("mismatched %s method: %s", xm.Name(), err)
+ }
+ }
+ case *types.Array:
+ y := y.(*types.Array)
+ if x.Len() != y.Len() {
+ return fmt.Errorf("unequal array lengths: %d vs %d", x.Len(), y.Len())
+ }
+ if err := equalType(x.Elem(), y.Elem()); err != nil {
+ return fmt.Errorf("array elements: %s", err)
+ }
+ case *types.Basic:
+ y := y.(*types.Basic)
+ if x.Kind() != y.Kind() {
+ return fmt.Errorf("unequal basic types: %s vs %s", x, y)
+ }
+ case *types.Chan:
+ y := y.(*types.Chan)
+ if x.Dir() != y.Dir() {
+ return fmt.Errorf("unequal channel directions: %d vs %d", x.Dir(), y.Dir())
+ }
+ if err := equalType(x.Elem(), y.Elem()); err != nil {
+ return fmt.Errorf("channel elements: %s", err)
+ }
+ case *types.Map:
+ y := y.(*types.Map)
+ if err := equalType(x.Key(), y.Key()); err != nil {
+ return fmt.Errorf("map keys: %s", err)
+ }
+ if err := equalType(x.Elem(), y.Elem()); err != nil {
+ return fmt.Errorf("map values: %s", err)
+ }
+ case *types.Named:
+ y := y.(*types.Named)
+ if x.String() != y.String() {
+ return fmt.Errorf("unequal named types: %s vs %s", x, y)
+ }
+ case *types.Pointer:
+ y := y.(*types.Pointer)
+ if err := equalType(x.Elem(), y.Elem()); err != nil {
+ return fmt.Errorf("pointer elements: %s", err)
+ }
+ case *types.Signature:
+ y := y.(*types.Signature)
+ if err := equalType(x.Params(), y.Params()); err != nil {
+ return fmt.Errorf("parameters: %s", err)
+ }
+ if err := equalType(x.Results(), y.Results()); err != nil {
+ return fmt.Errorf("results: %s", err)
+ }
+ if x.Variadic() != y.Variadic() {
+ return fmt.Errorf("unequal variadicity: %t vs %t",
+ x.Variadic(), y.Variadic())
+ }
+ if (x.Recv() != nil) != (y.Recv() != nil) {
+ return fmt.Errorf("unequal receivers: %s vs %s", x.Recv(), y.Recv())
+ }
+ if x.Recv() != nil {
+ // TODO(adonovan): fix: this assertion fires for interface methods.
+ // The type of the receiver of an interface method is a named type
+ // if the Package was loaded from export data, or an unnamed (interface)
+ // type if the Package was produced by type-checking ASTs.
+ // if err := equalType(x.Recv().Type(), y.Recv().Type()); err != nil {
+ // return fmt.Errorf("receiver: %s", err)
+ // }
+ }
+ case *types.Slice:
+ y := y.(*types.Slice)
+ if err := equalType(x.Elem(), y.Elem()); err != nil {
+ return fmt.Errorf("slice elements: %s", err)
+ }
+ case *types.Struct:
+ y := y.(*types.Struct)
+ if x.NumFields() != y.NumFields() {
+ return fmt.Errorf("unequal struct fields: %d vs %d",
+ x.NumFields(), y.NumFields())
+ }
+ for i := 0; i < x.NumFields(); i++ {
+ xf := x.Field(i)
+ yf := y.Field(i)
+ if xf.Name() != yf.Name() {
+ return fmt.Errorf("mismatched fields: %s vs %s", xf, yf)
+ }
+ if err := equalType(xf.Type(), yf.Type()); err != nil {
+ return fmt.Errorf("struct field %s: %s", xf.Name(), err)
+ }
+ if x.Tag(i) != y.Tag(i) {
+ return fmt.Errorf("struct field %s has unequal tags: %q vs %q",
+ xf.Name(), x.Tag(i), y.Tag(i))
+ }
+ }
+ case *types.Tuple:
+ y := y.(*types.Tuple)
+ if x.Len() != y.Len() {
+ return fmt.Errorf("unequal tuple lengths: %d vs %d", x.Len(), y.Len())
+ }
+ for i := 0; i < x.Len(); i++ {
+ if err := equalType(x.At(i).Type(), y.At(i).Type()); err != nil {
+ return fmt.Errorf("tuple element %d: %s", i, err)
+ }
+ }
+ }
+ return nil
+}
+
+// TestVeryLongFile tests the position of an import object declared in
+// a very long input file. Line numbers greater than maxlines are
+// reported as line 1, not garbage or token.NoPos.
+func TestVeryLongFile(t *testing.T) {
+ // parse and typecheck
+ longFile := "package foo" + strings.Repeat("\n", 123456) + "var X int"
+ fset1 := token.NewFileSet()
+ f, err := parser.ParseFile(fset1, "foo.go", longFile, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var conf types.Config
+ pkg, err := conf.Check("foo", fset1, []*ast.File{f}, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // export
+ exportdata, err := gcimporter.BExportData(fset1, pkg)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // import
+ imports := make(map[string]*types.Package)
+ fset2 := token.NewFileSet()
+ _, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg.Path())
+ if err != nil {
+ t.Fatalf("BImportData(%s): %v", pkg.Path(), err)
+ }
+
+ // compare
+ posn1 := fset1.Position(pkg.Scope().Lookup("X").Pos())
+ posn2 := fset2.Position(pkg2.Scope().Lookup("X").Pos())
+ if want := "foo.go:1:1"; posn2.String() != want {
+ t.Errorf("X position = %s, want %s (orig was %s)",
+ posn2, want, posn1)
+ }
+}
+
+const src = `
+package p
+
+type (
+ T0 = int32
+ T1 = struct{}
+ T2 = struct{ T1 }
+ Invalid = foo // foo is undeclared
+)
+`
+
+func checkPkg(t *testing.T, pkg *types.Package, label string) {
+ T1 := types.NewStruct(nil, nil)
+ T2 := types.NewStruct([]*types.Var{types.NewField(0, pkg, "T1", T1, true)}, nil)
+
+ for _, test := range []struct {
+ name string
+ typ types.Type
+ }{
+ {"T0", types.Typ[types.Int32]},
+ {"T1", T1},
+ {"T2", T2},
+ {"Invalid", types.Typ[types.Invalid]},
+ } {
+ obj := pkg.Scope().Lookup(test.name)
+ if obj == nil {
+ t.Errorf("%s: %s not found", label, test.name)
+ continue
+ }
+ tname, _ := obj.(*types.TypeName)
+ if tname == nil {
+ t.Errorf("%s: %v not a type name", label, obj)
+ continue
+ }
+ if !tname.IsAlias() {
+ t.Errorf("%s: %v: not marked as alias", label, tname)
+ continue
+ }
+ if got := tname.Type(); !types.Identical(got, test.typ) {
+ t.Errorf("%s: %v: got %v; want %v", label, tname, got, test.typ)
+ }
+ }
+}
+
+func TestTypeAliases(t *testing.T) {
+ // parse and typecheck
+ fset1 := token.NewFileSet()
+ f, err := parser.ParseFile(fset1, "p.go", src, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var conf types.Config
+ pkg1, err := conf.Check("p", fset1, []*ast.File{f}, nil)
+ if err == nil {
+ // foo in undeclared in src; we should see an error
+ t.Fatal("invalid source type-checked without error")
+ }
+ if pkg1 == nil {
+ // despite incorrect src we should see a (partially) type-checked package
+ t.Fatal("nil package returned")
+ }
+ checkPkg(t, pkg1, "export")
+
+ // export
+ exportdata, err := gcimporter.BExportData(fset1, pkg1)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // import
+ imports := make(map[string]*types.Package)
+ fset2 := token.NewFileSet()
+ _, pkg2, err := gcimporter.BImportData(fset2, imports, exportdata, pkg1.Path())
+ if err != nil {
+ t.Fatalf("BImportData(%s): %v", pkg1.Path(), err)
+ }
+ checkPkg(t, pkg2, "import")
+}
projects / dotfiles / .git / blobdiff