internal/modindex: add LookupAll(pkg, names)

The new function LookupAll returns a map from
import paths to []Candidate, where the []Candidate
contains all the names.

This improves the current situation where the caller
of Lookup() has to figure out if all the missing
names have been found.

Also, the parallelism while building a new index
is now limited to half the number of cpus.

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

Author: pjweinbgo

internal/modindex/lookup.go

@@ -35,6 +35,36 @@ const (
 	Func
 )
 
+// LookupAll only returns those Candidates whose import path
+// finds all the nms.
+func (ix *Index) LookupAll(pkg 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)
+		for _, c := range cands {
+			byImpPath[c.ImportPath] = append(byImpPath[c.ImportPath], c)
+		}
+	}
+	for k, v := range byImpPath {
+		if len(v) != len(names) {
+			delete(byImpPath, k)
+		}
+	}
+	return byImpPath
+}
+
+// remove duplicates
+func uniquify(in []string) []string {
+	if len(in) == 0 {
+		return in
+	}
+	in = slices.Clone(in)
+	slices.Sort(in)
+	return slices.Compact(in)
+}
+
 // 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 {

internal/modindex/lookup_test.go

@@ -68,7 +68,6 @@ func okresult(r result, p Candidate) bool {
 }
 
 func TestLookup(t *testing.T) {
-	log.SetFlags(log.Lshortfile)
 	dir := testModCache(t)
 	wrtData(t, dir, thedata)
 	if _, err := indexModCache(dir, true); err != nil {
@@ -133,3 +132,67 @@ func wrtData(t *testing.T, dir string, data tdata) {
 		fd.WriteString(item.code + "\n")
 	}
 }
+
+func TestLookupAll(t *testing.T) {
+	log.SetFlags(log.Lshortfile)
+	dir := testModCache(t)
+	wrtModule := func(mod string, nms ...string) {
+		dname := filepath.Join(dir, mod)
+		if err := os.MkdirAll(dname, 0755); err != nil {
+			t.Fatal(err)
+		}
+		fname := filepath.Join(dname, "foo.go")
+		fd, err := os.Create(fname)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer fd.Close()
+		if _, err := fd.WriteString(fmt.Sprintf("package foo\n")); err != nil {
+			t.Fatal(err)
+		}
+		for _, nm := range nms {
+			fd.WriteString(fmt.Sprintf("func %s() {}\n", nm))
+		}
+	}
+	wrtModule("a.com/go/[email protected]", "A", "B", "C", "D")
+	wrtModule("b.com/go/[email protected]", "A", "B", "C")
+	wrtModule("c.com/go/[email protected]", "A", "B", "C", "D", "E")
+
+	if _, err := indexModCache(dir, true); err != nil {
+		t.Fatal(err)
+	}
+	ix, err := ReadIndex(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cands := ix.Lookup("foo", "A", false)
+	if len(cands) != 3 {
+		t.Errorf("got %d candidates for A, expected 3", len(cands))
+	}
+	got := ix.LookupAll("foo", "A", "B", "C", "D")
+	if len(got) != 2 {
+		t.Errorf("got %d candidates for A,B,C,D, expected 2", len(got))
+	}
+	got = ix.LookupAll("foo", []string{"A", "B", "C", "D", "E"}...)
+	if len(got) != 1 {
+		t.Errorf("got %d candidates for A,B,C,D,E, expected 1", len(got))
+	}
+}
+
+func TestUniquify(t *testing.T) {
+	var v []string
+	for i := 1; i < 4; i++ {
+		v = append(v, "A")
+		w := uniquify(v)
+		if len(w) != 1 {
+			t.Errorf("got %d, expected 1", len(w))
+		}
+	}
+	for i := 1; i < 3; i++ {
+		v = append(v, "B", "C")
+		w := uniquify(v)
+		if len(w) != 3 {
+			t.Errorf("got %d, expected 3", len(w))
+		}
+	}
+}

internal/modindex/symbols.go

@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strings"
 
@@ -29,14 +30,14 @@ import (
 type symbol struct {
 	pkg  string // name of the symbols's package
 	name string // declared name
-	kind string // T, C, V, or F
+	kind string // T, C, V, or F, follwed by D if deprecated
 	sig  string // signature information, for F
 }
 
 // find the symbols for the best directories
 func getSymbols(cd Abspath, dirs map[string][]*directory) {
 	var g errgroup.Group
-	g.SetLimit(-1) // maybe throttle this some day
+	g.SetLimit(max(2, runtime.GOMAXPROCS(0)/2))
 	for _, vv := range dirs {
 		// throttling some day?
 		d := vv[0]
@@ -111,7 +112,7 @@ func getFileExports(f *ast.File) []symbol {
 				// print struct tags. So for this to happen the type of a formal parameter
 				// has to be a explict struct, e.g. foo(x struct{a int "$"}) and ExprString
 				// would have to show the struct tag. Even testing for this case seems
-				// a waste of effort, but let's not ignore such pathologies
+				// a waste of effort, but let's remember the possibility
 				if strings.Contains(tp, "$") {
 					continue
 				}