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>

diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 65568f23077d9d914faf10617568069f11bc19da..d19513a1ac80e268f0d04eef265c210d573f47b9 100644 (file)
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/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 {

diff --git a/test/run.go b/test/run.go
index 0c5da1af78c5d9044fd1f09b0db6022e51e78d35..942fd032f2165a55ce64f5c2bfee94fcdac99a34 100644 (file)
--- a/test/run.go
+++ b/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 {

diff --git a/test/typeparam/issue48538.go b/test/typeparam/issue48538.go
new file mode 100644 (file)
index 0000000..fed9b5e
--- /dev/null
+++ b/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",
+       }
+}