From 73df946d56c74384511a194dd01dbe099584fd1a Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 15:14:23 +0200 Subject: Adding upstream version 1.16.10. Signed-off-by: Daniel Baumann --- src/go/importer/importer.go | 122 +++++++++++++++++++++++++++++++++++++++ src/go/importer/importer_test.go | 87 ++++++++++++++++++++++++++++ 2 files changed, 209 insertions(+) create mode 100644 src/go/importer/importer.go create mode 100644 src/go/importer/importer_test.go (limited to 'src/go/importer') diff --git a/src/go/importer/importer.go b/src/go/importer/importer.go new file mode 100644 index 0000000..23118d3 --- /dev/null +++ b/src/go/importer/importer.go @@ -0,0 +1,122 @@ +// Copyright 2015 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 importer provides access to export data importers. +package importer + +import ( + "go/build" + "go/internal/gccgoimporter" + "go/internal/gcimporter" + "go/internal/srcimporter" + "go/token" + "go/types" + "io" + "runtime" +) + +// A Lookup function returns a reader to access package data for +// a given import path, or an error if no matching package is found. +type Lookup func(path string) (io.ReadCloser, error) + +// ForCompiler returns an Importer for importing from installed packages +// for the compilers "gc" and "gccgo", or for importing directly +// from the source if the compiler argument is "source". In this +// latter case, importing may fail under circumstances where the +// exported API is not entirely defined in pure Go source code +// (if the package API depends on cgo-defined entities, the type +// checker won't have access to those). +// +// The lookup function is called each time the resulting importer needs +// to resolve an import path. In this mode the importer can only be +// invoked with canonical import paths (not relative or absolute ones); +// it is assumed that the translation to canonical import paths is being +// done by the client of the importer. +// +// A lookup function must be provided for correct module-aware operation. +// Deprecated: If lookup is nil, for backwards-compatibility, the importer +// will attempt to resolve imports in the $GOPATH workspace. +func ForCompiler(fset *token.FileSet, compiler string, lookup Lookup) types.Importer { + switch compiler { + case "gc": + return &gcimports{ + fset: fset, + packages: make(map[string]*types.Package), + lookup: lookup, + } + + case "gccgo": + var inst gccgoimporter.GccgoInstallation + if err := inst.InitFromDriver("gccgo"); err != nil { + return nil + } + return &gccgoimports{ + packages: make(map[string]*types.Package), + importer: inst.GetImporter(nil, nil), + lookup: lookup, + } + + case "source": + if lookup != nil { + panic("source importer for custom import path lookup not supported (issue #13847).") + } + + return srcimporter.New(&build.Default, fset, make(map[string]*types.Package)) + } + + // compiler not supported + return nil +} + +// For calls ForCompiler with a new FileSet. +// +// Deprecated: Use ForCompiler, which populates a FileSet +// with the positions of objects created by the importer. +func For(compiler string, lookup Lookup) types.Importer { + return ForCompiler(token.NewFileSet(), compiler, lookup) +} + +// Default returns an Importer for the compiler that built the running binary. +// If available, the result implements types.ImporterFrom. +func Default() types.Importer { + return For(runtime.Compiler, nil) +} + +// gc importer + +type gcimports struct { + fset *token.FileSet + packages map[string]*types.Package + lookup Lookup +} + +func (m *gcimports) Import(path string) (*types.Package, error) { + return m.ImportFrom(path, "" /* no vendoring */, 0) +} + +func (m *gcimports) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) { + if mode != 0 { + panic("mode must be 0") + } + return gcimporter.Import(m.fset, m.packages, path, srcDir, m.lookup) +} + +// gccgo importer + +type gccgoimports struct { + packages map[string]*types.Package + importer gccgoimporter.Importer + lookup Lookup +} + +func (m *gccgoimports) Import(path string) (*types.Package, error) { + return m.ImportFrom(path, "" /* no vendoring */, 0) +} + +func (m *gccgoimports) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) { + if mode != 0 { + panic("mode must be 0") + } + return m.importer(m.packages, path, srcDir, m.lookup) +} diff --git a/src/go/importer/importer_test.go b/src/go/importer/importer_test.go new file mode 100644 index 0000000..0f5121d --- /dev/null +++ b/src/go/importer/importer_test.go @@ -0,0 +1,87 @@ +// Copyright 2017 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 importer + +import ( + "go/token" + "internal/testenv" + "io" + "os" + "os/exec" + "runtime" + "strings" + "testing" +) + +func TestForCompiler(t *testing.T) { + testenv.MustHaveGoBuild(t) + + const thePackage = "math/big" + out, err := exec.Command(testenv.GoToolPath(t), "list", "-f={{context.Compiler}}:{{.Target}}", thePackage).CombinedOutput() + if err != nil { + t.Fatalf("go list %s: %v\n%s", thePackage, err, out) + } + target := strings.TrimSpace(string(out)) + i := strings.Index(target, ":") + compiler, target := target[:i], target[i+1:] + if !strings.HasSuffix(target, ".a") { + t.Fatalf("unexpected package %s target %q (not *.a)", thePackage, target) + } + + if compiler == "gccgo" { + t.Skip("golang.org/issue/22500") + } + + fset := token.NewFileSet() + + t.Run("LookupDefault", func(t *testing.T) { + imp := ForCompiler(fset, compiler, nil) + pkg, err := imp.Import(thePackage) + if err != nil { + t.Fatal(err) + } + if pkg.Path() != thePackage { + t.Fatalf("Path() = %q, want %q", pkg.Path(), thePackage) + } + + // Check that the fileset positions are accurate. + // https://github.com/golang/go#28995 + mathBigInt := pkg.Scope().Lookup("Int") + posn := fset.Position(mathBigInt.Pos()) // "$GOROOT/src/math/big/int.go:25:1" + filename := strings.Replace(posn.Filename, "$GOROOT", runtime.GOROOT(), 1) + data, err := os.ReadFile(filename) + if err != nil { + t.Fatalf("can't read file containing declaration of math/big.Int: %v", err) + } + lines := strings.Split(string(data), "\n") + if posn.Line > len(lines) || !strings.HasPrefix(lines[posn.Line-1], "type Int") { + t.Fatalf("Object %v position %s does not contain its declaration", + mathBigInt, posn) + } + }) + + t.Run("LookupCustom", func(t *testing.T) { + lookup := func(path string) (io.ReadCloser, error) { + if path != "math/bigger" { + t.Fatalf("lookup called with unexpected path %q", path) + } + f, err := os.Open(target) + if err != nil { + t.Fatal(err) + } + return f, nil + } + imp := ForCompiler(fset, compiler, lookup) + pkg, err := imp.Import("math/bigger") + if err != nil { + t.Fatal(err) + } + // Even though we open math/big.a, the import request was for math/bigger + // and that should be recorded in pkg.Path(), at least for the gc toolchain. + if pkg.Path() != "math/bigger" { + t.Fatalf("Path() = %q, want %q", pkg.Path(), "math/bigger") + } + }) +} -- cgit v1.2.3