internal/analysisinternal: move more stuff out

- CanImport, IsStdPackage -> internal/packagepath,
  a new package for package metadata stuff.
- MatchingIdents -> gopls/internal/fillreturns,
  shared with fillstruct.

The remaining decs are all analysis related, but they
straddle the driver/analyzer divide, which is not great.
(A driver shouldn't per se depend on 'refactor', for example.)
I propose to split the remains into internal/analysisdriver
and internal/analyzerlib.

Change-Id: Ia981b14becedbf874367daed91f55e0a237ae773
Reviewed-on: https://go-review.googlesource.com/c/tools/+/710795
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Robert Findley <rfindley@google.com>
Auto-Submit: Alan Donovan <adonovan@google.com>

Author: adonovan

go/analysis/passes/inline/gofix.go

@@ -23,6 +23,7 @@ import (
 	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/diff"
+	"golang.org/x/tools/internal/packagepath"
 	"golang.org/x/tools/internal/refactor"
 	"golang.org/x/tools/internal/refactor/inline"
 	"golang.org/x/tools/internal/typesinternal"
@@ -282,7 +283,7 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, curId inspector.Cursor) {
 			if obj != tn {
 				return
 			}
-		} else if !analysisinternal.CanImport(a.pass.Pkg.Path(), pkgPath) {
+		} else if !packagepath.CanImport(a.pass.Pkg.Path(), pkgPath) {
 			// If this package can't see the package of this part of rhs, we can't inline.
 			return
 		} else if _, ok := importPrefixes[pkgPath]; !ok {
@@ -450,7 +451,7 @@ func (a *analyzer) inlineConst(con *types.Const, cur inspector.Cursor) {
 			// "B" means something different here than at the inlinable const's scope.
 			return
 		}
-	} else if !analysisinternal.CanImport(a.pass.Pkg.Path(), incon.RHSPkgPath) {
+	} else if !packagepath.CanImport(a.pass.Pkg.Path(), incon.RHSPkgPath) {
 		// If this package can't see the RHS's package, we can't inline.
 		return
 	}

go/analysis/passes/modernize/modernize.go

@@ -18,10 +18,10 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/ast/edge"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/analysisinternal/generated"
 	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/moreiters"
+	"golang.org/x/tools/internal/packagepath"
 	"golang.org/x/tools/internal/stdlib"
 	"golang.org/x/tools/internal/typesinternal"
 	"golang.org/x/tools/internal/versions"
@@ -124,7 +124,7 @@ func fileUses(info *types.Info, file *ast.File, version string) bool {
 // specified standard packages or their dependencies.
 func within(pass *analysis.Pass, pkgs ...string) bool {
 	path := pass.Pkg.Path()
-	return analysisinternal.IsStdPackage(path) &&
+	return packagepath.IsStdPackage(path) &&
 		moreiters.Contains(stdlib.Dependencies(pkgs...), path)
 }
 

gopls/internal/analysis/fillreturns/fillreturns.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/format"
+	"go/token"
 	"go/types"
 	"regexp"
 	"slices"
@@ -112,7 +113,7 @@ outer:
 		}
 
 		file, _ := cursorutil.FirstEnclosing[*ast.File](curRet)
-		matches := analysisinternal.MatchingIdents(retTyps, file, ret.Pos(), info, pass.Pkg)
+		matches := MatchingIdents(retTyps, file, ret.Pos(), info, pass.Pkg)
 		qual := typesinternal.FileQualifier(file, pass.Pkg)
 		for i, retTyp := range retTyps {
 			var match ast.Expr
@@ -242,3 +243,95 @@ func isZeroExpr(expr ast.Expr) bool {
 		return false
 	}
 }
+
+// MatchingIdents finds the names of all identifiers in 'node' that match any of the given types.
+// 'pos' represents the position at which the identifiers may be inserted. 'pos' must be within
+// the scope of each of identifier we select. Otherwise, we will insert a variable at 'pos' that
+// is unrecognized.
+//
+// This function is shared with the 'fillstruct' analyzer.
+func MatchingIdents(typs []types.Type, node ast.Node, pos token.Pos, info *types.Info, pkg *types.Package) map[types.Type][]string {
+
+	// Initialize matches to contain the variable types we are searching for.
+	matches := make(map[types.Type][]string)
+	for _, typ := range typs {
+		if typ == nil {
+			continue // TODO(adonovan): is this reachable?
+		}
+		matches[typ] = nil // create entry
+	}
+
+	seen := map[types.Object]struct{}{}
+	ast.Inspect(node, func(n ast.Node) bool {
+		if n == nil {
+			return false
+		}
+		// Prevent circular definitions. If 'pos' is within an assignment statement, do not
+		// allow any identifiers in that assignment statement to be selected. Otherwise,
+		// we could do the following, where 'x' satisfies the type of 'f0':
+		//
+		// x := fakeStruct{f0: x}
+		//
+		if assign, ok := n.(*ast.AssignStmt); ok && pos > assign.Pos() && pos <= assign.End() {
+			return false
+		}
+		if n.End() > pos {
+			return n.Pos() <= pos
+		}
+		ident, ok := n.(*ast.Ident)
+		if !ok || ident.Name == "_" {
+			return true
+		}
+		obj := info.Defs[ident]
+		if obj == nil || obj.Type() == nil {
+			return true
+		}
+		if _, ok := obj.(*types.TypeName); ok {
+			return true
+		}
+		// Prevent duplicates in matches' values.
+		if _, ok = seen[obj]; ok {
+			return true
+		}
+		seen[obj] = struct{}{}
+		// Find the scope for the given position. Then, check whether the object
+		// exists within the scope.
+		innerScope := pkg.Scope().Innermost(pos)
+		if innerScope == nil {
+			return true
+		}
+		_, foundObj := innerScope.LookupParent(ident.Name, pos)
+		if foundObj != obj {
+			return true
+		}
+		// The object must match one of the types that we are searching for.
+		// TODO(adonovan): opt: use typeutil.Map?
+		if names, ok := matches[obj.Type()]; ok {
+			matches[obj.Type()] = append(names, ident.Name)
+		} else {
+			// If the object type does not exactly match
+			// any of the target types, greedily find the first
+			// target type that the object type can satisfy.
+			for typ := range matches {
+				if equivalentTypes(obj.Type(), typ) {
+					matches[typ] = append(matches[typ], ident.Name)
+				}
+			}
+		}
+		return true
+	})
+	return matches
+}
+
+func equivalentTypes(want, got types.Type) bool {
+	if types.Identical(want, got) {
+		return true
+	}
+	// Code segment to help check for untyped equality from (golang/go#32146).
+	if rhs, ok := want.(*types.Basic); ok && rhs.Info()&types.IsUntyped > 0 {
+		if lhs, ok := got.Underlying().(*types.Basic); ok {
+			return rhs.Info()&types.IsConstType == lhs.Info()&types.IsConstType
+		}
+	}
+	return types.AssignableTo(want, got)
+}

gopls/internal/analysis/fillstruct/fillstruct.go

@@ -24,12 +24,12 @@ import (
 	"unicode"
 
 	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/gopls/internal/analysis/fillreturns"
 	"golang.org/x/tools/gopls/internal/cache"
 	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/fuzzy"
 	"golang.org/x/tools/gopls/internal/util/cursorutil"
 	"golang.org/x/tools/gopls/internal/util/safetoken"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/typesinternal"
 )
@@ -183,7 +183,7 @@ func SuggestedFix(cpkg *cache.Package, pgf *parsego.File, start, end token.Pos)
 		}
 		fieldTyps = append(fieldTyps, field.Type())
 	}
-	matches := analysisinternal.MatchingIdents(fieldTyps, file, start, info, pkg)
+	matches := fillreturns.MatchingIdents(fieldTyps, file, start, info, pkg)
 	qual := typesinternal.FileQualifier(file, pkg)
 
 	for i, fieldTyp := range fieldTyps {

gopls/internal/analysis/unusedfunc/unusedfunc.go

@@ -19,6 +19,7 @@ import (
 	"golang.org/x/tools/internal/analysisinternal"
 	typeindexanalyzer "golang.org/x/tools/internal/analysisinternal/typeindex"
 	"golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/packagepath"
 	"golang.org/x/tools/internal/typesinternal/typeindex"
 )
 
@@ -70,7 +71,7 @@ var Analyzer = &analysis.Analyzer{
 func run(pass *analysis.Pass) (any, error) {
 	// The standard library makes heavy use of intrinsics, linknames, etc,
 	// that confuse this algorithm; so skip it (#74130).
-	if analysisinternal.IsStdPackage(pass.Pkg.Path()) {
+	if packagepath.IsStdPackage(pass.Pkg.Path()) {
 		return nil, nil
 	}
 

gopls/internal/golang/completion/deep_completion.go

@@ -11,7 +11,7 @@ import (
 	"time"
 
 	"golang.org/x/tools/gopls/internal/util/typesutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/packagepath"
 )
 
 // MaxDeepCompletions limits deep completion results because in most cases
@@ -162,7 +162,7 @@ func (c *completer) deepSearch(ctx context.Context, minDepth int, deadline *time
 				continue
 			}
 
-			if cand.imp != nil && !analysisinternal.CanImport(string(c.pkg.Metadata().PkgPath), cand.imp.importPath) {
+			if cand.imp != nil && !packagepath.CanImport(string(c.pkg.Metadata().PkgPath), cand.imp.importPath) {
 				continue // inaccessible internal package
 			}
 

gopls/internal/mcp/context.go

@@ -23,8 +23,8 @@ import (
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/golang"
 	"golang.org/x/tools/gopls/internal/protocol"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/packagepath"
 )
 
 type ContextParams struct {
@@ -108,7 +108,7 @@ func (h *handler) contextHandler(ctx context.Context, req *mcp.CallToolRequest,
 			// Skip the standard library to reduce token usage, operating on
 			// the assumption that the LLM is already familiar with its
 			// symbols and documentation.
-			if analysisinternal.IsStdPackage(spec.Path.Value) {
+			if packagepath.IsStdPackage(spec.Path.Value) {
 				continue
 			}
 			toSummarize = append(toSummarize, spec)