[dev.typeparams] go/types: introduce type set abstraction for interfaces

This is a port of CL 329309 to go/types, with minor updates for API
differences and to handle methodset.go, which doesn't exist in types2.

A couple pre-existing comments were adjusted to match types2.

Change-Id: I3fd556e1326013a694ff5edb8518ca24c27bd10b
Reviewed-on: https://go-review.googlesource.com/c/go/+/334894
Trust: Robert Findley <[email protected]>
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Go Bot <[email protected]>
Reviewed-by: Robert Griesemer <[email protected]>

Author: findleyr

src/go/types/api_typeparams.go

@@ -21,10 +21,6 @@ func NewTypeParam(obj *TypeName, index int, bound Type) *TypeParam {
 func (s *Signature) TParams() []*TypeName           { return s._TParams() }
 func (s *Signature) SetTParams(tparams []*TypeName) { s._SetTParams(tparams) }
 
-func (t *Interface) HasTypeList() bool  { return t._HasTypeList() }
-func (t *Interface) IsComparable() bool { return t._IsComparable() }
-func (t *Interface) IsConstraint() bool { return t._IsConstraint() }
-
 func (t *Named) TParams() []*TypeName { return t._TParams() }
 func (t *Named) TArgs() []Type        { return t._TArgs() }
 func (t *Named) SetTArgs(args []Type) { t._SetTArgs(args) }

src/go/types/builtins.go

@@ -785,7 +785,7 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
 		tpar := NewTypeName(token.NoPos, nil /* = Universe 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{allMethods: markComplete, allTypes: tsum}
+		ptyp.bound = &Interface{complete: true, tset: &TypeSet{types: tsum}}
 
 		return ptyp
 	}

src/go/types/call.go

@@ -109,8 +109,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 					break
 				}
 				if t := asInterface(T); t != nil {
-					check.completeInterface(token.NoPos, t)
-					if t._IsConstraint() {
+					if t.IsConstraint() {
 						check.errorf(call, _Todo, "cannot use interface %s in conversion (contains type list or is comparable)", T)
 						break
 					}

src/go/types/expr.go

@@ -682,7 +682,6 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 			return Typ[UntypedNil], nil, 0
 		}
 		// cannot assign untyped values to non-empty interfaces
-		check.completeInterface(token.NoPos, t)
 		if !t.Empty() {
 			return nil, nil, _InvalidUntypedConversion
 		}

src/go/types/infer.go

@@ -316,24 +316,13 @@ func (w *tpWalker) isParameterized(typ Type) (res bool) {
 		return w.isParameterized(t.params) || w.isParameterized(t.results)
 
 	case *Interface:
-		if t.allMethods != nil {
-			// TODO(rFindley) at some point we should enforce completeness here
-			for _, m := range t.allMethods {
-				if w.isParameterized(m.typ) {
-					return true
-				}
+		tset := t.typeSet()
+		for _, m := range tset.methods {
+			if w.isParameterized(m.typ) {
+				return true
 			}
-			return w.isParameterized(t.allTypes)
 		}
-
-		return t.iterate(func(t *Interface) bool {
-			for _, m := range t.methods {
-				if w.isParameterized(m.typ) {
-					return true
-				}
-			}
-			return w.isParameterizedList(t.embeddeds)
-		}, nil)
+		return w.isParameterized(tset.types)
 
 	case *Map:
 		return w.isParameterized(t.key) || w.isParameterized(t.elem)
@@ -471,15 +460,15 @@ func (check *Checker) inferB(tparams []*TypeName, targs []Type, report bool) (ty
 // structuralType returns the structural type of a constraint, if any.
 func (check *Checker) structuralType(constraint Type) Type {
 	if iface, _ := under(constraint).(*Interface); iface != nil {
-		check.completeInterface(token.NoPos, iface)
-		if u, _ := iface.allTypes.(*Union); u != nil {
+		types := iface.typeSet().types
+		if u, _ := types.(*Union); u != nil {
 			if u.NumTerms() == 1 {
 				// TODO(gri) do we need to respect tilde?
 				return u.types[0]
 			}
 			return nil
 		}
-		return iface.allTypes
+		return types
 	}
 	return nil
 }

src/go/types/interface.go

@@ -98,17 +98,24 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 		check.posMap[ityp] = append(check.posMap[ityp], tlist[0].(*ast.UnaryExpr).X.Pos())
 	}
 
+	// All methods and embedded elements for this interface are collected;
+	// i.e., this interface is may be used in a type set computation.
+	ityp.complete = true
+
 	if len(ityp.methods) == 0 && len(ityp.embeddeds) == 0 {
 		// empty interface
-		ityp.allMethods = markComplete
+		ityp.tset = &topTypeSet
 		return
 	}
 
 	// sort for API stability
 	sortMethods(ityp.methods)
 	sortTypes(ityp.embeddeds)
 
-	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
+	// Compute type set with a non-nil *Checker as soon as possible
+	// to report any errors. Subsequent uses of type sets should be
+	// using this computed type set and won't need to pass in a *Checker.
+	check.later(func() { newTypeSet(check, iface.Pos(), ityp) })
 }
 
 func flattenUnion(list []ast.Expr, x ast.Expr) []ast.Expr {
@@ -119,24 +126,26 @@ func flattenUnion(list []ast.Expr, x ast.Expr) []ast.Expr {
 	return append(list, x)
 }
 
-func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
-	if ityp.allMethods != nil {
-		return
+// newTypeSet may be called with check == nil.
+// TODO(gri) move this function into typeset.go eventually
+func newTypeSet(check *Checker, pos token.Pos, ityp *Interface) *TypeSet {
+	if ityp.tset != nil {
+		return ityp.tset
 	}
 
-	// completeInterface may be called via the LookupFieldOrMethod,
-	// MissingMethod, Identical, or IdenticalIgnoreTags external API
-	// in which case check will be nil. In this case, type-checking
-	// must be finished and all interfaces should have been completed.
-	if check == nil {
-		panic("internal error: incomplete interface")
+	// If the interface is not fully set up yet, the type set will
+	// not be complete, which may lead to errors when using the the
+	// type set (e.g. missing method). Don't compute a partial type
+	// set (and don't store it!), so that we still compute the full
+	// type set eventually. Instead, return the top type set and
+	// let any follow-on errors play out.
+	//
+	// TODO(gri) Consider recording when this happens and reporting
+	// it as an error (but only if there were no other errors so to
+	// to not have unnecessary follow-on errors).
+	if !ityp.complete {
+		return &topTypeSet
 	}
-	completeInterface(check, pos, ityp)
-}
-
-// completeInterface may be called with check == nil.
-func completeInterface(check *Checker, pos token.Pos, ityp *Interface) {
-	assert(ityp.allMethods == nil)
 
 	if check != nil && trace {
 		// Types don't generally have position information.
@@ -146,11 +155,11 @@ func completeInterface(check *Checker, pos token.Pos, ityp *Interface) {
 			pos = ityp.methods[0].pos
 		}
 
-		check.trace(pos, "complete %s", ityp)
+		check.trace(pos, "type set for %s", ityp)
 		check.indent++
 		defer func() {
 			check.indent--
-			check.trace(pos, "=> %s (methods = %v, types = %v)", ityp, ityp.allMethods, ityp.allTypes)
+			check.trace(pos, "=> %s ", ityp.typeSet())
 		}()
 	}
 
@@ -159,7 +168,7 @@ func completeInterface(check *Checker, pos token.Pos, ityp *Interface) {
 	// have valid interfaces. Mark the interface as complete to avoid
 	// infinite recursion if the validType check occurs later for some
 	// reason.
-	ityp.allMethods = markComplete
+	ityp.tset = new(TypeSet) // TODO(gri) is this sufficient?
 
 	// Methods of embedded interfaces are collected unchanged; i.e., the identity
 	// of a method I.m's Func Object of an interface I is the same as that of
@@ -229,14 +238,12 @@ func completeInterface(check *Checker, pos token.Pos, ityp *Interface) {
 		var types Type
 		switch t := under(typ).(type) {
 		case *Interface:
-			if t.allMethods == nil {
-				completeInterface(check, pos, t)
-			}
-			for _, m := range t.allMethods {
+			tset := newTypeSet(check, pos, t)
+			for _, m := range tset.methods {
 				addMethod(pos, m, false) // use embedding position pos rather than m.pos
 
 			}
-			types = t.allTypes
+			types = tset.types
 		case *Union:
 			// TODO(gri) combine with default case once we have
 			//           converted all tests to new notation and we
@@ -273,9 +280,11 @@ func completeInterface(check *Checker, pos token.Pos, ityp *Interface) {
 
 	if methods != nil {
 		sort.Sort(byUniqueMethodName(methods))
-		ityp.allMethods = methods
+		ityp.tset.methods = methods
 	}
-	ityp.allTypes = allTypes
+	ityp.tset.types = allTypes
+
+	return ityp.tset
 }
 
 func sortTypes(list []Type) {

src/go/types/lookup.go

@@ -186,9 +186,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 
 			case *Interface:
 				// look for a matching method
-				// TODO(gri) t.allMethods is sorted - use binary search
-				check.completeInterface(token.NoPos, t)
-				if i, m := lookupMethod(t.allMethods, pkg, name); m != nil {
+				if i, m := t.typeSet().LookupMethod(pkg, name); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
 					if obj != nil || e.multiples {
@@ -199,9 +197,7 @@ func (check *Checker) rawLookupFieldOrMethod(T Type, addressable bool, pkg *Pack
 				}
 
 			case *_TypeParam:
-				// only consider explicit methods in the type parameter bound, not
-				// methods that may be common to all types in the type list.
-				if i, m := lookupMethod(t.Bound().allMethods, pkg, name); m != nil {
+				if i, m := t.Bound().typeSet().LookupMethod(pkg, name); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
 					if obj != nil || e.multiples {
@@ -307,18 +303,15 @@ func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType b
 // To improve error messages, also report the wrong signature
 // when the method exists on *V instead of V.
 func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, wrongType *Func) {
-	check.completeInterface(token.NoPos, T)
-
 	// fast path for common case
 	if T.Empty() {
 		return
 	}
 
 	if ityp := asInterface(V); ityp != nil {
-		check.completeInterface(token.NoPos, ityp)
-		// TODO(gri) allMethods is sorted - can do this more efficiently
-		for _, m := range T.allMethods {
-			_, f := lookupMethod(ityp.allMethods, m.pkg, m.name)
+		// TODO(gri) the methods are sorted - could do this more efficiently
+		for _, m := range T.typeSet().methods {
+			_, f := ityp.typeSet().LookupMethod(m.pkg, m.name)
 
 			if f == nil {
 				// if m is the magic method == we're ok (interfaces are comparable)
@@ -356,7 +349,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 	// A concrete type implements T if it implements all methods of T.
 	Vd, _ := deref(V)
 	Vn := asNamed(Vd)
-	for _, m := range T.allMethods {
+	for _, m := range T.typeSet().methods {
 		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
 		obj, _, _ := check.rawLookupFieldOrMethod(V, false, m.pkg, m.name)
 

src/go/types/methodset.go

@@ -157,10 +157,10 @@ func NewMethodSet(T Type) *MethodSet {
 				}
 
 			case *Interface:
-				mset = mset.add(t.allMethods, e.index, true, e.multiples)
+				mset = mset.add(t.typeSet().methods, e.index, true, e.multiples)
 
 			case *_TypeParam:
-				mset = mset.add(t.Bound().allMethods, e.index, true, e.multiples)
+				mset = mset.add(t.Bound().typeSet().methods, e.index, true, e.multiples)
 			}
 		}
 

src/go/types/predicates.go

@@ -6,10 +6,6 @@
 
 package types
 
-import (
-	"go/token"
-)
-
 // isNamed reports whether typ has a name.
 // isNamed may be called with types that are not fully set up.
 func isNamed(typ Type) bool {
@@ -109,7 +105,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 	//
 	// is not comparable because []byte is not comparable.
 	if t := asTypeParam(T); t != nil && optype(t) == theTop {
-		return t.Bound()._IsComparable()
+		return t.Bound().IsComparable()
 	}
 
 	switch t := optype(T).(type) {
@@ -133,7 +129,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 			return comparable(t, seen)
 		})
 	case *_TypeParam:
-		return t.Bound()._IsComparable()
+		return t.Bound().IsComparable()
 	}
 	return false
 }
@@ -291,16 +287,8 @@ func (check *Checker) identical0(x, y Type, cmpTags bool, p *ifacePair) bool {
 		// the same names and identical function types. Lower-case method names from
 		// different packages are always different. The order of the methods is irrelevant.
 		if y, ok := y.(*Interface); ok {
-			// If identical0 is called (indirectly) via an external API entry point
-			// (such as Identical, IdenticalIgnoreTags, etc.), check is nil. But in
-			// that case, interfaces are expected to be complete and lazy completion
-			// here is not needed.
-			if check != nil {
-				check.completeInterface(token.NoPos, x)
-				check.completeInterface(token.NoPos, y)
-			}
-			a := x.allMethods
-			b := y.allMethods
+			a := x.typeSet().methods
+			b := y.typeSet().methods
 			if len(a) == len(b) {
 				// Interface types are the only types where cycles can occur
 				// that are not "terminated" via named types; and such cycles

src/go/types/sanitize.go

@@ -113,9 +113,11 @@ func (s sanitizer) typ(typ Type) Type {
 	case *Interface:
 		s.funcList(t.methods)
 		s.typeList(t.embeddeds)
-		s.funcList(t.allMethods)
-		if allTypes := s.typ(t.allTypes); allTypes != t.allTypes {
-			t.allTypes = allTypes
+		// TODO(gri) do we need to sanitize type sets?
+		tset := t.typeSet()
+		s.funcList(tset.methods)
+		if types := s.typ(tset.types); types != tset.types {
+			tset.types = types
 		}
 
 	case *Map:

src/go/types/sizeof_test.go

@@ -27,7 +27,7 @@ func TestSizeof(t *testing.T) {
 		{Tuple{}, 12, 24},
 		{Signature{}, 44, 88},
 		{Union{}, 24, 48},
-		{Interface{}, 52, 104},
+		{Interface{}, 40, 80},
 		{Map{}, 16, 32},
 		{Chan{}, 12, 24},
 		{Named{}, 84, 160},
@@ -48,6 +48,7 @@ func TestSizeof(t *testing.T) {
 		// Misc
 		{Scope{}, 40, 80},
 		{Package{}, 40, 80},
+		{TypeSet{}, 20, 40},
 	}
 	for _, test := range tests {
 		got := reflect.TypeOf(test.val).Size()