internal/gcimporter: have IImportShallow accept an import func

In preparation for skipping imports that aren't reached, change the
gcimporter.IImportShallow API to accept an func rather than an explicit
map.

Update call sites to use a trivial wrapper around the new API.
Subsequent CLs will avoid building packages that aren't needed.

Updates golang/go#57987

Change-Id: Iee88e5f42fa353cde3e87447031c3e7485f04ca4
Reviewed-on: https://go-review.googlesource.com/c/tools/+/476436
Reviewed-by: Alan Donovan <[email protected]>
gopls-CI: kokoro <[email protected]>
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: findleyr

gopls/internal/lsp/cache/analysis.go

@@ -743,7 +743,7 @@ func typeCheckForAnalysis(fset *token.FileSet, parsed []*source.ParsedGoFile, m
 			return nil, bug.Errorf("missing export data for %q", pkgPath)
 		}
 		hashExport(pkgPath, export)
-		imported, err := gcimporter.IImportShallow(fset, importMap, export, string(pkgPath), insert)
+		imported, err := gcimporter.IImportShallow(fset, gcimporter.GetPackageFromMap(importMap), export, string(pkgPath), insert)
 		if err != nil {
 			return nil, bug.Errorf("invalid export data for %q: %v", pkgPath, err)
 		}

gopls/internal/lsp/cache/check.go

@@ -354,7 +354,7 @@ func (b *typeCheckBatch) importPackage(ctx context.Context, m *source.Metadata,
 
 	// TODO(rfindley): collect "deep" hashes here using the provided
 	// callback, for precise pruning.
-	imported, err := gcimporter.IImportShallow(b.fset, impMap, data, string(m.PkgPath), func(*types.Package, string) {})
+	imported, err := gcimporter.IImportShallow(b.fset, gcimporter.GetPackageFromMap(impMap), data, string(m.PkgPath), func(*types.Package, string) {})
 	if err != nil {
 		return nil, bug.Errorf("invalid export data for %q: %v", m.ID, err)
 	}

internal/gcimporter/gcimporter_test.go

@@ -833,7 +833,7 @@ func TestIssue57729(t *testing.T) {
 	// Re-import it.
 	imports := make(map[string]*types.Package)
 	insert := func(pkg1 *types.Package, name string) { panic("unexpected insert") }
-	pkg2, err := IImportShallow(fset, imports, data, "p", insert)
+	pkg2, err := IImportShallow(fset, GetPackageFromMap(imports), data, "p", insert)
 	if err != nil {
 		t.Fatalf("import: %v", err) // any failure of IExport+IImport is a bug.
 	}

internal/gcimporter/iexport.go

@@ -47,9 +47,9 @@ func IExportShallow(fset *token.FileSet, pkg *types.Package) ([]byte, error) {
 // IImportShallow decodes "shallow" types.Package data encoded by IExportShallow
 // in the same executable. This function cannot import data from
 // cmd/compile or gcexportdata.Write.
-func IImportShallow(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string, insert InsertType) (*types.Package, error) {
+func IImportShallow(fset *token.FileSet, importFunc func(path, name string) *types.Package, data []byte, path string, insert InsertType) (*types.Package, error) {
 	const bundle = false
-	pkgs, err := iimportCommon(fset, imports, data, bundle, path, insert)
+	pkgs, err := iimportCommon(fset, importFunc, data, bundle, path, insert)
 	if err != nil {
 		return nil, err
 	}

internal/gcimporter/iimport.go

@@ -85,7 +85,7 @@ const (
 // If the export data version is not recognized or the format is otherwise
 // compromised, an error is returned.
 func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
-	pkgs, err := iimportCommon(fset, imports, data, false, path, nil)
+	pkgs, err := iimportCommon(fset, GetPackageFromMap(imports), data, false, path, nil)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -94,10 +94,36 @@ func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 
 // IImportBundle imports a set of packages from the serialized package bundle.
 func IImportBundle(fset *token.FileSet, imports map[string]*types.Package, data []byte) ([]*types.Package, error) {
-	return iimportCommon(fset, imports, data, true, "", nil)
+	return iimportCommon(fset, GetPackageFromMap(imports), data, true, "", nil)
 }
 
-func iimportCommon(fset *token.FileSet, imports map[string]*types.Package, data []byte, bundle bool, path string, insert InsertType) (pkgs []*types.Package, err error) {
+// A GetPackageFunc is a function that gets the package with
+// the given path from the importer state, creating it
+// (with the specified name) if necessary.
+// It is an abstraction of the map historically used to memoize package creation.
+//
+// Two calls with the same path must return the same package.
+type GetPackageFunc = func(path, name string) *types.Package
+
+// GetPackageFromMap returns a GetPackageFunc that retrieves packages from the
+// given map of package path -> package.
+//
+// The resulting func may mutate m: if a requested package is not found, a new
+// package will be inserted into m.
+func GetPackageFromMap(m map[string]*types.Package) GetPackageFunc {
+	return func(path, name string) *types.Package {
+		if _, ok := m[path]; !ok {
+			m[path] = types.NewPackage(path, name)
+		}
+		return m[path]
+	}
+}
+
+// iimportCommon implements the core of the import algorithm.
+//
+// The given getPackage func must always return a non-nil package
+// (see ImportFromMap for an example).
+func iimportCommon(fset *token.FileSet, getPackage GetPackageFunc, data []byte, bundle bool, path string, insert InsertType) (pkgs []*types.Package, err error) {
 	const currentVersion = iexportVersionCurrent
 	version := int64(-1)
 	if !debug {
@@ -195,10 +221,9 @@ func iimportCommon(fset *token.FileSet, imports map[string]*types.Package, data
 		if pkgPath == "" {
 			pkgPath = path
 		}
-		pkg := imports[pkgPath]
+		pkg := getPackage(pkgPath, pkgName)
 		if pkg == nil {
-			pkg = types.NewPackage(pkgPath, pkgName)
-			imports[pkgPath] = pkg
+			errorf("internal error: getPackage returned nil package for %s", pkgPath)
 		} else if pkg.Name() != pkgName {
 			errorf("conflicting names %s and %s for package %q", pkg.Name(), pkgName, path)
 		}

internal/gcimporter/shallow_test.go

@@ -118,7 +118,7 @@ func typecheck(t *testing.T, ppkg *packages.Package) {
 	)
 	loadFromExportData := func(imp *packages.Package) (*types.Package, error) {
 		data := []byte(imp.ExportFile)
-		return gcimporter.IImportShallow(fset, importMap, data, imp.PkgPath, insert)
+		return gcimporter.IImportShallow(fset, gcimporter.GetPackageFromMap(importMap), data, imp.PkgPath, insert)
 	}
 	insert = func(p *types.Package, name string) {
 		imp, ok := depsByPkgPath[p.Path()]