p.doDecl(localpkg, name)
}
+ for _, typ := range p.interfaceList {
+ typ.Complete()
+ }
+
// record all referenced packages as imports
list := append(([]*types.Package)(nil), pkgList[1:]...)
sort.Sort(byPath(list))
// IsConstraint reports whether interface t is not just a method set.
func (t *Interface) IsConstraint() bool { return !t.typeSet().IsMethodSet() }
-// Complete just returns its receiver. There's no other effect.
+// Complete computes the interface's type set. It must be called by users of
+// NewInterfaceType and NewInterface after the interface's embedded types are
+// fully defined and before using the interface type in any way other than to
+// form other types. The interface must not contain duplicate methods or a
+// panic occurs. Complete returns the receiver.
//
-// Deprecated: Interfaces are now completed on demand; this function is only
-// here for backward-compatibility. It does not have to be called explicitly
-// anymore.
+// Deprecated: Type sets are now computed lazily, on demand; this function
+// is only here for backward-compatibility. It does not have to
+// be called explicitly anymore.
func (t *Interface) Complete() *Interface {
+ // Some tests are still depending on the state change
+ // (string representation of an Interface not containing an
+ // /* incomplete */ marker) caused by the explicit Complete
+ // call, so we compute the type set eagerly here.
+ t.complete = true
+ t.typeSet()
return t
}
// create type interface { error }
et := Universe.Lookup("error").Type()
it := NewInterfaceType(nil, []Type{et})
+ it.Complete()
// verify that after completing the interface, the embedded method remains unchanged
- // (interfaces are "completed" lazily now, so the completion happens implicitly when
- // accessing Method(0))
want := et.Underlying().(*Interface).Method(0)
got := it.Method(0)
if got != want {