cmd/compile: use Structure() to get single underlying type of typeparam.

Use types2.Structure() to get single underlying type of typeparams, to
handle some unusual cases where a type param is constrained to a single
underlying struct or map type.

Fixes #48538

Change-Id: I289fb7b31d489f7586f2b04aeb1df74e15a9f965
Reviewed-on: https://go-review.googlesource.com/c/go/+/359335
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

src/cmd/compile/internal/noder/expr.go

@@ -344,7 +344,7 @@ func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node {
 		return typed(g.typ(typ), n)
 	}
 
-	_, isStruct := typ.Underlying().(*types2.Struct)
+	_, isStruct := types2.Structure(typ).(*types2.Struct)
 
 	exprs := make([]ir.Node, len(lit.ElemList))
 	for i, elem := range lit.ElemList {

test/run.go

@@ -2188,6 +2188,7 @@ var unifiedFailures = setOf(
 
 	"fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape"
 	"fixedbugs/issue7921.go",  // prints "… escapes to heap", but test expects "string(…) escapes to heap"
+	"typeparam/issue48538.go", // assertion failure, interprets struct key as closure variable
 )
 
 func setOf(keys ...string) map[string]bool {

test/typeparam/issue48538.go

@@ -0,0 +1,60 @@
+// compile -G=3
+
+// Copyright 2021 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.
+
+// Testing composite literal for a type param constrained to be a struct or a map.
+
+package p
+
+type C interface {
+	~struct{ b1, b2 string }
+}
+
+func f[T C]() T {
+	return T{
+		b1: "a",
+		b2: "b",
+	}
+}
+
+func f2[T ~struct{ b1, b2 string }]() T {
+	return T{
+		b1: "a",
+		b2: "b",
+	}
+}
+
+type D interface {
+	map[string]string | S
+}
+
+type S map[string]string
+
+func g[T D]() T {
+	b1 := "foo"
+	b2 := "bar"
+	return T{
+		b1: "a",
+		b2: "b",
+	}
+}
+
+func g2[T map[string]string]() T {
+	b1 := "foo"
+	b2 := "bar"
+	return T{
+		b1: "a",
+		b2: "b",
+	}
+}
+
+func g3[T S]() T {
+	b1 := "foo"
+	b2 := "bar"
+	return T{
+		b1: "a",
+		b2: "b",
+	}
+}