if tp := asTypeParam(x); tp != nil {
// Test if t satisfies the requirements for the argument
// type and collect possible result types at the same time.
- var rtypes []Type
- var tildes []bool
+ var terms []*Term
if !tp.iface().typeSet().is(func(t *term) bool {
if r := f(t.typ); r != nil {
- rtypes = append(rtypes, r)
- tildes = append(tildes, t.tilde)
+ terms = append(terms, NewTerm(t.tilde, r))
return true
}
return false
// type param is placed in the current package so export/import
// works as expected.
tpar := NewTypeName(nopos, check.pkg, "<type parameter>", nil)
- ptyp := check.NewTypeParam(tpar, NewInterfaceType(nil, []Type{newUnion(rtypes, tildes)})) // assigns type to tpar as a side-effect
+ ptyp := check.NewTypeParam(tpar, NewInterfaceType(nil, []Type{NewUnion(terms)})) // assigns type to tpar as a side-effect
ptyp.index = tp.index
return ptyp
return
}
-func (subst *subster) termlist(in []*term) (out []*term, copied bool) {
+func (subst *subster) termlist(in []*Term) (out []*Term, copied bool) {
out = in
for i, t := range in {
if u := subst.typ(t.typ); u != t.typ {
if !copied {
// first function that got substituted => allocate new out slice
// and copy all functions
- new := make([]*term, len(in))
+ new := make([]*Term, len(in))
copy(new, out)
out = new
copied = true
}
- out[i] = &term{t.tilde, u}
+ out[i] = NewTerm(t.tilde, u)
}
}
return
// A Union represents a union of terms embedded in an interface.
type Union struct {
- terms []*term // list of syntactical terms (not a canonicalized termlist)
+ terms []*Term // list of syntactical terms (not a canonicalized termlist)
tset *TypeSet // type set described by this union, computed lazily
}
-// NewUnion returns a new Union type with the given terms (types[i], tilde[i]).
-// The lengths of both arguments must match. It is an error to create an empty
-// union; they are syntactically not possible.
-func NewUnion(types []Type, tilde []bool) *Union { return newUnion(types, tilde) }
+// NewUnion returns a new Union type with the given terms.
+// It is an error to create an empty union; they are syntactically not possible.
+func NewUnion(terms []*Term) *Union {
+ if len(terms) == 0 {
+ panic("empty union")
+ }
+ return &Union{terms, nil}
+}
-func (u *Union) NumTerms() int { return len(u.terms) }
-func (u *Union) Term(i int) (Type, bool) { t := u.terms[i]; return t.typ, t.tilde }
+func (u *Union) Len() int { return len(u.terms) }
+func (u *Union) Term(i int) *Term { return u.terms[i] }
func (u *Union) Underlying() Type { return u }
func (u *Union) String() string { return TypeString(u, nil) }
+// A Term represents a term in a Union.
+type Term term
+
+// NewTerm returns a new union term.
+func NewTerm(tilde bool, typ Type) *Term { return &Term{tilde, typ} }
+
+func (t *Term) Tilde() bool { return t.tilde }
+func (t *Term) Type() Type { return t.typ }
+func (t *Term) String() string { return (*term)(t).String() }
+
// ----------------------------------------------------------------------------
// Implementation
-func newUnion(types []Type, tilde []bool) *Union {
- assert(len(types) == len(tilde))
- if len(types) == 0 {
- panic("empty union")
- }
- t := new(Union)
- t.terms = make([]*term, len(types))
- for i, typ := range types {
- t.terms[i] = &term{tilde[i], typ}
- }
- return t
-}
-
func parseUnion(check *Checker, tlist []syntax.Expr) Type {
- var terms []*term
+ var terms []*Term
for _, x := range tlist {
tilde, typ := parseTilde(check, x)
if len(tlist) == 1 && !tilde {
return typ // single type
}
- terms = append(terms, &term{tilde, typ})
+ terms = append(terms, NewTerm(tilde, typ))
}
// Check validity of terms.
// overlappingTerm reports the index of the term x in terms which is
// overlapping (not disjoint) from y. The result is < 0 if there is no
// such term.
-func overlappingTerm(terms []*term, y *term) int {
+func overlappingTerm(terms []*Term, y *Term) int {
for i, x := range terms {
// disjoint requires non-nil, non-top arguments
if debug {
panic("empty or top union term")
}
}
- if !x.disjoint(y) {
+ if !(*term)(x).disjoint((*term)(y)) {
return i
}
}