1 files changed, 11 insertions, 11 deletions

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 9e9d6dfb29..3819a9ffb8 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -315,10 +315,10 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 			// both methods must have the same number of type parameters
 			ftyp := f.typ.(*Signature)
 			mtyp := m.typ.(*Signature)
-			if len(ftyp.tparams) != len(mtyp.tparams) {
+			if ftyp.TParams().Len() != mtyp.TParams().Len() {
 				return m, f
 			}
-			if !acceptMethodTypeParams && len(ftyp.tparams) > 0 {
+			if !acceptMethodTypeParams && ftyp.TParams().Len() > 0 {
 				panic("internal error: method with type parameters")
 			}
 
@@ -328,7 +328,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 			// TODO(gri) is this always correct? what about type bounds?
 			// (Alternative is to rename/subst type parameters and compare.)
 			u := newUnifier(true)
-			u.x.init(ftyp.tparams)
+			u.x.init(ftyp.TParams().list())
 			if !u.unify(ftyp, mtyp) {
 				return m, f
 			}
@@ -367,10 +367,10 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		// both methods must have the same number of type parameters
 		ftyp := f.typ.(*Signature)
 		mtyp := m.typ.(*Signature)
-		if len(ftyp.tparams) != len(mtyp.tparams) {
+		if ftyp.TParams().Len() != mtyp.TParams().Len() {
 			return m, f
 		}
-		if !acceptMethodTypeParams && len(ftyp.tparams) > 0 {
+		if !acceptMethodTypeParams && ftyp.TParams().Len() > 0 {
 			panic("internal error: method with type parameters")
 		}
 
@@ -381,17 +381,17 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		// In order to compare the signatures, substitute the receiver
 		// type parameters of ftyp with V's instantiation type arguments.
 		// This lazily instantiates the signature of method f.
-		if Vn != nil && len(Vn.TParams()) > 0 {
+		if Vn != nil && Vn.TParams().Len() > 0 {
 			// Be careful: The number of type arguments may not match
 			// the number of receiver parameters. If so, an error was
 			// reported earlier but the length discrepancy is still
 			// here. Exit early in this case to prevent an assertion
 			// failure in makeSubstMap.
 			// TODO(gri) Can we avoid this check by fixing the lengths?
-			if len(ftyp.rparams) != len(Vn.targs) {
+			if len(ftyp.RParams().list()) != len(Vn.targs) {
 				return
 			}
-			ftyp = check.subst(nopos, ftyp, makeSubstMap(ftyp.rparams, Vn.targs)).(*Signature)
+			ftyp = check.subst(nopos, ftyp, makeSubstMap(ftyp.RParams().list(), Vn.targs)).(*Signature)
 		}
 
 		// If the methods have type parameters we don't care whether they
@@ -400,7 +400,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		// TODO(gri) is this always correct? what about type bounds?
 		// (Alternative is to rename/subst type parameters and compare.)
 		u := newUnifier(true)
-		if len(ftyp.tparams) > 0 {
+		if ftyp.TParams().Len() > 0 {
 			// We reach here only if we accept method type parameters.
 			// In this case, unification must consider any receiver
 			// and method type parameters as "free" type parameters.
@@ -410,9 +410,9 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 			// unimplemented call so that we test this code if we
 			// enable method type parameters.
 			unimplemented()
-			u.x.init(append(ftyp.rparams, ftyp.tparams...))
+			u.x.init(append(ftyp.RParams().list(), ftyp.TParams().list()...))
 		} else {
-			u.x.init(ftyp.rparams)
+			u.x.init(ftyp.RParams().list())
 		}
 		if !u.unify(ftyp, mtyp) {
 			return m, f