gopls/internal/analysis/gofix: generic aliases

Support inlining generic aliases.

For golang/go#32816.

Change-Id: Ic65e6fb30d65ee0f7d6e0093fd882a675de71da4
Reviewed-on: https://go-review.googlesource.com/c/tools/+/651617
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>

Author: jba

gopls/internal/analysis/gofix/gofix.go

@@ -9,6 +9,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"slices"
 	"strings"
 
 	_ "embed"
@@ -140,11 +141,6 @@ func (a *analyzer) findAlias(spec *ast.TypeSpec, declInline bool) {
 		}
 	}
 
-	if spec.TypeParams != nil {
-		// TODO(jba): handle generic aliases
-		return
-	}
-
 	// Remember that this is an inlinable alias.
 	typ := &goFixInlineAliasFact{}
 	lhs := a.pass.TypesInfo.Defs[spec.Name].(*types.TypeName)
@@ -294,7 +290,7 @@ func (a *analyzer) inlineCall(call *ast.CallExpr, cur cursor.Cursor) {
 }
 
 // If tn is the TypeName of an inlinable alias, suggest inlining its use at cur.
-func (a *analyzer) inlineAlias(tn *types.TypeName, cur cursor.Cursor) {
+func (a *analyzer) inlineAlias(tn *types.TypeName, curId cursor.Cursor) {
 	inalias, ok := a.inlinableAliases[tn]
 	if !ok {
 		var fact goFixInlineAliasFact
@@ -307,12 +303,17 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, cur cursor.Cursor) {
 		return // nope
 	}
 
-	// Get the alias's RHS. It has everything we need to format the replacement text.
-	rhs := tn.Type().(*types.Alias).Rhs()
-
+	alias := tn.Type().(*types.Alias)
+	// Remember the names of the alias's type params. When we check for shadowing
+	// later, we'll ignore these because they won't appear in the replacement text.
+	typeParamNames := map[*types.TypeName]bool{}
+	for tp := range alias.TypeParams().TypeParams() {
+		typeParamNames[tp.Obj()] = true
+	}
+	rhs := alias.Rhs()
 	curPath := a.pass.Pkg.Path()
-	curFile := currentFile(cur)
-	n := cur.Node().(*ast.Ident)
+	curFile := currentFile(curId)
+	id := curId.Node().(*ast.Ident)
 	// We have an identifier A here (n), possibly qualified by a package
 	// identifier (sel.n), and an inlinable "type A = rhs" elsewhere.
 	//
@@ -324,6 +325,10 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, cur cursor.Cursor) {
 		edits          []analysis.TextEdit
 	)
 	for _, tn := range typenames(rhs) {
+		// Ignore the type parameters of the alias: they won't appear in the result.
+		if typeParamNames[tn] {
+			continue
+		}
 		var pkgPath, pkgName string
 		if pkg := tn.Pkg(); pkg != nil {
 			pkgPath = pkg.Path()
@@ -333,9 +338,9 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, cur cursor.Cursor) {
 			// The name is in the current package or the universe scope, so no import
 			// is required. Check that it is not shadowed (that is, that the type
 			// it refers to in rhs is the same one it refers to at n).
-			scope := a.pass.TypesInfo.Scopes[curFile].Innermost(n.Pos()) // n's scope
-			_, obj := scope.LookupParent(tn.Name(), n.Pos())             // what qn.name means in n's scope
-			if obj != tn {                                               // shadowed
+			scope := a.pass.TypesInfo.Scopes[curFile].Innermost(id.Pos()) // n's scope
+			_, obj := scope.LookupParent(tn.Name(), id.Pos())             // what qn.name means in n's scope
+			if obj != tn {
 				return
 			}
 		} else if !analysisinternal.CanImport(a.pass.Pkg.Path(), pkgPath) {
@@ -345,15 +350,40 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, cur cursor.Cursor) {
 			// Use AddImport to add pkgPath if it's not there already. Associate the prefix it assigns
 			// with the package path for use by the TypeString qualifier below.
 			_, prefix, eds := analysisinternal.AddImport(
-				a.pass.TypesInfo, curFile, pkgName, pkgPath, tn.Name(), n.Pos())
+				a.pass.TypesInfo, curFile, pkgName, pkgPath, tn.Name(), id.Pos())
 			importPrefixes[pkgPath] = strings.TrimSuffix(prefix, ".")
 			edits = append(edits, eds...)
 		}
 	}
-	// If n is qualified by a package identifier, we'll need the full selector expression.
-	var expr ast.Expr = n
-	if e, _ := cur.Edge(); e == edge.SelectorExpr_Sel {
-		expr = cur.Parent().Node().(ast.Expr)
+	// Find the complete identifier, which may take any of these forms:
+	//       Id
+	//       Id[T]
+	//       Id[K, V]
+	//   pkg.Id
+	//   pkg.Id[T]
+	//   pkg.Id[K, V]
+	var expr ast.Expr = id
+	if e, _ := curId.Edge(); e == edge.SelectorExpr_Sel {
+		curId = curId.Parent()
+		expr = curId.Node().(ast.Expr)
+	}
+	// If expr is part of an IndexExpr or IndexListExpr, we'll need that node.
+	// Given C[int], TypeOf(C) is generic but TypeOf(C[int]) is instantiated.
+	switch ek, _ := curId.Edge(); ek {
+	case edge.IndexExpr_X:
+		expr = curId.Parent().Node().(*ast.IndexExpr)
+	case edge.IndexListExpr_X:
+		expr = curId.Parent().Node().(*ast.IndexListExpr)
+	}
+	t := a.pass.TypesInfo.TypeOf(expr).(*types.Alias) // type of entire identifier
+	if targs := t.TypeArgs(); targs.Len() > 0 {
+		// Instantiate the alias with the type args from this use.
+		// For example, given type A = M[K, V], compute the type of the use
+		// A[int, Foo] as M[int, Foo].
+		// Don't validate instantiation: it can't panic unless we have a bug,
+		// in which case seeing the stack trace via telemetry would be helpful.
+		instAlias, _ := types.Instantiate(nil, alias, slices.Collect(targs.Types()), false)
+		rhs = instAlias.(*types.Alias).Rhs()
 	}
 	// To get the replacement text, render the alias RHS using the package prefixes
 	// we assigned above.

gopls/internal/analysis/gofix/testdata/src/a/a.go

@@ -164,3 +164,25 @@ func _[P any]() {
 	_ = x
 	_ = y
 }
+
+// generic type aliases
+
+//go:fix inline
+type (
+	Mapset[T comparable] = map[T]bool // want Mapset: `goFixInline alias`
+	Pair[X, Y any]       = struct {   // want Pair: `goFixInline alias`
+		X X
+		Y Y
+	}
+)
+
+var _ Mapset[int] // want `Type alias Mapset\[int\] should be inlined`
+
+var _ Pair[T, string] // want `Type alias Pair\[T, string\] should be inlined`
+
+func _[V any]() {
+	//go:fix inline
+	type M[K comparable] = map[K]V
+
+	var _ M[int] // want `Type alias M\[int\] should be inlined`
+}

gopls/internal/analysis/gofix/testdata/src/a/a.go.golden

@@ -165,3 +165,28 @@ func _[P any]() {
 	_ = x
 	_ = y
 }
+
+// generic type aliases
+
+//go:fix inline
+type (
+	Mapset[T comparable] = map[T]bool // want Mapset: `goFixInline alias`
+	Pair[X, Y any]       = struct {   // want Pair: `goFixInline alias`
+		X X
+		Y Y
+	}
+)
+
+var _ map[int]bool // want `Type alias Mapset\[int\] should be inlined`
+
+var _ struct {
+	X T
+	Y string
+} // want `Type alias Pair\[T, string\] should be inlined`
+
+func _[V any]() {
+	//go:fix inline
+	type M[K comparable] = map[K]V
+
+	var _ map[int]V // want `Type alias M\[int\] should be inlined`
+}