gopls: prepare for mod cache index

This CL adds the infrastructure for using the module cache index when
satisfying missing imports. There is no change in behavior as it invokes
the existing imports.Source.

There is a new option importsSource whose value can be "goimports" to keep
the old behavior, "gopls" to use (in a future CL) the module cache
index, and "off" (for use by cider) to avoid looking in the file
system at all.

The index is kept in memory. Periodically the code checks to see if it
needs to be updated.

Change-Id: I61e0b5e224a6c26d75932417b26ecb9f432b460f
Reviewed-on: https://go-review.googlesource.com/c/tools/+/640495
Reviewed-by: Robert Findley <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: pjweinbgo

gopls/internal/cache/imports.go

@@ -15,6 +15,7 @@ import (
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/event/keys"
 	"golang.org/x/tools/internal/imports"
+	"golang.org/x/tools/internal/modindex"
 )
 
 // refreshTimer implements delayed asynchronous refreshing of state.
@@ -59,11 +60,8 @@ func (t *refreshTimer) schedule() {
 
 	if t.timer == nil {
 		// Don't refresh more than twice per minute.
-		delay := 30 * time.Second
 		// Don't spend more than ~2% of the time refreshing.
-		if adaptive := 50 * t.duration; adaptive > delay {
-			delay = adaptive
-		}
+		delay := max(30*time.Second, 50*t.duration)
 		t.timer = time.AfterFunc(delay, func() {
 			start := time.Now()
 			t.mu.Lock()
@@ -149,6 +147,41 @@ func newImportsState(backgroundCtx context.Context, modCache *sharedModCache, en
 	return s
 }
 
+// modcacheState holds a modindex.Index and controls its updates
+type modcacheState struct {
+	dir          string // GOMODCACHE
+	refreshTimer *refreshTimer
+	mu           sync.Mutex
+	index        *modindex.Index
+}
+
+// newModcacheState constructs a new modcacheState for goimports.
+// The returned state is automatically updated until [modcacheState.stopTimer] is called.
+func newModcacheState(dir string) *modcacheState {
+	s := &modcacheState{
+		dir: dir,
+	}
+	s.index, _ = modindex.ReadIndex(dir)
+	s.refreshTimer = newRefreshTimer(s.refreshIndex)
+	go s.refreshIndex()
+	return s
+}
+
+func (s *modcacheState) refreshIndex() {
+	ok, err := modindex.Update(s.dir)
+	if err != nil || !ok {
+		return
+	}
+	// read the new index
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.index, _ = modindex.ReadIndex(s.dir)
+}
+
+func (s *modcacheState) stopTimer() {
+	s.refreshTimer.stop()
+}
+
 // stopTimer stops scheduled refreshes of this imports state.
 func (s *importsState) stopTimer() {
 	s.refreshTimer.stop()

gopls/internal/cache/session.go

@@ -8,10 +8,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"maps"
 	"os"
 	"path/filepath"
 	"slices"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -218,7 +218,7 @@ func (s *Session) createView(ctx context.Context, def *viewDefinition) (*View, *
 			ModCache:       s.cache.modCache.dirCache(def.folder.Env.GOMODCACHE),
 		}
 		if def.folder.Options.VerboseOutput {
-			pe.Logf = func(format string, args ...interface{}) {
+			pe.Logf = func(format string, args ...any) {
 				event.Log(ctx, fmt.Sprintf(format, args...))
 			}
 		}
@@ -237,6 +237,9 @@ func (s *Session) createView(ctx context.Context, def *viewDefinition) (*View, *
 		viewDefinition:       def,
 		importsState:         newImportsState(backgroundCtx, s.cache.modCache, pe),
 	}
+	if def.folder.Options.ImportsSource != "off" {
+		v.modcacheState = newModcacheState(def.folder.Env.GOMODCACHE)
+	}
 
 	s.snapshotWG.Add(1)
 	v.snapshot = &Snapshot{
@@ -833,9 +836,7 @@ func (s *Session) DidModifyFiles(ctx context.Context, modifications []file.Modif
 			openFiles = append(openFiles, o.URI())
 		}
 		// Sort for determinism.
-		sort.Slice(openFiles, func(i, j int) bool {
-			return openFiles[i] < openFiles[j]
-		})
+		slices.Sort(openFiles)
 
 		// TODO(rfindley): can we avoid running the go command (go env)
 		// synchronously to change processing? Can we assume that the env did not
@@ -1124,9 +1125,7 @@ func (s *Session) FileWatchingGlobPatterns(ctx context.Context) map[protocol.Rel
 		if err != nil {
 			continue // view is shut down; continue with others
 		}
-		for k, v := range snapshot.fileWatchingGlobPatterns() {
-			patterns[k] = v
-		}
+		maps.Copy(patterns, snapshot.fileWatchingGlobPatterns())
 		release()
 	}
 	return patterns

gopls/internal/cache/source.go

@@ -0,0 +1,35 @@
+// Copyright 2025 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 cache
+
+import (
+	"context"
+
+	"golang.org/x/tools/internal/imports"
+)
+
+// interim code for using the module cache index in imports
+// This code just forwards everything to an imports.ProcessEnvSource
+
+// goplsSource is an imports.Source that provides import information using
+// gopls and the module cache index.
+// TODO(pjw): implement. Right now, this just forwards to the imports.ProcessEnvSource.
+type goplsSource struct {
+	envSource *imports.ProcessEnvSource
+}
+
+func (s *Snapshot) NewGoplsSource(is *imports.ProcessEnvSource) *goplsSource {
+	return &goplsSource{
+		envSource: is,
+	}
+}
+
+func (s *goplsSource) LoadPackageNames(ctx context.Context, srcDir string, paths []imports.ImportPath) (map[imports.ImportPath]imports.PackageName, error) {
+	return s.envSource.LoadPackageNames(ctx, srcDir, paths)
+}
+
+func (s *goplsSource) ResolveReferences(ctx context.Context, filename string, missing imports.References) ([]*imports.Result, error) {
+	return s.envSource.ResolveReferences(ctx, filename, missing)
+}

gopls/internal/cache/view.go

@@ -15,6 +15,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"maps"
 	"os"
 	"os/exec"
 	"path"
@@ -106,8 +107,12 @@ type View struct {
 	// background contexts created for this view.
 	baseCtx context.Context
 
+	// importsState is for the old imports code
 	importsState *importsState
 
+	// maintain the current module cache index
+	modcacheState *modcacheState
+
 	// pkgIndex is an index of package IDs, for efficient storage of typerefs.
 	pkgIndex *typerefs.PackageIndex
 
@@ -1143,9 +1148,7 @@ func (s *Snapshot) ModuleUpgrades(modfile protocol.DocumentURI) map[string]strin
 	defer s.mu.Unlock()
 	upgrades := map[string]string{}
 	orig, _ := s.moduleUpgrades.Get(modfile)
-	for mod, ver := range orig {
-		upgrades[mod] = ver
-	}
+	maps.Copy(upgrades, orig)
 	return upgrades
 }
 

gopls/internal/golang/format.go

@@ -21,6 +21,7 @@ import (
 	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/protocol"
+	"golang.org/x/tools/gopls/internal/settings"
 	"golang.org/x/tools/gopls/internal/util/safetoken"
 	"golang.org/x/tools/internal/diff"
 	"golang.org/x/tools/internal/event"
@@ -120,7 +121,7 @@ func allImportsFixes(ctx context.Context, snapshot *cache.Snapshot, pgf *parsego
 	defer done()
 
 	if err := snapshot.RunProcessEnvFunc(ctx, func(ctx context.Context, opts *imports.Options) error {
-		allFixEdits, editsPerFix, err = computeImportEdits(ctx, pgf, snapshot.View().Folder().Env.GOROOT, opts)
+		allFixEdits, editsPerFix, err = computeImportEdits(ctx, pgf, snapshot, opts)
 		return err
 	}); err != nil {
 		return nil, nil, fmt.Errorf("allImportsFixes: %v", err)
@@ -130,12 +131,22 @@ func allImportsFixes(ctx context.Context, snapshot *cache.Snapshot, pgf *parsego
 
 // computeImportEdits computes a set of edits that perform one or all of the
 // necessary import fixes.
-func computeImportEdits(ctx context.Context, pgf *parsego.File, goroot string, options *imports.Options) (allFixEdits []protocol.TextEdit, editsPerFix []*importFix, err error) {
+func computeImportEdits(ctx context.Context, pgf *parsego.File, snapshot *cache.Snapshot, options *imports.Options) (allFixEdits []protocol.TextEdit, editsPerFix []*importFix, err error) {
+	goroot := snapshot.View().Folder().Env.GOROOT
 	filename := pgf.URI.Path()
 
 	// Build up basic information about the original file.
 	isource, err := imports.NewProcessEnvSource(options.Env, filename, pgf.File.Name.Name)
-	allFixes, err := imports.FixImports(ctx, filename, pgf.Src, goroot, options.Env.Logf, isource)
+	var source imports.Source
+	switch snapshot.Options().ImportsSource {
+	case settings.ImportsSourceGopls:
+		source = snapshot.NewGoplsSource(isource)
+	case settings.ImportsSourceOff: // for cider, which has no file system
+		source = nil
+	case settings.ImportsSourceGoimports:
+		source = isource
+	}
+	allFixes, err := imports.FixImports(ctx, filename, pgf.Src, goroot, options.Env.Logf, source)
 	if err != nil {
 		return nil, nil, err
 	}

gopls/internal/settings/default.go

@@ -39,6 +39,7 @@ func DefaultOptions(overrides ...func(*Options)) *Options {
 				DynamicWatchedFilesSupported:               true,
 				LineFoldingOnly:                            false,
 				HierarchicalDocumentSymbolSupport:          true,
+				ImportsSource:                              ImportsSourceGopls,
 			},
 			ServerOptions: ServerOptions{
 				SupportedCodeActions: map[file.Kind]map[protocol.CodeActionKind]bool{

gopls/internal/settings/settings.go

@@ -53,6 +53,7 @@ type ClientOptions struct {
 	PreferredContentFormat                     protocol.MarkupKind
 	LineFoldingOnly                            bool
 	HierarchicalDocumentSymbolSupport          bool
+	ImportsSource                              ImportsSourceEnum `status:"experimental"`
 	SemanticTypes                              []string
 	SemanticMods                               []string
 	RelatedInformationSupported                bool
@@ -697,6 +698,19 @@ func (s ImportShortcut) ShowDefinition() bool {
 	return s == BothShortcuts || s == DefinitionShortcut
 }
 
+// ImportsSourceEnum has legal values:
+//
+// - `off` to disable searching the file system for imports
+// - `gopls` to use the metadata graph and module cache index
+// - `goimports` for the old behavior, to be deprecated
+type ImportsSourceEnum string
+
+const (
+	ImportsSourceOff       ImportsSourceEnum = "off"
+	ImportsSourceGopls                       = "gopls"
+	ImportsSourceGoimports                   = "goimports"
+)
+
 type Matcher string
 
 const (
@@ -949,6 +963,11 @@ func (o *Options) setOne(name string, value any) error {
 		return setBool(&o.CompleteUnimported, value)
 	case "completionBudget":
 		return setDuration(&o.CompletionBudget, value)
+	case "importsSource":
+		return setEnum(&o.ImportsSource, value,
+			ImportsSourceOff,
+			ImportsSourceGopls,
+			ImportsSourceGoimports)
 	case "matcher":
 		return setEnum(&o.Matcher, value,
 			Fuzzy,
@@ -1033,9 +1052,7 @@ func (o *Options) setOne(name string, value any) error {
 			o.Codelenses = make(map[CodeLensSource]bool)
 		}
 		o.Codelenses = maps.Clone(o.Codelenses)
-		for source, enabled := range lensOverrides {
-			o.Codelenses[source] = enabled
-		}
+		maps.Copy(o.Codelenses, lensOverrides)
 
 		if name == "codelens" {
 			return deprecatedError("codelenses")

internal/imports/fix.go

@@ -927,7 +927,7 @@ type ProcessEnv struct {
 	WorkingDir string
 
 	// If Logf is non-nil, debug logging is enabled through this function.
-	Logf func(format string, args ...interface{})
+	Logf func(format string, args ...any)
 
 	// If set, ModCache holds a shared cache of directory info to use across
 	// multiple ProcessEnvs.