gopls/completion: unimported completions with explicit package names

If a user types foo., and foo is not a package already imported in the
current file, the unimported completion code searches for the
package foo in a number of places. If it fails to find it, the new
code looks in the current module for an import like
import foo "package-path-for-bar"
and tries to satisfy the completion from package bar. If it can,
it will also add a suitable import statement.

Related: golang/go#40278 golang/go#74918
Change-Id: I5345a7d1a23fa240c468b9b21b2e9bcddf27c770
Reviewed-on: https://go-review.googlesource.com/c/tools/+/698578
Reviewed-by: Madeline Kalil <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: pjweinbgo

gopls/internal/golang/completion/unimported.go

@@ -18,7 +18,8 @@ package completion
 // 1. the imports of some other file of the current package,
 // 2. the standard library,
 // 3. the imports of some other file in the current workspace,
-// 4. the module cache.
+// 4. imports in the current module with 'foo' as the explicit package name,
+// 5. the module cache,
 // It stops at the first success.
 
 import (
@@ -63,11 +64,47 @@ func (c *completer) unimported(ctx context.Context, pkgname metadata.PackageName
 		return
 	}
 
-	// look in the module cache, for the last chance
+	// before looking in the module cache, maybe it is an explicit
+	// package name used in this module
+	if c.explicitPkgName(ctx, pkgname, prefix) {
+		return
+	}
+
+	// look in the module cache
 	items, err := c.modcacheMatches(pkgname, prefix)
-	if err == nil {
-		c.scoreList(items)
+	if err == nil && c.scoreList(items) {
+		return
+	}
+
+	// out of things to do
+}
+
+// see if some file in the current package satisfied a foo. import
+// because foo is an explicit package name (import foo "a.b.c")
+func (c *completer) explicitPkgName(ctx context.Context, pkgname metadata.PackageName, prefix string) bool {
+	for _, pgf := range c.pkg.CompiledGoFiles() {
+		imports := pgf.File.Imports
+		for _, imp := range imports {
+			if imp.Name != nil && imp.Name.Name == string(pkgname) {
+				path := strings.Trim(imp.Path.Value, `"`)
+				if c.tryPath(ctx, metadata.PackagePath(path), string(pkgname), prefix) {
+					return true // one is enough
+				}
+			}
+		}
+	}
+	return false
+}
+
+// see if this path contains a usable import with explict package name
+func (c *completer) tryPath(ctx context.Context, path metadata.PackagePath, pkgname, prefix string) bool {
+	packages := c.snapshot.MetadataGraph().ForPackagePath
+	ids := []metadata.PackageID{}
+	for _, pkg := range packages[path] { // could there ever be more than one?
+		ids = append(ids, pkg.ID) // pkg.ID. ID: "math/rand" but Name: "rand"
 	}
+	items := c.pkgIDmatches(ctx, ids, metadata.PackageName(pkgname), prefix)
+	return c.scoreList(items)
 }
 
 // find all the packageIDs for packages in the workspace that have the desired name

gopls/internal/test/integration/completion/completion_test.go

@@ -1461,3 +1461,37 @@ func main() {
 		}
 	})
 }
+
+// find import foo "bar" for foo.xxx
+func TestImportAlias(t *testing.T) {
+	testenv.NeedsGoCommand1Point(t, 22) // we will find math/rand/v2
+	const files = `
+-- a.go --
+package x
+var _ = xrand.
+-- b.go --
+package x
+
+import xrand "math/rand"
+
+var _ = xrand.Int()
+
+-- go.mod --
+module foo.com
+
+go 1.24.2
+`
+	Run(t, files, func(t *testing.T, env *Env) {
+		env.OpenFile("a.go")
+		env.Await(env.DoneWithOpen())
+		loc := env.RegexpSearch("a.go", "xrand.()")
+		compls := env.Completion(loc)
+		if len(compls.Items) == 0 {
+			t.Fatal("no completions")
+		}
+		one := compls.Items[0].AdditionalTextEdits[0].NewText
+		if one != "\nimport xrand \"math/rand\"\n" {
+			t.Errorf("wrong import %q", one)
+		}
+	})
+}

gopls/internal/test/integration/completion/fixedbugs_test.go

@@ -21,7 +21,7 @@ module example.com
 
 go 1.18
 -- playdos/play.go --
-package  
+package   // comment (to preserve spaces)
 `
 
 	Run(t, files, func(t *testing.T, env *Env) {