go/types: rename TypeParams to TParamList

This is a straightforward port of CL 341861 to go/types.

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

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 35aa5e2d5a463155a7e7209a40d836ba059f8417..c6505b63a184503bc0d2e200963611806a74387d 100644 (file)
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -631,7 +631,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
        }
 }
 
-func (check *Checker) collectTypeParams(list *ast.FieldList) *TypeParams {
+func (check *Checker) collectTypeParams(list *ast.FieldList) *TParamList {
        var tparams []*TypeName
        // Declare type parameters up-front, with empty interface as type bound.
        // The scope of type parameters starts at the beginning of the type parameter

diff --git a/src/go/types/named.go b/src/go/types/named.go
index 1a8e6a9062a56bb99214e81e2a04edc03199d90f..1841038fdbcecb85a11c961bd7de1ba8d965df16 100644 (file)
--- a/src/go/types/named.go
+++ b/src/go/types/named.go
@@ -20,7 +20,7 @@ type Named struct {
        fromRHS    Type        // type (on RHS of declaration) this *Named type is derived of (for cycle reporting)
        underlying Type        // possibly a *Named during setup; never a *Named once set up completely
        instance   *instance   // syntactic information for lazy instantiation
-       tparams    *TypeParams // type parameters, or nil
+       tparams    *TParamList // type parameters, or nil
        targs      []Type      // type arguments (after instantiation), or nil
        methods    []*Func     // methods declared for this type (not the method set of this type); signatures are type-checked lazily
 
@@ -80,7 +80,7 @@ func (t *Named) load() *Named {
 }
 
 // newNamed is like NewNamed but with a *Checker receiver and additional orig argument.
-func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParams, methods []*Func) *Named {
+func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TParamList, methods []*Func) *Named {
        typ := &Named{check: check, obj: obj, orig: orig, fromRHS: underlying, underlying: underlying, tparams: tparams, methods: methods}
        if typ.orig == nil {
                typ.orig = typ
@@ -120,7 +120,7 @@ func (t *Named) _Orig() *Named { return t.orig }
 
 // TParams returns the type parameters of the named type t, or nil.
 // The result is non-nil for an (originally) parameterized type even if it is instantiated.
-func (t *Named) TParams() *TypeParams { return t.load().tparams }
+func (t *Named) TParams() *TParamList { return t.load().tparams }
 
 // SetTParams sets the type parameters of the named type t.
 func (t *Named) SetTParams(tparams []*TypeName) { t.load().tparams = bindTParams(tparams) }

diff --git a/src/go/types/signature.go b/src/go/types/signature.go
index ffe612d9b7500df3643b52e8e4cc8017c5fc5eb5..9bfb1683a725aa57ccbbbb7243be62231ad9b9d2 100644 (file)
--- a/src/go/types/signature.go
+++ b/src/go/types/signature.go
@@ -21,8 +21,8 @@ type Signature struct {
        // and store it in the Func Object) because when type-checking a function
        // literal we call the general type checker which returns a general Type.
        // We then unpack the *Signature and use the scope for the literal body.
-       rparams  *TypeParams // receiver type parameters from left to right, or nil
-       tparams  *TypeParams // type parameters from left to right, or nil
+       rparams  *TParamList // receiver type parameters from left to right, or nil
+       tparams  *TParamList // type parameters from left to right, or nil
        scope    *Scope      // function scope, present for package-local signatures
        recv     *Var        // nil if not a method
        params   *Tuple      // (incoming) parameters from left to right; or nil
@@ -56,13 +56,13 @@ func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
 func (s *Signature) Recv() *Var { return s.recv }
 
 // TParams returns the type parameters of signature s, or nil.
-func (s *Signature) TParams() *TypeParams { return s.tparams }
+func (s *Signature) TParams() *TParamList { return s.tparams }
 
 // SetTParams sets the type parameters of signature s.
 func (s *Signature) SetTParams(tparams []*TypeName) { s.tparams = bindTParams(tparams) }
 
 // RParams returns the receiver type parameters of signature s, or nil.
-func (s *Signature) RParams() *TypeParams { return s.rparams }
+func (s *Signature) RParams() *TParamList { return s.rparams }
 
 // SetRParams sets the receiver type params of signature s.
 func (s *Signature) SetRParams(rparams []*TypeName) { s.rparams = bindTParams(rparams) }

diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index ce8b4a7073321ec1cd02c91d7196cdc5d46917a8..63925049472107cba52096609b77699b8c0c2c20 100644 (file)
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -85,28 +85,28 @@ func (t *TypeParam) SetConstraint(bound Type) {
 func (t *TypeParam) Underlying() Type { return t }
 func (t *TypeParam) String() string   { return TypeString(t, nil) }
 
-// TypeParams holds a list of type parameters bound to a type.
-type TypeParams struct{ tparams []*TypeName }
+// TParamList holds a list of type parameters bound to a type.
+type TParamList struct{ tparams []*TypeName }
 
 // Len returns the number of type parameters in the list.
 // It is safe to call on a nil receiver.
-func (tps *TypeParams) Len() int {
+func (tps *TParamList) Len() int {
        return len(tps.list())
 }
 
 // At returns the i'th type parameter in the list.
-func (tps *TypeParams) At(i int) *TypeName {
+func (tps *TParamList) At(i int) *TypeName {
        return tps.list()[i]
 }
 
-func (tps *TypeParams) list() []*TypeName {
+func (tps *TParamList) list() []*TypeName {
        if tps == nil {
                return nil
        }
        return tps.tparams
 }
 
-func bindTParams(list []*TypeName) *TypeParams {
+func bindTParams(list []*TypeName) *TParamList {
        if len(list) == 0 {
                return nil
        }
@@ -117,7 +117,7 @@ func bindTParams(list []*TypeName) *TypeParams {
                }
                typ.index = i
        }
-       return &TypeParams{tparams: list}
+       return &TParamList{tparams: list}
 }
 
 // ----------------------------------------------------------------------------