[dev.typeparams] cmd/compile: fix HasShape, add dottype test

HasShape needs a TINTER case.

Add a test for x.(T) in various situations. Needs the fix above.

Also remove ONEW unshapify case. It is ok for ONEW to have a shape
type, as it will just be passed to mallocgc, or possibly used as a
stack object type, both of which are ok.

Change-Id: Ibddf8f5c8c254d32cb5ebcaca7dc94b4c00ab893
Reviewed-on: https://go-review.googlesource.com/c/go/+/337231
Trust: Keith Randall <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>

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

@@ -1376,12 +1376,6 @@ func (subst *subster) node(n ir.Node) ir.Node {
 		case ir.ODOTTYPE, ir.ODOTTYPE2:
 			m.SetType(subst.unshapifyTyp(m.Type()))
 
-		case ir.ONEW:
-			// New needs to pass a concrete type to the runtime.
-			// Or maybe it doesn't? We could use a shape type.
-			// TODO: need to modify m.X? I don't think any downstream passes use it.
-			m.SetType(subst.unshapifyTyp(m.Type()))
-
 		case ir.OMETHEXPR:
 			se := m.(*ir.SelectorExpr)
 			se.X = ir.TypeNodeAt(se.X.Pos(), subst.unshapifyTyp(se.X.Type()))

src/cmd/compile/internal/types/type.go

@@ -2189,7 +2189,13 @@ func (t *Type) HasShape1(visited map[*Type]bool) bool {
 				}
 			}
 		}
-		// TODO: TINTER - check methods?
+	case TINTER:
+		for _, f := range t.Methods().Slice() {
+			if f.Type.HasShape1(visited) {
+				return true
+			}
+		}
+		return false
 	}
 	return false
 }

test/typeparam/dottype.go

@@ -0,0 +1,81 @@
+// run -gcflags=-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.
+
+package main
+
+func f[T any](x interface{}) T {
+	return x.(T)
+}
+func f2[T any](x interface{}) (T, bool) {
+	t, ok := x.(T)
+	return t, ok
+}
+
+type I interface {
+	foo()
+}
+
+type myint int
+
+func (myint) foo() {
+}
+
+type myfloat float64
+
+func (myfloat) foo() {
+}
+
+func g[T I](x I) T {
+	return x.(T)
+}
+func g2[T I](x I) (T, bool) {
+	t, ok := x.(T)
+	return t, ok
+}
+
+func h[T any](x interface{}) struct{a, b T} {
+	return x.(struct{a, b T})
+}
+
+func k[T any](x interface{}) interface { bar() T } {
+	return x.(interface{bar() T })
+}
+
+type mybar int
+func (x mybar) bar() int {
+	return int(x)
+}
+
+
+func main() {
+	var i interface{} = int(3)
+	var j I = myint(3)
+	var x interface{} = float64(3)
+	var y I = myfloat(3)
+
+	println(f[int](i))
+	shouldpanic(func() { f[int](x) })
+	println(f2[int](i))
+	println(f2[int](x))
+
+	println(g[myint](j))
+	shouldpanic(func() { g[myint](y) })
+	println(g2[myint](j))
+	println(g2[myint](y))
+
+	println(h[int](struct{a, b int}{3, 5}).a)
+
+	println(k[int](mybar(3)).bar())
+}
+func shouldpanic(x func()) {
+	defer func() {
+		e := recover()
+		if e == nil {
+			panic("didn't panic")
+		}
+	}()
+	x()
+}

test/typeparam/dottype.out

@@ -0,0 +1,8 @@
+3
+3 true
+0 false
+3
+3 true
+0 false
+3
+3