[dev.typeparams] cmd/compile: set type parameter indices when they are bound

This is a port of CL 336249 with adjustments due to slightly
different handling of type parameter declaration in types2.

The CL also contains adjustments to the compiler front-end.

With this change it is not necessary to export type parameter
indices. Filed issue #47451 so we don't forget.

Change-Id: I2834f7be313fcb4763dff2a9058f1983ee6a81b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/338192
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

5 files changed, 26 insertions, 20 deletions

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index 96abbe66ae..2416d1a49e 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -167,10 +167,10 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	ntyp.SetUnderlying(g.typeExpr(decl.Type))
 
 	tparams := otyp.(*types2.Named).TParams()
-	if len(tparams) > 0 {
-		rparams := make([]*types.Type, len(tparams))
+	if n := tparams.Len(); n > 0 {
+		rparams := make([]*types.Type, n)
 		for i := range rparams {
-			rparams[i] = g.typ(tparams[i].Type())
+			rparams[i] = g.typ(tparams.At(i).Type())
 		}
 		// This will set hasTParam flag if any rparams are not concrete types.
 		ntyp.SetRParams(rparams)
diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go
index 131ee89cbb..a0d3cad699 100644
--- a/src/cmd/compile/internal/noder/expr.go
+++ b/src/cmd/compile/internal/noder/expr.go
@@ -337,7 +337,7 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto
 			if wantPtr {
 				recvType2Base = types2.AsPointer(recvType2).Elem()
 			}
-			if len(types2.AsNamed(recvType2Base).TParams()) > 0 {
+			if types2.AsNamed(recvType2Base).TParams().Len() > 0 {
 				// recvType2 is the original generic type that is
 				// instantiated for this method call.
 				// selinfo.Recv() is the instantiated type
diff --git a/src/cmd/compile/internal/noder/reader2.go b/src/cmd/compile/internal/noder/reader2.go
index 297fa59439..3e310e26c4 100644
--- a/src/cmd/compile/internal/noder/reader2.go
+++ b/src/cmd/compile/internal/noder/reader2.go
@@ -481,7 +481,7 @@ func (r *reader2) typeParamNames() []*types2.TypeName {
 		pkg, name := r.localIdent()
 
 		names[i] = types2.NewTypeName(pos, pkg, name, nil)
-		r.dict.tparams[i] = r.p.check.NewTypeParam(names[i], i, nil)
+		r.dict.tparams[i] = r.p.check.NewTypeParam(names[i], nil)
 	}
 
 	for i, bound := range r.dict.bounds {
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index d073526ada..3f7280a823 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -304,9 +304,9 @@ func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
 				} else {
 					meth2 = ir.NewNameAt(meth.Pos(), newsym)
 					rparams := types2.AsSignature(m.Type()).RParams()
-					tparams := make([]*types.Type, len(rparams))
-					for i, rparam := range rparams {
-						tparams[i] = g.typ1(rparam.Type())
+					tparams := make([]*types.Type, rparams.Len())
+					for i := range tparams {
+						tparams[i] = g.typ1(rparams.At(i).Type())
 					}
 					assert(len(tparams) == len(targs))
 					ts := typecheck.Tsubster{
@@ -336,9 +336,9 @@ func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
 
 func (g *irgen) signature(recv *types.Field, sig *types2.Signature) *types.Type {
 	tparams2 := sig.TParams()
-	tparams := make([]*types.Field, len(tparams2))
+	tparams := make([]*types.Field, tparams2.Len())
 	for i := range tparams {
-		tp := tparams2[i]
+		tp := tparams2.At(i)
 		tparams[i] = types.NewField(g.pos(tp), g.sym(tp), g.typ1(tp.Type()))
 	}
 
diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go
index 7b2285556e..0fc7e4f38c 100644
--- a/src/cmd/compile/internal/noder/writer.go
+++ b/src/cmd/compile/internal/noder/writer.go
@@ -299,7 +299,7 @@ func (pw *pkgWriter) typIdx(typ types2.Type, dict *writerDict) typeInfo {
 		// Type aliases can refer to uninstantiated generic types, so we
 		// might see len(TParams) != 0 && len(TArgs) == 0 here.
 		// TODO(mdempsky): Revisit after #46477 is resolved.
-		assert(len(typ.TParams()) == len(typ.TArgs()) || len(typ.TArgs()) == 0)
+		assert(typ.TParams().Len() == len(typ.TArgs()) || len(typ.TArgs()) == 0)
 
 		// TODO(mdempsky): Why do we need to loop here?
 		orig := typ
@@ -615,9 +615,10 @@ func (w *writer) objDict(obj types2.Object, dict *writerDict) {
 	w.len(len(dict.implicits))
 
 	tparams := objTypeParams(obj)
-	w.len(len(tparams))
-	for _, tparam := range tparams {
-		w.typ(tparam.Type().(*types2.TypeParam).Bound())
+	ntparams := tparams.Len()
+	w.len(ntparams)
+	for i := 0; i < ntparams; i++ {
+		w.typ(tparams.At(i).Type().(*types2.TypeParam).Bound())
 	}
 
 	nderived := len(dict.derived)
@@ -641,10 +642,12 @@ func (w *writer) objDict(obj types2.Object, dict *writerDict) {
 	assert(len(dict.funcs) == nfuncs)
 }
 
-func (w *writer) typeParamNames(tparams []*types2.TypeName) {
+func (w *writer) typeParamNames(tparams *types2.TypeParams) {
 	w.sync(syncTypeParamNames)
 
-	for _, tparam := range tparams {
+	ntparams := tparams.Len()
+	for i := 0; i < ntparams; i++ {
+		tparam := tparams.At(i)
 		w.pos(tparam)
 		w.localIdent(tparam)
 	}
@@ -1468,13 +1471,16 @@ type declCollector struct {
 
 func (c *declCollector) withTParams(obj types2.Object) *declCollector {
 	tparams := objTypeParams(obj)
-	if len(tparams) == 0 {
+	n := tparams.Len()
+	if n == 0 {
 		return c
 	}
 
 	copy := *c
 	copy.implicits = copy.implicits[:len(copy.implicits):len(copy.implicits)]
-	copy.implicits = append(copy.implicits, objTypeParams(obj)...)
+	for i := 0; i < n; i++ {
+		copy.implicits = append(copy.implicits, tparams.At(i))
+	}
 	return &copy
 }
 
@@ -1705,7 +1711,7 @@ func (w *writer) pkgDecl(decl syntax.Decl) {
 		// TODO(mdempsky): Revisit after #46477 is resolved.
 		if name.IsAlias() {
 			named, ok := name.Type().(*types2.Named)
-			if ok && len(named.TParams()) != 0 && len(named.TArgs()) == 0 {
+			if ok && named.TParams().Len() != 0 && len(named.TArgs()) == 0 {
 				break
 			}
 		}
@@ -1851,7 +1857,7 @@ func fieldIndex(info *types2.Info, str *types2.Struct, key *syntax.Name) int {
 }
 
 // objTypeParams returns the type parameters on the given object.
-func objTypeParams(obj types2.Object) []*types2.TypeName {
+func objTypeParams(obj types2.Object) *types2.TypeParams {
 	switch obj := obj.(type) {
 	case *types2.Func:
 		sig := obj.Type().(*types2.Signature)