mirror of
https://github.com/golang/go
synced 2024-09-04 15:34:21 +00:00
[dev.typeparams] cmd/compile: change types2.Union API to accept a list of Terms
Instead of providing a list of tildes and types, use a list of Terms to create a Union, with suitable accessors. Define the (exported) notion of a Term representing a union term. This simplified various uses and also will be easier to extend should we want to add more information to a Term in the future. Change-Id: I52fd73938bfa11bac60adbf10580b6d0680df4f1 Reviewed-on: https://go-review.googlesource.com/c/go/+/340250 Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
parent
09d82689ed
commit
0d7dc417ea
|
@ -677,13 +677,13 @@ func (r *importReader) doType(base *types2.Named) types2.Type {
|
|||
errorf("unexpected instantiation type")
|
||||
}
|
||||
nt := int(r.uint64())
|
||||
terms := make([]types2.Type, nt)
|
||||
tildes := make([]bool, nt)
|
||||
terms := make([]*types2.Term, nt)
|
||||
for i := range terms {
|
||||
terms[i] = r.typ()
|
||||
tildes[i] = r.bool()
|
||||
typ := r.typ()
|
||||
tilde := r.bool()
|
||||
terms[i] = types2.NewTerm(tilde, typ)
|
||||
}
|
||||
return types2.NewUnion(terms, tildes)
|
||||
return types2.NewUnion(terms)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -281,13 +281,13 @@ func (r *reader2) structType() *types2.Struct {
|
|||
}
|
||||
|
||||
func (r *reader2) unionType() *types2.Union {
|
||||
terms := make([]types2.Type, r.len())
|
||||
tildes := make([]bool, len(terms))
|
||||
terms := make([]*types2.Term, r.len())
|
||||
for i := range terms {
|
||||
terms[i] = r.typ()
|
||||
tildes[i] = r.bool()
|
||||
typ := r.typ()
|
||||
tilde := r.bool()
|
||||
terms[i] = types2.NewTerm(tilde, typ)
|
||||
}
|
||||
return types2.NewUnion(terms, tildes)
|
||||
return types2.NewUnion(terms)
|
||||
}
|
||||
|
||||
func (r *reader2) interfaceType() *types2.Interface {
|
||||
|
|
|
@ -232,13 +232,13 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
|
|||
return tp
|
||||
|
||||
case *types2.Union:
|
||||
nt := typ.NumTerms()
|
||||
nt := typ.Len()
|
||||
tlist := make([]*types.Type, nt)
|
||||
tildes := make([]bool, nt)
|
||||
for i := range tlist {
|
||||
term, tilde := typ.Term(i)
|
||||
tlist[i] = g.typ1(term)
|
||||
tildes[i] = tilde
|
||||
t := typ.Term(i)
|
||||
tlist[i] = g.typ1(t.Type())
|
||||
tildes[i] = t.Tilde()
|
||||
}
|
||||
return types.NewUnion(tlist, tildes)
|
||||
|
||||
|
|
|
@ -394,11 +394,11 @@ func (w *writer) structType(typ *types2.Struct) {
|
|||
}
|
||||
|
||||
func (w *writer) unionType(typ *types2.Union) {
|
||||
w.len(typ.NumTerms())
|
||||
for i := 0; i < typ.NumTerms(); i++ {
|
||||
term, tilde := typ.Term(i)
|
||||
w.typ(term)
|
||||
w.bool(tilde)
|
||||
w.len(typ.Len())
|
||||
for i := 0; i < typ.Len(); i++ {
|
||||
t := typ.Term(i)
|
||||
w.typ(t.Type())
|
||||
w.bool(t.Tilde())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -797,12 +797,10 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
|
|||
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
|
||||
|
@ -819,7 +817,7 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
|
|||
// 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
|
||||
|
|
|
@ -387,19 +387,19 @@ func (subst *subster) typeList(in []Type) (out []Type, copied bool) {
|
|||
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
|
||||
|
|
|
@ -359,7 +359,7 @@ func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *TypeSet {
|
|||
// This case is handled during union parsing.
|
||||
unreachable()
|
||||
default:
|
||||
terms = termlist{t}
|
||||
terms = termlist{(*term)(t)}
|
||||
}
|
||||
// The type set of a union expression is the union
|
||||
// of the type sets of each term.
|
||||
|
|
|
@ -129,7 +129,7 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
|
|||
case *Union:
|
||||
// Unions only appear as (syntactic) embedded elements
|
||||
// in interfaces and syntactically cannot be empty.
|
||||
if t.NumTerms() == 0 {
|
||||
if t.Len() == 0 {
|
||||
panic("empty union")
|
||||
}
|
||||
for i, t := range t.terms {
|
||||
|
|
|
@ -11,45 +11,46 @@ import "cmd/compile/internal/syntax"
|
|||
|
||||
// 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.
|
||||
|
@ -124,7 +125,7 @@ func parseTilde(check *Checker, x syntax.Expr) (tilde bool, typ Type) {
|
|||
// 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 {
|
||||
|
@ -132,7 +133,7 @@ func overlappingTerm(terms []*term, y *term) int {
|
|||
panic("empty or top union term")
|
||||
}
|
||||
}
|
||||
if !x.disjoint(y) {
|
||||
if !(*term)(x).disjoint((*term)(y)) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue