[dev.typeparams] cmd/compile: simple shape cleanups

 - Changed some early returns to asserts (instantiateMethods and Shapify
   should never take a shape arg)

 - Added suggested change (by Ingo) to use copy() in getInstantiation()

 - Clarified that shape types never have methods in Shapify(), removed
   some TODO comments.

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

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 037f309a82b4335b1086e79b37f25e641a43ee71..c006c4af446ebadb0bd3082d16f5878942c6114e 100644 (file)
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -474,10 +474,7 @@ func (g *irgen) buildClosure(outer *ir.Func, x ir.Node) ir.Node {
 func (g *irgen) instantiateMethods() {
        for i := 0; i < len(g.instTypeList); i++ {
                typ := g.instTypeList[i]
-               if typ.HasShape() {
-                       // Shape types should not have any methods.
-                       continue
-               }
+               assert(!typ.HasShape())
                // Mark runtime type as needed, since this ensures that the
                // compiler puts out the needed DWARF symbols, when this
                // instantiated type has a different package from the local
@@ -782,9 +779,7 @@ func (g *irgen) getInstantiation(nameNode *ir.Name, shapes []*types.Type, isMeth
                if !t.HasShape() {
                        if s1 == nil {
                                s1 = make([]*types.Type, len(shapes))
-                               for j := 0; j < i; j++ {
-                                       s1[j] = shapes[j]
-                               }
+                               copy(s1[0:i], shapes[0:i])
                        }
                        s1[i] = typecheck.Shapify(t)
                } else if s1 != nil {

diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go
index 968d7a0d6d7850e633ba721349c3114c5ce4205a..25db24259c31e04410d7900a6c6f16d85f65357e 100644 (file)
--- a/src/cmd/compile/internal/typecheck/subr.go
+++ b/src/cmd/compile/internal/typecheck/subr.go
@@ -1338,6 +1338,9 @@ func genericTypeName(sym *types.Sym) string {
 
 // Shapify takes a concrete type and returns a GCshape type that can
 // be used in place of the input type and still generate identical code.
+// No methods are added - all methods calls directly on a shape should
+// be done by converting to an interface using the dictionary.
+//
 // TODO: this could take the generic function and base its decisions
 // on how that generic function uses this type argument. For instance,
 // if it doesn't use it as a function argument/return value, then
@@ -1345,9 +1348,7 @@ func genericTypeName(sym *types.Sym) string {
 // differ in how they get passed as arguments). For now, we only
 // unify two different types if they are identical in every possible way.
 func Shapify(t *types.Type) *types.Type {
-       if t.IsShape() {
-               return t // TODO: is this right?
-       }
+       assert(!t.HasShape())
        // Map all types with the same underlying type to the same shape.
        u := t.Underlying()
 
@@ -1358,7 +1359,7 @@ func Shapify(t *types.Type) *types.Type {
        }
 
        if s := shaped[u]; s != nil {
-               return s //TODO: keep?
+               return s
        }
 
        sym := Lookup(fmt.Sprintf(".shape%d", snum))
@@ -1370,7 +1371,6 @@ func Shapify(t *types.Type) *types.Type {
        s.SetHasShape(true)
        name.SetType(s)
        name.SetTypecheck(1)
-       // TODO: add methods to s that the bound has?
        shaped[u] = s
        return s
 }