internal/typeparams: factor 2 copies of isParameterized

The typeparams.Free.Has(T) method reports whether type T
has free type parameters. It factors two copies of this
algorithm, themselves copied from go/types.

Change-Id: I285e26ba82b28ca0a3ddbd956fa75e342a0dc22d
Reviewed-on: https://go-review.googlesource.com/c/tools/+/573135
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Tim King <[email protected]>
Auto-Submit: Alan Donovan <[email protected]>
Commit-Queue: Alan Donovan <[email protected]>

Author: adonovan

go/analysis/passes/ifaceassert/ifaceassert.go

@@ -13,6 +13,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
+	"golang.org/x/tools/internal/typeparams"
 )
 
 //go:embed doc.go
@@ -28,7 +29,7 @@ var Analyzer = &analysis.Analyzer{
 
 // assertableTo checks whether interface v can be asserted into t. It returns
 // nil on success, or the first conflicting method on failure.
-func assertableTo(v, t types.Type) *types.Func {
+func assertableTo(free *typeparams.Free, v, t types.Type) *types.Func {
 	if t == nil || v == nil {
 		// not assertable to, but there is no missing method
 		return nil
@@ -42,7 +43,7 @@ func assertableTo(v, t types.Type) *types.Func {
 
 	// Mitigations for interface comparisons and generics.
 	// TODO(https://github.com/golang/go/issues/50658): Support more precise conclusion.
-	if isParameterized(V) || isParameterized(T) {
+	if free.Has(V) || free.Has(T) {
 		return nil
 	}
 	if f, wrongType := types.MissingMethod(V, T, false); wrongType {
@@ -57,6 +58,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		(*ast.TypeAssertExpr)(nil),
 		(*ast.TypeSwitchStmt)(nil),
 	}
+	var free typeparams.Free
 	inspect.Preorder(nodeFilter, func(n ast.Node) {
 		var (
 			assert  *ast.TypeAssertExpr // v.(T) expression
@@ -86,7 +88,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		V := pass.TypesInfo.TypeOf(assert.X)
 		for _, target := range targets {
 			T := pass.TypesInfo.TypeOf(target)
-			if f := assertableTo(V, T); f != nil {
+			if f := assertableTo(&free, V, T); f != nil {
 				pass.Reportf(
 					target.Pos(),
 					"impossible type assertion: no type can implement both %v and %v (conflicting types for %v method)",

go/ssa/create.go

@@ -34,13 +34,12 @@ import (
 // See the Example tests for simple examples.
 func NewProgram(fset *token.FileSet, mode BuilderMode) *Program {
 	return &Program{
-		Fset:          fset,
-		imported:      make(map[string]*Package),
-		packages:      make(map[*types.Package]*Package),
-		mode:          mode,
-		canon:         newCanonizer(),
-		ctxt:          types.NewContext(),
-		parameterized: tpWalker{seen: make(map[types.Type]bool)},
+		Fset:     fset,
+		imported: make(map[string]*Package),
+		packages: make(map[*types.Package]*Package),
+		mode:     mode,
+		canon:    newCanonizer(),
+		ctxt:     types.NewContext(),
 	}
 }
 

go/ssa/emit.go

@@ -249,7 +249,7 @@ func emitConv(f *Function, val Value, typ types.Type) Value {
 		// Record the types of operands to MakeInterface, if
 		// non-parameterized, as they are the set of runtime types.
 		t := val.Type()
-		if f.typeparams.Len() == 0 || !f.Prog.parameterized.isParameterized(t) {
+		if f.typeparams.Len() == 0 || !f.Prog.isParameterized(t) {
 			addRuntimeType(f.Prog, t)
 		}
 

go/ssa/instantiate.go

@@ -75,7 +75,7 @@ func createInstance(fn *Function, targs []types.Type, cr *creator) *Function {
 		subst     *subster
 		build     buildFunc
 	)
-	if prog.mode&InstantiateGenerics != 0 && !prog.parameterized.anyParameterized(targs) {
+	if prog.mode&InstantiateGenerics != 0 && !prog.isParameterized(targs...) {
 		synthetic = fmt.Sprintf("instance of %s", fn.Name())
 		if fn.syntax != nil {
 			scope := obj.Origin().Scope()
@@ -110,3 +110,21 @@ func createInstance(fn *Function, targs []types.Type, cr *creator) *Function {
 	cr.Add(instance)
 	return instance
 }
+
+// isParameterized reports whether any of the specified types contains
+// a free type parameter. It is safe to call concurrently.
+func (prog *Program) isParameterized(ts ...types.Type) bool {
+	prog.hasParamsMu.Lock()
+	defer prog.hasParamsMu.Unlock()
+
+	// TODO(adonovan): profile. If this operation is expensive,
+	// handle the most common but shallow cases such as T, pkg.T,
+	// *T without consulting the cache under the lock.
+
+	for _, t := range ts {
+		if prog.hasParams.Has(t) {
+			return true
+		}
+	}
+	return false
+}

go/ssa/methods.go

@@ -32,7 +32,7 @@ func (prog *Program) MethodValue(sel *types.Selection) *Function {
 		return nil // interface method or type parameter
 	}
 
-	if prog.parameterized.isParameterized(T) {
+	if prog.isParameterized(T) {
 		return nil // generic method
 	}
 

go/ssa/parameterized.go

@@ -33,7 +33,9 @@ type Program struct {
 	methodsMu  sync.Mutex
 	methodSets typeutil.Map // maps type to its concrete *methodSet
 
-	parameterized tpWalker // memoization of whether a type refers to type parameters
+	// memoization of whether a type refers to type parameters
+	hasParamsMu sync.Mutex
+	hasParams   typeparams.Free
 
 	runtimeTypesMu sync.Mutex
 	runtimeTypes   typeutil.Map // set of runtime types (from MakeInterface)