internal/astutil/free: move inline.freeishNames into its own package

We'll need it in the analysis driver to remove unneeded imports
as part of the attached issue.

For golang/go#72035

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

Author: adonovan

internal/refactor/inline/free.go renamed to internal/astutil/free/free.go

@@ -2,18 +2,22 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Copied, with considerable changes, from go/parser/resolver.go
-// at af53bd2c03.
-
-package inline
+// Package free defines utilities for computing the free variables of
+// a syntax tree without type information. This is inherently
+// heuristic because of the T{f: x} ambiguity, in which f may or may
+// not be a lexical reference depending on whether T is a struct type.
+package free
 
 import (
 	"go/ast"
 	"go/token"
 )
 
-// freeishNames computes an approximation to the free names of the AST
-// at node n based solely on syntax, inserting values into the map.
+// Copied, with considerable changes, from go/parser/resolver.go
+// at af53bd2c03.
+
+// Names computes an approximation to the set of free names of the AST
+// at node n based solely on syntax.
 //
 // In the absence of composite literals, the set of free names is exact. Composite
 // literals introduce an ambiguity that can only be resolved with type information:
@@ -33,16 +37,22 @@ import (
 //   - Labels are ignored: they do not refer to values.
 //   - This is never called on FuncDecls or ImportSpecs, so the function
 //     panics if it sees one.
-func freeishNames(free map[string]bool, n ast.Node, includeComplitIdents bool) {
-	v := &freeVisitor{free: free, includeComplitIdents: includeComplitIdents}
+func Names(n ast.Node, includeComplitIdents bool) map[string]bool {
+	v := &freeVisitor{
+		free:                 make(map[string]bool),
+		includeComplitIdents: includeComplitIdents,
+	}
 	// Begin with a scope, even though n might not be a form that establishes a scope.
 	// For example, n might be:
 	//    x := ...
 	// Then we need to add the first x to some scope.
 	v.openScope()
 	ast.Walk(v, n)
 	v.closeScope()
-	assert(v.scope == nil, "unbalanced scopes")
+	if v.scope != nil {
+		panic("unbalanced scopes")
+	}
+	return v.free
 }
 
 // A freeVisitor holds state for a free-name analysis.

internal/refactor/inline/free_test.go renamed to internal/astutil/free/free_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package inline
+package free_test
 
 import (
 	"fmt"
@@ -13,9 +13,11 @@ import (
 	"slices"
 	"strings"
 	"testing"
+
+	"golang.org/x/tools/internal/astutil/free"
 )
 
-func TestFreeishNames(t *testing.T) {
+func TestNames(t *testing.T) {
 	elems := func(m map[string]bool) string {
 		return strings.Join(slices.Sorted(maps.Keys(m)), " ")
 	}
@@ -213,13 +215,12 @@ func TestFreeishNames(t *testing.T) {
 			for _, test := range tc.cases {
 				_, f := mustParse(t, "free.go", `package p; func _() {`+test.code+`}`)
 				n := f.Decls[0].(*ast.FuncDecl).Body
-				got := map[string]bool{}
 				want := map[string]bool{}
 				for n := range strings.FieldsSeq(test.want) {
 					want[n] = true
 				}
 
-				freeishNames(got, n, tc.includeComplitIdents)
+				got := free.Names(n, tc.includeComplitIdents)
 
 				if !maps.Equal(got, want) {
 					t.Errorf("\ncode  %s\ngot   %v\nwant  %v", test.code, elems(got), elems(want))
@@ -229,12 +230,12 @@ func TestFreeishNames(t *testing.T) {
 	}
 }
 
-func TestFreeishNamesScope(t *testing.T) {
+func TestFreeNames_scope(t *testing.T) {
 	// Verify that inputs that don't start a scope don't crash.
 	_, f := mustParse(t, "free.go", `package p; func _() { x := 1; _ = x }`)
 	// Select the short var decl, not the entire function body.
 	n := f.Decls[0].(*ast.FuncDecl).Body.List[0]
-	freeishNames(map[string]bool{}, n, false)
+	_ = free.Names(n, false)
 }
 
 func mustParse(t *testing.T, filename string, content any) (*token.FileSet, *ast.File) {

internal/refactor/inline/inline.go

@@ -24,6 +24,7 @@ import (
 	"golang.org/x/tools/go/ast/astutil"
 	"golang.org/x/tools/go/types/typeutil"
 	internalastutil "golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/astutil/free"
 	"golang.org/x/tools/internal/packagepath"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/typesinternal"
@@ -575,9 +576,8 @@ func (i *importState) localName(pkgPath, pkgName string, shadow shadowMap) strin
 // Since they are not relevant to removing unused imports, we instruct
 // freeishNames to omit composite-literal keys that are identifiers.
 func trimNewImports(newImports []newImport, new ast.Node) []newImport {
-	free := map[string]bool{}
 	const omitComplitIdents = false
-	freeishNames(free, new, omitComplitIdents)
+	free := free.Names(new, omitComplitIdents)
 	var res []newImport
 	for _, ni := range newImports {
 		if free[ni.pkgName] {
@@ -2388,14 +2388,13 @@ func createBindingDecl(logf logger, caller *Caller, args []*argument, calleeDecl
 		// (caller syntax), so we can use type info.
 		// But Type is the untyped callee syntax,
 		// so we have to use a syntax-only algorithm.
-		free := make(map[string]bool)
+		const includeComplitIdents = true
+		free := free.Names(spec.Type, includeComplitIdents)
 		for _, value := range spec.Values {
 			for name := range freeVars(caller.Info, value) {
 				free[name] = true
 			}
 		}
-		const includeComplitIdents = true
-		freeishNames(free, spec.Type, includeComplitIdents)
 		for name := range free {
 			if names[name] {
 				logf("binding decl would shadow free name %q", name)
@@ -3456,7 +3455,7 @@ func (st *state) assignStmts(callerStmt *ast.AssignStmt, returnOperands []ast.Ex
 			assert(callIdx == -1, "malformed (duplicative) AST")
 			callIdx = i
 			for j, returnOperand := range returnOperands {
-				freeishNames(freeNames, returnOperand, includeComplitIdents)
+				maps.Copy(freeNames, free.Names(returnOperand, includeComplitIdents))
 				rhs = append(rhs, returnOperand)
 				if resultInfo[j]&nonTrivialResult != 0 {
 					nonTrivial[i+j] = true
@@ -3469,7 +3468,7 @@ func (st *state) assignStmts(callerStmt *ast.AssignStmt, returnOperands []ast.Ex
 			// We must clone before clearing positions, since e came from the caller.
 			expr = internalastutil.CloneNode(expr)
 			clearPositions(expr)
-			freeishNames(freeNames, expr, includeComplitIdents)
+			maps.Copy(freeNames, free.Names(expr, includeComplitIdents))
 			rhs = append(rhs, expr)
 		}
 	}