go/ssa: use core type in address

The type of an address is now the element type of a type whose core type
is a pointer type. Previously this was the element type of a type whose
underlying type was a pointer type. emitStore now uses the core type as
well.
	func f[M any, P *M](p P) {
		var m M
		*p = m
	}

is emitted as:

	func f[M any, P *M](p P):
	0:
		*p = *new(M):M
		return

Related to golang/go#57272
Fixes golang/go#58633

Change-Id: I35d4345a9b3f69bcd28cf8342f7fec550329eba4
Reviewed-on: https://go-review.googlesource.com/c/tools/+/492598
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Tim King <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>

Author: Antonboom

go/ssa/builder_generic_test.go

@@ -340,7 +340,7 @@ func TestGenericBodies(t *testing.T) {
 			func d[T interface{ map[int]int64 }](x T) int64 {
 				print(x, x[2], x[3]) //@ types(T, int64, int64)
 				x[2] = 43
-        		return x[3]
+				return x[3]
 			}
 			func e[T ~string](t T) {
 				print(t, t[0]) //@ types(T, uint8)
@@ -413,6 +413,7 @@ func TestGenericBodies(t *testing.T) {
 			`,
 		},
 		{
+			// TODO(59983): investigate why writing g.c panics in (*FieldAddr).String.
 			pkg: "g",
 			contents: `package g
 			type S struct{ f int }
@@ -458,6 +459,45 @@ func TestGenericBodies(t *testing.T) {
 			}
 			`,
 		},
+		{
+			pkg: "k",
+			contents: `
+			package k
+
+			func f[M any, PM *M](p PM) {
+				var m M
+				*p = m
+				print(m)  /*@ types(M)*/
+				print(p)  /*@ types(PM)*/
+			}
+			`,
+		},
+		{
+			pkg: "l",
+			contents: `
+			package l
+
+			type A struct{int}
+			func (*A) Marker() {}
+
+			type B struct{string}
+			func (*B) Marker() {}
+
+			type C struct{float32}
+			func (*C) Marker() {}
+
+			func process[T interface {
+				*A
+				*B
+				*C
+				Marker()
+			}](v T) {
+				v.Marker()
+				a := *(any(v).(*A)); print(a)  /*@ types("l.A")*/
+				b := *(any(v).(*B)); print(b)  /*@ types("l.B")*/
+				c := *(any(v).(*C)); print(c)  /*@ types("l.C")*/
+			}`,
+		},
 	} {
 		test := test
 		t.Run(test.pkg, func(t *testing.T) {

go/ssa/emit.go

@@ -372,9 +372,10 @@ func emitTypeCoercion(f *Function, v Value, typ types.Type) Value {
 // emitStore emits to f an instruction to store value val at location
 // addr, applying implicit conversions as required by assignability rules.
 func emitStore(f *Function, addr, val Value, pos token.Pos) *Store {
+	typ := mustDeref(addr.Type())
 	s := &Store{
 		Addr: addr,
-		Val:  emitConv(f, val, deref(addr.Type())),
+		Val:  emitConv(f, val, typ),
 		pos:  pos,
 	}
 	f.emit(s)

go/ssa/lvalue.go

@@ -25,7 +25,7 @@ type lvalue interface {
 
 // An address is an lvalue represented by a true pointer.
 type address struct {
-	addr Value
+	addr Value     // must have a pointer core type.
 	pos  token.Pos // source position
 	expr ast.Expr  // source syntax of the value (not address) [debug mode]
 }
@@ -52,7 +52,7 @@ func (a *address) address(fn *Function) Value {
 }
 
 func (a *address) typ() types.Type {
-	return deref(a.addr.Type())
+	return mustDeref(a.addr.Type())
 }
 
 // An element is an lvalue represented by m[k], the location of an

go/ssa/util.go

@@ -108,6 +108,16 @@ func deref(typ types.Type) types.Type {
 	return typ
 }
 
+// mustDeref returns the element type of a type with a pointer core type.
+// Panics on failure.
+func mustDeref(typ types.Type) types.Type {
+	// TODO(taking): Replace deref with mustDeref when possible.
+	if p, ok := typeparams.CoreType(typ).(*types.Pointer); ok {
+		return p.Elem()
+	}
+	panic("cannot dereference type " + typ.String())
+}
+
 // recvType returns the receiver type of method obj.
 func recvType(obj *types.Func) types.Type {
 	return obj.Type().(*types.Signature).Recv().Type()