// Copyright 2019 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. // This is a copy of bexport_test.go for iexport.go. //go:build go1.11 // +build go1.11 package gcimporter_test import ( "bufio" "bytes" "fmt" "go/ast" "go/build" "go/constant" "go/parser" "go/token" "go/types" "io" "math/big" "os" "reflect" "runtime" "sort" "strings" "testing" "golang.org/x/tools/go/ast/inspector" "golang.org/x/tools/go/buildutil" "golang.org/x/tools/go/gcexportdata" "golang.org/x/tools/go/loader" "golang.org/x/tools/internal/aliases" "golang.org/x/tools/internal/gcimporter" "golang.org/x/tools/internal/testenv" "golang.org/x/tools/internal/typeparams/genericfeatures" ) func readExportFile(filename string) ([]byte, error) { f, err := os.Open(filename) if err != nil { return nil, err } defer f.Close() buf := bufio.NewReader(f) if _, _, err := gcimporter.FindExportData(buf); err != nil { return nil, err } if ch, err := buf.ReadByte(); err != nil { return nil, err } else if ch != 'i' { return nil, fmt.Errorf("unexpected byte: %v", ch) } return io.ReadAll(buf) } func iexport(fset *token.FileSet, version int, pkg *types.Package) ([]byte, error) { var buf bytes.Buffer const bundle, shallow = false, false if err := gcimporter.IExportCommon(&buf, fset, bundle, shallow, version, []*types.Package{pkg}); err != nil { return nil, err } return buf.Bytes(), nil } // isUnifiedBuilder reports whether we are executing on a go builder that uses // unified export data. func isUnifiedBuilder() bool { return os.Getenv("GO_BUILDER_NAME") == "linux-amd64-unified" } const minStdlibPackages = 248 func TestIExportData_stdlib(t *testing.T) { if runtime.Compiler == "gccgo" { t.Skip("gccgo standard library is inaccessible") } testenv.NeedsGoBuild(t) if isRace { t.Skipf("stdlib tests take too long in race mode and flake on builders") } if testing.Short() { t.Skip("skipping RAM hungry test in -short mode") } // Load, parse and type-check the program. ctxt := build.Default // copy ctxt.GOPATH = "" // disable GOPATH conf := loader.Config{ Build: &ctxt, AllowErrors: true, TypeChecker: types.Config{ Sizes: types.SizesFor(ctxt.Compiler, ctxt.GOARCH), Error: func(err error) { t.Log(err) }, }, } 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) } var sorted []*types.Package isUnified := isUnifiedBuilder() for pkg, info := range prog.AllPackages { // Temporarily skip packages that use generics on the unified builder, to // fix TryBots. // // TODO(#48595): fix this test with GOEXPERIMENT=unified. inspect := inspector.New(info.Files) features := genericfeatures.ForPackage(inspect, &info.Info) if isUnified && features != 0 { t.Logf("skipping package %q which uses generics", pkg.Path()) continue } if info.Files != nil { // non-empty directory sorted = append(sorted, pkg) } } sort.Slice(sorted, func(i, j int) bool { return sorted[i].Path() < sorted[j].Path() }) version := gcimporter.IExportVersion numPkgs := len(sorted) if want := minStdlibPackages; numPkgs < want { t.Errorf("Loaded only %d packages, want at least %d", numPkgs, want) } // TODO(adonovan): opt: parallelize this slow loop. for _, pkg := range sorted { if exportdata, err := iexport(conf.Fset, version, pkg); err != nil { t.Error(err) } else { testPkgData(t, conf.Fset, version, pkg, exportdata) } if pkg.Name() == "main" || pkg.Name() == "haserrors" { // skip; no export data } else if bp, err := ctxt.Import(pkg.Path(), "", build.FindOnly); err != nil { t.Log("warning:", err) } else if exportdata, err := readExportFile(bp.PkgObj); err != nil { t.Log("warning:", err) } else { testPkgData(t, conf.Fset, version, pkg, exportdata) } } var bundle bytes.Buffer if err := gcimporter.IExportBundle(&bundle, conf.Fset, sorted); err != nil { t.Fatal(err) } fset2 := token.NewFileSet() imports := make(map[string]*types.Package) pkgs2, err := gcimporter.IImportBundle(fset2, imports, bundle.Bytes()) if err != nil { t.Fatal(err) } for i, pkg := range sorted { testPkg(t, conf.Fset, version, pkg, fset2, pkgs2[i]) } } func testPkgData(t *testing.T, fset *token.FileSet, version int, pkg *types.Package, exportdata []byte) { imports := make(map[string]*types.Package) fset2 := token.NewFileSet() _, pkg2, err := gcimporter.IImportData(fset2, imports, exportdata, pkg.Path()) if err != nil { t.Errorf("IImportData(%s): %v", pkg.Path(), err) } testPkg(t, fset, version, pkg, fset2, pkg2) } func testPkg(t *testing.T, fset *token.FileSet, version int, pkg *types.Package, fset2 *token.FileSet, pkg2 *types.Package) { if _, err := iexport(fset2, version, pkg2); err != nil { t.Errorf("reexport %q: %v", pkg.Path(), err) } // Compare the packages' corresponding members. for _, name := range pkg.Scope().Names() { if !token.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(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 := cmpObj(obj1, obj2); err != nil { t.Errorf("%s.%s: %s\ngot: %s\nwant: %s", pkg.Path(), name, err, obj2, obj1) } } } // 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 TestIExportData_long(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 := iexport(fset1, gcimporter.IExportVersion, pkg) if err != nil { t.Fatal(err) } // import imports := make(map[string]*types.Package) fset2 := token.NewFileSet() _, pkg2, err := gcimporter.IImportData(fset2, imports, exportdata, pkg.Path()) if err != nil { t.Fatalf("IImportData(%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) } } func TestIExportData_typealiases(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 // use a nil fileset here to confirm that it doesn't panic exportdata, err := iexport(nil, gcimporter.IExportVersion, pkg1) if err != nil { t.Fatal(err) } // import imports := make(map[string]*types.Package) fset2 := token.NewFileSet() _, pkg2, err := gcimporter.IImportData(fset2, imports, exportdata, pkg1.Path()) if err != nil { t.Fatalf("IImportData(%s): %v", pkg1.Path(), err) } checkPkg(t, pkg2, "import") } // cmpObj reports how x and y differ. They are assumed to belong to different // universes so cannot be compared directly. It is an adapted version of // equalObj in bexport_test.go. func cmpObj(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 := x.(type) { case *types.Var, *types.Func: // ok case *types.Const: xval := x.Val() yval := y.(*types.Const).Val() equal := constant.Compare(xval, token.EQL, yval) if !equal { // try approx. comparison xkind := xval.Kind() ykind := yval.Kind() if xkind == constant.Complex || ykind == constant.Complex { equal = same(constant.Real(xval), constant.Real(yval)) && same(constant.Imag(xval), constant.Imag(yval)) } else if xkind == constant.Float || ykind == constant.Float { equal = same(xval, yval) } else if xkind == constant.Unknown && ykind == constant.Unknown { equal = true } } if !equal { return fmt.Errorf("unequal constants %s vs %s", xval, yval) } case *types.TypeName: if xalias, yalias := x.IsAlias(), y.(*types.TypeName).IsAlias(); xalias != yalias { return fmt.Errorf("mismatching IsAlias(): %s vs %s", x, y) } // equalType does not recurse into the underlying types of named types, so // we must pass the underlying type explicitly here. However, in doing this // we may skip checking the features of the named types themselves, in // situations where the type name is not referenced by the underlying or // any other top-level declarations. Therefore, we must explicitly compare // named types here, before passing their underlying types into equalType. xn, _ := aliases.Unalias(xt).(*types.Named) yn, _ := aliases.Unalias(yt).(*types.Named) if (xn == nil) != (yn == nil) { return fmt.Errorf("mismatching types: %T vs %T", xt, yt) } if xn != nil { if err := cmpNamed(xn, yn); err != nil { return err } } xt = xt.Underlying() yt = yt.Underlying() default: return fmt.Errorf("unexpected %T", x) } return equalType(xt, yt) } // Use the same floating-point precision (512) as cmd/compile // (see Mpprec in cmd/compile/internal/gc/mpfloat.go). const mpprec = 512 // same compares non-complex numeric values and reports if they are approximately equal. func same(x, y constant.Value) bool { xf := constantToFloat(x) yf := constantToFloat(y) d := new(big.Float).Sub(xf, yf) d.Abs(d) eps := big.NewFloat(1.0 / (1 << (mpprec - 1))) // allow for 1 bit of error return d.Cmp(eps) < 0 } // copy of the function with the same name in iexport.go. func constantToFloat(x constant.Value) *big.Float { var f big.Float f.SetPrec(mpprec) if v, exact := constant.Float64Val(x); exact { // float64 f.SetFloat64(v) } else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int { // TODO(gri): add big.Rat accessor to constant.Value. n := valueToRat(num) d := valueToRat(denom) f.SetRat(n.Quo(n, d)) } else { // Value too large to represent as a fraction => inaccessible. // TODO(gri): add big.Float accessor to constant.Value. _, ok := f.SetString(x.ExactString()) if !ok { panic("should not reach here") } } return &f } // copy of the function with the same name in iexport.go. func valueToRat(x constant.Value) *big.Rat { // Convert little-endian to big-endian. // I can't believe this is necessary. bytes := constant.Bytes(x) for i := 0; i < len(bytes)/2; i++ { bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i] } return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes)) } // This is a regression test for a bug in iexport of types.Struct: // unexported fields were losing their implicit package qualifier. func TestUnexportedStructFields(t *testing.T) { fset := token.NewFileSet() export := make(map[string][]byte) // process parses and type-checks a single-file // package and saves its export data. process := func(path, content string) { syntax, err := parser.ParseFile(fset, path+"/x.go", content, 0) if err != nil { t.Fatal(err) } packages := make(map[string]*types.Package) // keys are package paths cfg := &types.Config{ Importer: importerFunc(func(path string) (*types.Package, error) { data, ok := export[path] if !ok { return nil, fmt.Errorf("missing export data for %s", path) } return gcexportdata.Read(bytes.NewReader(data), fset, packages, path) }), } pkg := types.NewPackage(path, syntax.Name.Name) check := types.NewChecker(cfg, fset, pkg, nil) if err := check.Files([]*ast.File{syntax}); err != nil { t.Fatal(err) } var out bytes.Buffer if err := gcexportdata.Write(&out, fset, pkg); err != nil { t.Fatal(err) } export[path] = out.Bytes() } // Historically this led to a spurious error: // "cannot convert a.M (variable of type a.MyTime) to type time.Time" // because the private fields of Time and MyTime were not identical. process("time", `package time; type Time struct { x, y int }`) process("a", `package a; import "time"; type MyTime time.Time; var M MyTime`) process("b", `package b; import ("a"; "time"); var _ = time.Time(a.M)`) } type importerFunc func(path string) (*types.Package, error) func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }