go/analysis/passes/inline: fix panic in inlineAlias with instantiated generic alias

When the inline analyzer encounters a type alias like
type Alias[T any] = []T, it needs to perform two main steps for inlining:
   1. Collect Imports: Identify every package mentioned
      in the Right-Hand Side (RHS) of the alias to ensure
      the caller's file has the necessary import statements.
   2. Generate Text: Use types.TypeString to render the RHS
      into a string to replace the alias usage.

The bug was that the analyzer collected imports from the original
(generic) RHS but then generated the replacement text using
the instantiated RHS.

 Consider a case:
   * Package A: type Alias[T any] = []T
   * Package B: type MyType int
   * Main: var _ A.Alias[B.MyType]

The original RHS is just []T (no extra packages).
However, when instantiated for the caller, the RHS becomes []B.MyType.
Because the analyzer had already finished its "Collect Imports" phase
using the generic []T, it didn't realize it needed to add an import
for Package B. When types.TypeString eventually tried to render
[]B.MyType, it looked for a registered import prefix for Package B,
found none, and panicked with "package path has no import prefix".

Moving the import collection logic to after the RHS instantiation
ensures that all necessary packages from the instantiated RHS are
identified and imported, preventing the 'package path has no import
prefix' panic.

Fixes golang/go#77844

Change-Id: I45db22a62d371804b837bf0957b25625e9413487
Reviewed-on: https://go-review.googlesource.com/c/tools/+/749800
Reviewed-by: Alan Donovan <adonovan@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: hyangah

go/analysis/passes/inline/inline.go

@@ -315,12 +315,43 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, curId inspector.Cursor) {
 	curPath := a.pass.Pkg.Path()
 	curFile := astutil.EnclosingFile(curId)
 	id := curId.Node().(*ast.Ident)
+
+	// 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 curId.ParentEdgeKind() == 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 curId.ParentEdgeKind() {
+	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()
+	}
+
 	// We have an identifier A here (n), possibly qualified by a package
 	// identifier (sel.n), and an inlinable "type A = rhs" elsewhere.
 	//
 	// We can replace A with rhs if no name in rhs is shadowed at n's position,
 	// and every package in rhs is importable by the current package.
-
 	var (
 		importPrefixes = map[string]string{curPath: ""} // from pkg path to prefix
 		edits          []analysis.TextEdit
@@ -349,43 +380,15 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, curId inspector.Cursor) {
 			return
 		} else if _, ok := importPrefixes[pkgPath]; !ok {
 			// Use AddImport to add pkgPath if it's not there already. Associate the prefix it assigns
+			// with the prefix it assigns
 			// with the package path for use by the TypeString qualifier below.
 			prefix, eds := refactor.AddImport(
 				a.pass.TypesInfo, curFile, pkgName, pkgPath, tn.Name(), id.Pos())
 			importPrefixes[pkgPath] = strings.TrimSuffix(prefix, ".")
 			edits = append(edits, eds...)
 		}
 	}
-	// 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 curId.ParentEdgeKind() == 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 curId.ParentEdgeKind() {
-	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.
 	newText := types.TypeString(rhs, func(p *types.Package) string {

go/analysis/passes/inline/issue77844_test.go

@@ -0,0 +1,16 @@
+// Copyright 2025 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 inline
+
+import (
+	"golang.org/x/tools/go/analysis/analysistest"
+	"golang.org/x/tools/internal/testfiles"
+	"testing"
+)
+
+func TestIssue77844(t *testing.T) {
+	dir := testfiles.ExtractTxtarFileToTmp(t, "testdata/src/issue77844.txtar")
+	analysistest.Run(t, dir, Analyzer, "example.com/main")
+}

go/analysis/passes/inline/testdata/src/issue77844.txtar

@@ -0,0 +1,27 @@
+-- go.mod --
+module example.com
+
+go 1.24
+
+-- lib/lib.go --
+package lib
+
+//go:fix inline
+type Alias[T any] = []T
+
+-- other/other.go --
+package other
+
+type Other int
+
+-- main/main.go --
+package main
+
+import (
+	"example.com/lib"
+	"example.com/other"
+)
+
+func _() {
+	var _ lib.Alias[other.Other] // want "Type alias lib.Alias.other.Other. should be inlined"
+}