gopls/internal/lsp/cache: improve precision of cache key

Use the new typerefs algorithm to improve the precision of our cache
key, by excluding from the package key any dependencies that are known
not to affect the results of type-checking.

This makes building the package key more expensive. In particular, we
must be more careful to avoid duplicate building of package keys due to
races. To address this concern, the evaluation of package handles is
turned a concurrent batch operation.

Also fix a few bugs/oversights in the typerefs package encountered while
using gopls built with this change.

For golang/go#57987

Change-Id: Iec6d183b91dcd1223db0f6b64ca5231d42975c3e
Reviewed-on: https://go-review.googlesource.com/c/tools/+/477455
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Robert Findley <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
gopls-CI: kokoro <[email protected]>

Author: findleyr

gopls/internal/astutil/util.go

@@ -0,0 +1,61 @@
+// Copyright 2023 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 astutil
+
+import (
+	"go/ast"
+
+	"golang.org/x/tools/internal/typeparams"
+)
+
+// UnpackRecv unpacks a receiver type expression, reporting whether it is a
+// pointer recever, along with the type name identifier and any receiver type
+// parameter identifiers.
+//
+// Copied (with modifications) from go/types.
+func UnpackRecv(rtyp ast.Expr) (ptr bool, rname *ast.Ident, tparams []*ast.Ident) {
+L: // unpack receiver type
+	// This accepts invalid receivers such as ***T and does not
+	// work for other invalid receivers, but we don't care. The
+	// validity of receiver expressions is checked elsewhere.
+	for {
+		switch t := rtyp.(type) {
+		case *ast.ParenExpr:
+			rtyp = t.X
+		case *ast.StarExpr:
+			ptr = true
+			rtyp = t.X
+		default:
+			break L
+		}
+	}
+
+	// unpack type parameters, if any
+	switch rtyp.(type) {
+	case *ast.IndexExpr, *typeparams.IndexListExpr:
+		var indices []ast.Expr
+		rtyp, _, indices, _ = typeparams.UnpackIndexExpr(rtyp)
+		for _, arg := range indices {
+			var par *ast.Ident
+			switch arg := arg.(type) {
+			case *ast.Ident:
+				par = arg
+			default:
+				// ignore errors
+			}
+			if par == nil {
+				par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
+			}
+			tparams = append(tparams, par)
+		}
+	}
+
+	// unpack receiver name
+	if name, _ := rtyp.(*ast.Ident); name != nil {
+		rname = name
+	}
+
+	return
+}