internal/refactor/inline: built-ins may affect inference

This change fixes a bug that caused argument conversions to
be neglected when inlining calls to functions whose body
calls certain built-ins such as new:

  func f(x int64) *int64 { return new(x) }

  var _ *int64 = f(42) // => new(42), should be new(int64(42))

The solution is to consider built-in functions as well as
ordinary non-method functions when computing whether the
argument may affect type inference.

This results in a slight style regression when dealing with
complex numbers, but they are rare.

+ test

Fixes golang/go#76287

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

Author: adonovan

internal/refactor/inline/callee.go

@@ -725,8 +725,48 @@ func analyzeAssignment(info *types.Info, stack []ast.Node) (assignable, ifaceAss
 					paramType := paramTypeAtIndex(sig, call, i)
 					ifaceAssign := paramType == nil || types.IsInterface(paramType)
 					affectsInference := false
-					if fn := typeutil.StaticCallee(info, call); fn != nil {
-						if sig2 := fn.Type().(*types.Signature); sig2.Recv() == nil {
+					switch callee := typeutil.Callee(info, call).(type) {
+					case *types.Builtin:
+						// Consider this litmus test:
+						//
+						//   func f(x int64) any { return max(x) }
+						//   func main() { fmt.Printf("%T", f(42)) }
+						//
+						// If we lose the implicit conversion from untyped int
+						// to int64, the type inferred for the max(x) call changes,
+						// resulting in a different dynamic behavior: it prints
+						// int, not int64.
+						//
+						// Inferred result type affected:
+						//    new
+						//    complex, real, imag
+						//    min, max
+						//
+						// Dynamic behavior change:
+						//    append         -- dynamic type of append([]any(nil), x)[0]
+						//    delete(m, x)   -- dynamic key type where m is map[any]unit
+						//    panic          -- dynamic type of panic value
+						//
+						// Unaffected:
+						//    recover
+						//    make
+						//    len, cap
+						//    clear
+						//    close
+						//    copy
+						//    print, println  -- only uses underlying types (?)
+						//
+						// The dynamic type cases are all covered by
+						// the ifaceAssign logic.
+						switch callee.Name() {
+						case "new", "complex", "real", "imag", "min", "max":
+							affectsInference = true
+						}
+
+					case *types.Func:
+						// Only standalone (non-method) functions have type
+						// parameters affected by the call arguments.
+						if sig2 := callee.Signature(); sig2.Recv() == nil {
 							originParamType := paramTypeAtIndex(sig2, call, i)
 							affectsInference = originParamType == nil || new(typeparams.Free).Has(originParamType)
 						}

internal/refactor/inline/falcon_test.go

@@ -341,7 +341,9 @@ func TestFalconComplex(t *testing.T) {
 			"Complex arithmetic (good).",
 			`func f(re, im float64, z complex128) byte { return "x"[int(real(complex(re, im)*complex(re, -im)-z))] }`,
 			`func _() { f(1, 2, 5+0i) }`,
-			`func _() { _ = "x"[int(real(complex(1, 2)*complex(1, -2)-(5+0i)))] }`,
+			// The float64 conversions are excessively conservative here
+			// but in general may affect the type of complex produced.
+			`func _() { _ = "x"[int(real(complex(float64(1), float64(2))*complex(float64(1), -2)-(5+0i)))] }`,
 		},
 		{
 			"Complex arithmetic (bad).",

internal/refactor/inline/inline_test.go

@@ -75,6 +75,12 @@ func TestData(t *testing.T) {
 				testenv.NeedsTool(t, "cgo")
 			}
 
+			// Some tests need specific Go versions.
+			// TODO(adonovan): remove when go1.26 is assured.
+			if strings.HasSuffix(t.Name(), "newexpr.txtar") {
+				testenv.NeedsGo1Point(t, 26)
+			}
+
 			// Extract archive to temporary tree.
 			ar, err := txtar.ParseFile(file)
 			if err != nil {

internal/refactor/inline/testdata/newexpr.txtar

@@ -0,0 +1,44 @@
+Regression test for https://go.dev/issue/76287:
+ensure that inlining a function that wraps go1.26's new(expr)
+correctly inserts a conversion as needed, just as it would for a
+declared generic function equivalent to 'new'.
+
+- f uses a declared _new(expr) function.
+- g uses the built-in new(expr) function.
+
+-- go.mod --
+module testdata
+go 1.26
+
+-- common.go --
+package p
+
+func _new[T any](x T) *T { return &x }
+
+-- f.go --
+package p
+
+func f(x int64) *int64 { return _new(x) }
+
+var _ *int64 = f(42) //@ inline(re"f", f)
+
+-- g.go --
+package p
+
+func g(x int64) *int64 { return new(x) }
+
+var _ *int64 = g(42) //@ inline(re"g", g)
+
+-- f --
+package p
+
+func f(x int64) *int64 { return _new(x) }
+
+var _ *int64 = _new(int64(42)) //@ inline(re"f", f)
+
+-- g --
+package p
+
+func g(x int64) *int64 { return new(x) }
+
+var _ *int64 = new(int64(42)) //@ inline(re"g", g)