[dev.typeparams] go/types: update TypeParam APIs to match types2

This is a partial port of CL 323029, consisting only of changes to
go/types. Changes to the importer will be made in a separate CL.

Change-Id: I3b300f5e8f4df36c2c87e3f164705cd3c36218ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/335145
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/builtins.go b/src/go/types/builtins.go
index 9b2a75458cb6a4146fafca1deccd733569aab6a6..2573bac69ec6bd78f91a11ce0c1f773ba36e1c31 100644 (file)
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -783,9 +783,11 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
                        return nil
                }
 
-               // construct a suitable new type parameter
-               tpar := NewTypeName(token.NoPos, nil /* = Universe pkg */, "<type parameter>", nil)
-               ptyp := check.newTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
+               // Construct a suitable new type parameter for the sum type. The
+               // type param is placed in the current package so export/import
+               // works as expected.
+               tpar := NewTypeName(token.NoPos, check.pkg, "<type parameter>", nil)
+               ptyp := check.NewTypeParam(tpar, 0, &emptyInterface) // assigns type to tpar as a side-effect
                tsum := newUnion(rtypes, tildes)
                ptyp.bound = &Interface{complete: true, tset: &TypeSet{types: tsum}}
 

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 921530595a3c9315cb360aa27af7266da6471b33..d68070d0498bbc540ce1cc9b2c175c1721d36fe6 100644 (file)
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -758,7 +758,7 @@ func (check *Checker) collectTypeParams(list *ast.FieldList) []*TypeName {
 func (check *Checker) declareTypeParams(tparams []*TypeName, names []*ast.Ident) []*TypeName {
        for _, name := range names {
                tpar := NewTypeName(name.Pos(), check.pkg, name.Name, nil)
-               check.newTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
+               check.NewTypeParam(tpar, len(tparams), &emptyInterface) // assigns type to tpar as a side-effect
                check.declare(check.scope, name, tpar, check.scope.pos) // TODO(gri) check scope position
                tparams = append(tparams, tpar)
        }

diff --git a/src/go/types/type.go b/src/go/types/type.go
index 0a6fff0dcabcd79171214ee49e67d1d778bfc096..e0498fece2689b8e9cf941784d215f224e8a7a5c 100644 (file)
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -41,11 +41,13 @@ func under(t Type) Type {
        return t
 }
 
-// optype returns a type's operational type. Except for type parameters,
-// the operational type is the same as the underlying type (as returned
-// by under). For Type parameters, the operational type is determined
-// by the corresponding type constraint. The result may be the top type,
-// but it is never the incoming type parameter.
+// optype returns a type's operational type. Except for
+// type parameters, the operational type is the same
+// as the underlying type (as returned by under). For
+// Type parameters, the operational type is determined
+// by the corresponding type bound's type list. The
+// result may be the bottom or top type, but it is never
+// the incoming type parameter.
 func optype(typ Type) Type {
        if t := asTypeParam(typ); t != nil {
                // If the optype is typ, return the top type as we have

diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index 89ac3ecf38fdffc9bfa06441f2c54df4d528064d..e42c24f8cbe083d0a257d05a0a9d89e0e6fe78d6 100644 (file)
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -27,22 +27,14 @@ type TypeParam struct {
        bound Type      // *Named or *Interface; underlying type is always *Interface
 }
 
-// NewTypeParam returns a new TypeParam.
-func NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
-       return (*Checker)(nil).newTypeParam(obj, index, bound)
-}
-
-// TODO(rfindley): this is factored slightly differently in types2.
-func (check *Checker) newTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
-       assert(bound != nil)
-
+// NewTypeParam returns a new TypeParam.  bound can be nil (and set later).
+func (check *Checker) NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
        // Always increment lastID, even if it is not used.
        id := nextID()
        if check != nil {
                check.nextID++
                id = check.nextID
        }
-
        typ := &TypeParam{check: check, id: id, obj: obj, index: index, bound: bound}
        if obj.typ == nil {
                obj.typ = typ
@@ -79,6 +71,13 @@ func (t *TypeParam) Bound() *Interface {
        return iface
 }
 
+func (t *TypeParam) _SetBound(bound Type) {
+       if bound == nil {
+               panic("internal error: bound must not be nil")
+       }
+       t.bound = bound
+}
+
 func (t *TypeParam) Underlying() Type { return t }
 func (t *TypeParam) String() string   { return TypeString(t, nil) }