gopls/internal/cache: add missing error check

Also, minor style tweaks:
- use moremaps helpers
- use more informative variable names
- use explicit field names in comp.lit.

Fixes golang/go#74055

Change-Id: I56b27b8c0de491878c955f542d422f8fd6dd9e15
Reviewed-on: https://go-review.googlesource.com/c/tools/+/680258
Reviewed-by: Peter Weinberger <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: adonovan

gopls/internal/cache/source.go

@@ -14,7 +14,7 @@ import (
 	"golang.org/x/tools/gopls/internal/cache/metadata"
 	"golang.org/x/tools/gopls/internal/cache/symbols"
 	"golang.org/x/tools/gopls/internal/protocol"
-	"golang.org/x/tools/internal/event"
+	"golang.org/x/tools/gopls/internal/util/moremaps"
 	"golang.org/x/tools/internal/imports"
 )
 
@@ -136,27 +136,27 @@ func (s *goplsSource) ResolveReferences(ctx context.Context, filename string, mi
 func (s *goplsSource) resolveCacheReferences(missing imports.References) ([]*result, error) {
 	ix, err := s.S.view.ModcacheIndex()
 	if err != nil {
-		event.Error(s.ctx, "resolveCacheReferences", err)
+		return nil, err
 	}
 
 	found := make(map[string]*result)
-	for pkg, nms := range missing {
-		var ks []string
-		for k := range nms {
-			ks = append(ks, k)
-		}
-		cs := ix.LookupAll(pkg, ks...) // map[importPath][]Candidate
-		for k, cands := range cs {
-			res := found[k]
+	for pkgName, nameSet := range missing {
+		names := moremaps.KeySlice(nameSet)
+		for importPath, cands := range ix.LookupAll(pkgName, names...) {
+			res := found[importPath]
 			if res == nil {
 				res = &result{
-					&imports.Result{
-						Import:  &imports.ImportInfo{ImportPath: k},
-						Package: &imports.PackageInfo{Name: pkg, Exports: make(map[string]bool)},
+					res: &imports.Result{
+						Import: &imports.ImportInfo{
+							ImportPath: importPath,
+						},
+						Package: &imports.PackageInfo{
+							Name:    pkgName,
+							Exports: make(map[string]bool)},
 					},
-					false,
+					deprecated: false,
 				}
-				found[k] = res
+				found[importPath] = res
 			}
 			for _, c := range cands {
 				res.res.Package.Exports[c.Name] = true
@@ -166,11 +166,7 @@ func (s *goplsSource) resolveCacheReferences(missing imports.References) ([]*res
 		}
 
 	}
-	var ans []*result
-	for _, x := range found {
-		ans = append(ans, x)
-	}
-	return ans, nil
+	return moremaps.ValueSlice(found), nil
 }
 
 type found struct {

internal/modindex/lookup.go

@@ -36,13 +36,13 @@ const (
 )
 
 // LookupAll only returns those Candidates whose import path
-// finds all the nms.
-func (ix *Index) LookupAll(pkg string, names ...string) map[string][]Candidate {
+// finds all the names.
+func (ix *Index) LookupAll(pkgName string, names ...string) map[string][]Candidate {
 	// this can be made faster when benchmarks show that it needs to be
 	names = uniquify(names)
 	byImpPath := make(map[string][]Candidate)
 	for _, nm := range names {
-		cands := ix.Lookup(pkg, nm, false)
+		cands := ix.Lookup(pkgName, nm, false)
 		for _, c := range cands {
 			byImpPath[c.ImportPath] = append(byImpPath[c.ImportPath], c)
 		}
@@ -67,9 +67,9 @@ func uniquify(in []string) []string {
 
 // Lookup finds all the symbols in the index with the given PkgName and name.
 // If prefix is true, it finds all of these with name as a prefix.
-func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
-	loc, ok := slices.BinarySearchFunc(ix.Entries, pkg, func(e Entry, pkg string) int {
-		return strings.Compare(e.PkgName, pkg)
+func (ix *Index) Lookup(pkgName, name string, prefix bool) []Candidate {
+	loc, ok := slices.BinarySearchFunc(ix.Entries, pkgName, func(e Entry, pkg string) int {
+		return strings.Compare(e.PkgName, pkgName)
 	})
 	if !ok {
 		return nil // didn't find the package
@@ -78,7 +78,7 @@ func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
 	// loc is the first entry for this package name, but there may be several
 	for i := loc; i < len(ix.Entries); i++ {
 		e := ix.Entries[i]
-		if e.PkgName != pkg {
+		if e.PkgName != pkgName {
 			break // end of sorted package names
 		}
 		nloc, ok := slices.BinarySearchFunc(e.Names, name, func(s string, name string) int {
@@ -105,7 +105,7 @@ func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
 				continue // should never happen
 			}
 			px := Candidate{
-				PkgName:    pkg,
+				PkgName:    pkgName,
 				Name:       flds[0],
 				Dir:        string(e.Dir),
 				ImportPath: e.ImportPath,