gopls: use new gomodcache index

This CL changes the default for 'importsSource' to 'gopls',
so that imports and unimpoted completions will use the GOMODCACHE
index.

One test had to be changed, and there is a benchmark, with some data.
(On unimported completions from the module cache, the new code is
more than 10 times faster, and always succeeds where the old code
sometimes failed.)

Change-Id: Ie5c8001ac1292498b72e5b42b51b4fcb06ab6fa9
Reviewed-on: https://go-review.googlesource.com/c/tools/+/678475
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

Author: pjweinbgo

gopls/doc/release/v0.19.0.md

@@ -173,3 +173,15 @@ func f(x int) {
 	println(fmt.Sprintf("+%d", x))
 }
 ```
+
+## Use index for GOMODCACHE in imports and unimported completions
+
+The default for the option `importsSource` changes from "goimports" to "gopls".
+This has the effect of building and maintaining an index to
+the packages in GOMODCACHE.
+The index is stored in the directory `os.UserCacheDir()/go/imports`.
+Users who want the old behavior can change the option back. Users who don't
+the module cache used at all for imports or completions
+can change the option to
+"off". The new code is many times faster than the old when accessing the
+module cache.

gopls/internal/golang/completion/unimported.go

@@ -52,21 +52,6 @@ func (c *completer) unimported(ctx context.Context, pkgname metadata.PackageName
 		}
 	}
 	// do the stdlib next.
-	// For now, use the workspace version of stdlib packages
-	// to get function snippets. CL 665335 will fix this.
-	var x []metadata.PackageID
-	for _, mp := range stdpkgs {
-		if slices.Contains(wsIDs, metadata.PackageID(mp)) {
-			x = append(x, metadata.PackageID(mp))
-		}
-	}
-	if len(x) > 0 {
-		items := c.pkgIDmatches(ctx, x, pkgname, prefix)
-		if c.scoreList(items) {
-			return
-		}
-	}
-	// just use the stdlib
 	items := c.stdlibMatches(stdpkgs, pkgname, prefix)
 	if c.scoreList(items) {
 		return
@@ -164,7 +149,7 @@ func (c *completer) pkgIDmatches(ctx context.Context, ids []metadata.PackageID,
 					}
 					kind = protocol.FunctionCompletion
 					detail = fmt.Sprintf("func (from %q)", pkg.PkgPath)
-				case protocol.Variable:
+				case protocol.Variable, protocol.Struct:
 					kind = protocol.VariableCompletion
 					detail = fmt.Sprintf("var (from %q)", pkg.PkgPath)
 				case protocol.Constant:
@@ -264,6 +249,9 @@ func (c *completer) modcacheMatches(pkg metadata.PackageName, prefix string) ([]
 		case modindex.Const:
 			kind = protocol.ConstantCompletion
 			detail = fmt.Sprintf("const (from %s)", cand.ImportPath)
+		case modindex.Type: // might be a type alias
+			kind = protocol.VariableCompletion
+			detail = fmt.Sprintf("type (from %s)", cand.ImportPath)
 		default:
 			continue
 		}

gopls/internal/settings/default.go

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

gopls/internal/test/integration/bench/unimported_test.go

@@ -0,0 +1,161 @@
+// 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 bench
+
+import (
+	"context"
+	"fmt"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	. "golang.org/x/tools/gopls/internal/test/integration"
+	"golang.org/x/tools/gopls/internal/test/integration/fake"
+	"golang.org/x/tools/internal/modindex"
+)
+
+// experiments show the new code about 15 times faster than the old,
+// and the old code sometimes fails to find the completion
+func BenchmarkLocalModcache(b *testing.B) {
+	budgets := []string{"0s", "100ms", "200ms", "500ms", "1s", "5s"}
+	sources := []string{"gopls", "goimports"}
+	for _, budget := range budgets {
+		b.Run(fmt.Sprintf("budget=%s", budget), func(b *testing.B) {
+			for _, source := range sources {
+				b.Run(fmt.Sprintf("source=%s", source), func(b *testing.B) {
+					runModcacheCompletion(b, budget, source)
+				})
+			}
+		})
+	}
+}
+
+func runModcacheCompletion(b *testing.B, budget, source string) {
+	// First set up the program to be edited
+	gomod := `
+module mod.com
+
+go 1.21
+`
+	pat := `
+package main
+var _ = %s.%s
+`
+	pkg, name, modcache := findSym(b)
+	name, _, _ = strings.Cut(name, " ")
+	mainfile := fmt.Sprintf(pat, pkg, name)
+	// Second, create the Env and start gopls
+	dir := getTempDir()
+	if err := os.Mkdir(dir, 0750); err != nil {
+		if !os.IsExist(err) {
+			b.Fatal(err)
+		}
+	}
+	defer os.RemoveAll(dir) // is this right? needed?
+	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte(gomod), 0644); err != nil {
+		b.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "main.go"), []byte(mainfile), 0644); err != nil {
+		b.Fatal(err)
+	}
+	ts, err := newGoplsConnector(nil)
+	if err != nil {
+		b.Fatal(err)
+	}
+	// PJW: put better EditorConfig here
+	envvars := map[string]string{
+		"GOMODCACHE": modcache,
+		//"GOPATH":     sandbox.GOPATH(), // do we need a GOPATH?
+	}
+	fc := fake.EditorConfig{
+		Env: envvars,
+		Settings: map[string]any{
+			"completeUnimported": true,
+			"completionBudget":   budget, // "0s", "100ms"
+			"importsSource":      source, // "gopls" or "goimports"
+		},
+	}
+	sandbox, editor, awaiter, err := connectEditor(dir, fc, ts)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer sandbox.Close()
+	defer editor.Close(context.Background())
+	if err := awaiter.Await(context.Background(), InitialWorkspaceLoad); err != nil {
+		b.Fatal(err)
+	}
+	env := &Env{
+		TB:      b,
+		Ctx:     context.Background(),
+		Editor:  editor,
+		Sandbox: sandbox,
+		Awaiter: awaiter,
+	}
+	// Check that completion works as expected
+	env.CreateBuffer("main.go", mainfile)
+	env.AfterChange()
+	if false { // warm up? or not?
+		loc := env.RegexpSearch("main.go", name)
+		completions := env.Completion(loc)
+		if len(completions.Items) == 0 {
+			b.Fatal("no completions")
+		}
+	}
+
+	// run benchmark
+	for b.Loop() {
+		loc := env.RegexpSearch("main.go", name)
+		env.Completion(loc)
+	}
+}
+
+// find some symbol in the module cache
+func findSym(t testing.TB) (pkg, name, gomodcache string) {
+	initForTest(t)
+	cmd := exec.Command("go", "env", "GOMODCACHE")
+	out, err := cmd.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	modcache := strings.TrimSpace(string(out))
+	ix, err := modindex.ReadIndex(modcache)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ix == nil {
+		t.Fatal("no index")
+	}
+	if len(ix.Entries) == 0 {
+		t.Fatal("no entries")
+	}
+	nth := 100 // or something
+	for _, e := range ix.Entries {
+		if token.IsExported(e.PkgName) || strings.HasPrefix(e.PkgName, "_") {
+			continue // weird stuff in module cache
+		}
+
+		for _, nm := range e.Names {
+			nth--
+			if nth == 0 {
+				return e.PkgName, nm, modcache
+			}
+		}
+	}
+	t.Fatalf("index doesn't have enough usable names, need another %d", nth)
+	return "", "", modcache
+}
+
+// Set IndexDir, avoiding the special case for tests,
+func initForTest(t testing.TB) {
+	dir, err := os.UserCacheDir()
+	if err != nil {
+		t.Fatalf("os.UserCacheDir: %v", err)
+	}
+	dir = filepath.Join(dir, "go", "imports")
+	modindex.IndexDir = dir
+}

gopls/internal/test/marker/testdata/completion/issue62676.txt

@@ -53,7 +53,7 @@ import "os"
 
 func _() {
 	// This uses goimports-based completion; TODO: this should insert snippets.
-	os.Open //@acceptcompletion(re"Open()", "Open", open)
+	os.Open(${1:}) //@acceptcompletion(re"Open()", "Open", open)
 }
 
 func _() {