Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[dev.typeparams] cmd/compile/internal/types2: better names for things (cleanup)

Browse source 
- use the symbol 𝓀 (as in 𝓀niverse) instead of ⊀ to denote the set
  of all types (for better readabilty, ⊀ is hard to distinguish from
  T in some fonts)

- use isAll instead of isTop to test for the set of all types

- use allTermlist instead of topTermlist to denote the termlist
  representing all types

Change-Id: Idcb0b3398782b38653338e65173c0dbb935e430a
Reviewed-on: https://go-review.googlesource.com/c/go/+/339891
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:
Robert Griesemer 2021-08-04 15:18:37 -07:00
parent 110343e4a2
commit 5aac85ad5e
8 changed files with 100 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/cmd/compile/internal/types2/instantiate.go
View file

@ -174,7 +174,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
// if iface is comparable, targ must be comparable // if iface is comparable, targ must be comparable
// TODO(gri) the error messages needs to be better, here // TODO(gri) the error messages needs to be better, here
if iface.IsComparable() && !Comparable(targ) { if iface.IsComparable() && !Comparable(targ) {
if tpar := asTypeParam(targ); tpar != nil && tpar.iface().typeSet().IsTop() { if tpar := asTypeParam(targ); tpar != nil && tpar.iface().typeSet().IsAll() {
check.softErrorf(pos, "%s has no constraints", targ) check.softErrorf(pos, "%s has no constraints", targ)
return false return false
} }

2
src/cmd/compile/internal/types2/interface.go
View file

@ -92,7 +92,7 @@ func (t *Interface) NumMethods() int { return t.typeSet().NumMethods() }
func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) } func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) }
// Empty reports whether t is the empty interface. // Empty reports whether t is the empty interface.
func (t *Interface) Empty() bool { return t.typeSet().IsTop() } func (t *Interface) Empty() bool { return t.typeSet().IsAll() }
// IsComparable reports whether each type in interface t's type set is comparable. // IsComparable reports whether each type in interface t's type set is comparable.
func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() } func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() }

22
src/cmd/compile/internal/types2/termlist.go
View file

@ -13,9 +13,9 @@ import "bytes"
// normal form. // normal form.
type termlist []*term type termlist []*term
// topTermlist represents the set of all types. // allTermlist represents the set of all types.
// It is in normal form. // It is in normal form.
var topTermlist = termlist{new(term)} var allTermlist = termlist{new(term)}
// String prints the termlist exactly (without normalization). // String prints the termlist exactly (without normalization).
func (xl termlist) String() string { func (xl termlist) String() string {
@ -45,9 +45,9 @@ func (xl termlist) isEmpty() bool {
return true return true
} }
// isTop reports whether the termlist xl represents the set of all types. // isAll reports whether the termlist xl represents the set of all types.
func (xl termlist) isTop() bool { func (xl termlist) isAll() bool {
// If there's a ⊀ (top) term, the entire list is ⊀ (top). // If there's a 𝓀 term, the entire list is 𝓀.
// If the termlist is in normal form, this requires at most // If the termlist is in normal form, this requires at most
// one iteration. // one iteration.
for _, x := range xl { for _, x := range xl {
@ -74,14 +74,14 @@ func (xl termlist) norm() termlist {
continue continue
} }
if u1, u2 := xi.union(xj); u2 == nil { if u1, u2 := xi.union(xj); u2 == nil {
// If we encounter a ⊀ (top) term, the entire // If we encounter a 𝓀 term, the entire list is 𝓀.
// list is ⊀ (top). Exit early. // Exit early.
// (Note that this is not just an optimization; // (Note that this is not just an optimization;
// if we continue, we may end up with a ⊀ term // if we continue, we may end up with a 𝓀 term
// and other terms and the result would not be // and other terms and the result would not be
// in normal form.) // in normal form.)
if u1.typ == nil { if u1.typ == nil {
return topTermlist return allTermlist
} }
xi = u1 xi = u1
used[j] = true // xj is now unioned into xi - ignore it in future iterations used[j] = true // xj is now unioned into xi - ignore it in future iterations
@ -92,11 +92,11 @@ func (xl termlist) norm() termlist {
return rl return rl
} }
// If the type set represented by xl is specified by a single (non-⊀) term, // If the type set represented by xl is specified by a single (non-𝓀) term,
// structuralType returns that type. Otherwise it returns nil. // structuralType returns that type. Otherwise it returns nil.
func (xl termlist) structuralType() Type { func (xl termlist) structuralType() Type {
if nl := xl.norm(); len(nl) == 1 { if nl := xl.norm(); len(nl) == 1 {
return nl[0].typ // if nl.isTop() then typ is nil, which is ok return nl[0].typ // if nl.isAll() then typ is nil, which is ok
} }
return nil return nil
} }

78
src/cmd/compile/internal/types2/termlist_test.go
View file

@ -21,20 +21,20 @@ func maketl(s string) termlist {
} }
func TestTermlistTop(t *testing.T) { func TestTermlistTop(t *testing.T) {
if !topTermlist.isTop() { if !allTermlist.isAll() {
t.Errorf("topTermlist is not top") t.Errorf("allTermlist is not the set of all types")
} }
} }
func TestTermlistString(t *testing.T) { func TestTermlistString(t *testing.T) {
for _, want := range []string{ for _, want := range []string{
"βˆ…", "βˆ…",
"⊀", "𝓀",
"int", "int",
"~int", "~int",
"βˆ… βˆͺ βˆ…", "βˆ… βˆͺ βˆ…",
"⊀ βˆͺ ⊀", "𝓀 βˆͺ 𝓀",
"βˆ… βˆͺ ⊀ βˆͺ int", "βˆ… βˆͺ 𝓀 βˆͺ int",
} { } {
if got := maketl(want).String(); got != want { if got := maketl(want).String(); got != want {
t.Errorf("(%v).String() == %v", want, got) t.Errorf("(%v).String() == %v", want, got)
@ -46,9 +46,9 @@ func TestTermlistIsEmpty(t *testing.T) {
for test, want := range map[string]bool{ for test, want := range map[string]bool{
"βˆ…": true, "βˆ…": true,
"βˆ… βˆͺ βˆ…": true, "βˆ… βˆͺ βˆ…": true,
"βˆ… βˆͺ βˆ… βˆͺ ⊀": false, "βˆ… βˆͺ βˆ… βˆͺ 𝓀": false,
"⊀": false, "𝓀": false,
"⊀ βˆͺ int": false, "𝓀 βˆͺ int": false,
} { } {
xl := maketl(test) xl := maketl(test)
got := xl.isEmpty() got := xl.isEmpty()
@ -58,19 +58,19 @@ func TestTermlistIsEmpty(t *testing.T) {
} }
} }
func TestTermlistIsTop(t *testing.T) { func TestTermlistIsAll(t *testing.T) {
for test, want := range map[string]bool{ for test, want := range map[string]bool{
"βˆ…": false, "βˆ…": false,
"βˆ… βˆͺ βˆ…": false, "βˆ… βˆͺ βˆ…": false,
"int βˆͺ ~string": false, "int βˆͺ ~string": false,
"βˆ… βˆͺ βˆ… βˆͺ ⊀": true, "βˆ… βˆͺ βˆ… βˆͺ 𝓀": true,
"⊀": true, "𝓀": true,
"⊀ βˆͺ int": true, "𝓀 βˆͺ int": true,
} { } {
xl := maketl(test) xl := maketl(test)
got := xl.isTop() got := xl.isAll()
if got != want { if got != want {
t.Errorf("(%v).isTop() == %v; want %v", test, got, want) t.Errorf("(%v).isAll() == %v; want %v", test, got, want)
} }
} }
} }
@ -82,10 +82,10 @@ func TestTermlistNorm(t *testing.T) {
{"βˆ…", "βˆ…"}, {"βˆ…", "βˆ…"},
{"βˆ… βˆͺ βˆ…", "βˆ…"}, {"βˆ… βˆͺ βˆ…", "βˆ…"},
{"βˆ… βˆͺ int", "int"}, {"βˆ… βˆͺ int", "int"},
{"⊀ βˆͺ int", "⊀"}, {"𝓀 βˆͺ int", "𝓀"},
{"~int βˆͺ int", "~int"}, {"~int βˆͺ int", "~int"},
{"int βˆͺ ~string βˆͺ int", "int βˆͺ ~string"}, {"int βˆͺ ~string βˆͺ int", "int βˆͺ ~string"},
{"~int βˆͺ string βˆͺ ⊀ βˆͺ ~string βˆͺ int", "⊀"}, {"~int βˆͺ string βˆͺ 𝓀 βˆͺ ~string βˆͺ int", "𝓀"},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)
got := maketl(test.xl).norm() got := maketl(test.xl).norm()
@ -106,7 +106,7 @@ func TestTermlistStructuralType(t *testing.T) {
for test, want := range map[string]string{ for test, want := range map[string]string{
"βˆ…": "nil", "βˆ…": "nil",
"⊀": "nil", "𝓀": "nil",
"int": "int", "int": "int",
"~int": "int", "~int": "int",
"~int βˆͺ string": "nil", "~int βˆͺ string": "nil",
@ -128,15 +128,15 @@ func TestTermlistUnion(t *testing.T) {
}{ }{
{"βˆ…", "βˆ…", "βˆ…"}, {"βˆ…", "βˆ…", "βˆ…"},
{"βˆ…", "⊀", "⊀"}, {"βˆ…", "𝓀", "𝓀"},
{"βˆ…", "int", "int"}, {"βˆ…", "int", "int"},
{"⊀", "~int", "⊀"}, {"𝓀", "~int", "𝓀"},
{"int", "~int", "~int"}, {"int", "~int", "~int"},
{"int", "string", "int βˆͺ string"}, {"int", "string", "int βˆͺ string"},
{"int βˆͺ string", "~string", "int βˆͺ ~string"}, {"int βˆͺ string", "~string", "int βˆͺ ~string"},
{"~int βˆͺ string", "~string βˆͺ int", "~int βˆͺ ~string"}, {"~int βˆͺ string", "~string βˆͺ int", "~int βˆͺ ~string"},
{"~int βˆͺ string βˆͺ βˆ…", "~string βˆͺ int", "~int βˆͺ ~string"}, {"~int βˆͺ string βˆͺ βˆ…", "~string βˆͺ int", "~int βˆͺ ~string"},
{"~int βˆͺ string βˆͺ ⊀", "~string βˆͺ int", "⊀"}, {"~int βˆͺ string βˆͺ 𝓀", "~string βˆͺ int", "𝓀"},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)
yl := maketl(test.yl) yl := maketl(test.yl)
@ -153,15 +153,15 @@ func TestTermlistIntersect(t *testing.T) {
}{ }{
{"βˆ…", "βˆ…", "βˆ…"}, {"βˆ…", "βˆ…", "βˆ…"},
{"βˆ…", "⊀", "βˆ…"}, {"βˆ…", "𝓀", "βˆ…"},
{"βˆ…", "int", "βˆ…"}, {"βˆ…", "int", "βˆ…"},
{"⊀", "~int", "~int"}, {"𝓀", "~int", "~int"},
{"int", "~int", "int"}, {"int", "~int", "int"},
{"int", "string", "βˆ…"}, {"int", "string", "βˆ…"},
{"int βˆͺ string", "~string", "string"}, {"int βˆͺ string", "~string", "string"},
{"~int βˆͺ string", "~string βˆͺ int", "int βˆͺ string"}, {"~int βˆͺ string", "~string βˆͺ int", "int βˆͺ string"},
{"~int βˆͺ string βˆͺ βˆ…", "~string βˆͺ int", "int βˆͺ string"}, {"~int βˆͺ string βˆͺ βˆ…", "~string βˆͺ int", "int βˆͺ string"},
{"~int βˆͺ string βˆͺ ⊀", "~string βˆͺ int", "int βˆͺ ~string"}, {"~int βˆͺ string βˆͺ 𝓀", "~string βˆͺ int", "int βˆͺ ~string"},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)
yl := maketl(test.yl) yl := maketl(test.yl)
@ -178,10 +178,10 @@ func TestTermlistEqual(t *testing.T) {
want bool want bool
}{ }{
{"βˆ…", "βˆ…", true}, {"βˆ…", "βˆ…", true},
{"βˆ…", "⊀", false}, {"βˆ…", "𝓀", false},
{"⊀", "⊀", true}, {"𝓀", "𝓀", true},
{"⊀ βˆͺ int", "⊀", true}, {"𝓀 βˆͺ int", "𝓀", true},
{"⊀ βˆͺ int", "string βˆͺ ⊀", true}, {"𝓀 βˆͺ int", "string βˆͺ 𝓀", true},
{"int βˆͺ ~string", "string βˆͺ int", false}, {"int βˆͺ ~string", "string βˆͺ int", false},
{"int βˆͺ ~string βˆͺ βˆ…", "string βˆͺ int βˆͺ ~string", true}, {"int βˆͺ ~string βˆͺ βˆ…", "string βˆͺ int βˆͺ ~string", true},
} { } {
@ -200,14 +200,14 @@ func TestTermlistIncludes(t *testing.T) {
want bool want bool
}{ }{
{"βˆ…", "int", false}, {"βˆ…", "int", false},
{"⊀", "int", true}, {"𝓀", "int", true},
{"~int", "int", true}, {"~int", "int", true},
{"int", "string", false}, {"int", "string", false},
{"~int", "string", false}, {"~int", "string", false},
{"int βˆͺ string", "string", true}, {"int βˆͺ string", "string", true},
{"~int βˆͺ string", "int", true}, {"~int βˆͺ string", "int", true},
{"~int βˆͺ string βˆͺ βˆ…", "string", true}, {"~int βˆͺ string βˆͺ βˆ…", "string", true},
{"~string βˆͺ βˆ… βˆͺ ⊀", "int", true}, {"~string βˆͺ βˆ… βˆͺ 𝓀", "int", true},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)
yl := testTerm(test.typ).typ yl := testTerm(test.typ).typ
@ -224,12 +224,12 @@ func TestTermlistSupersetOf(t *testing.T) {
want bool want bool
}{ }{
{"βˆ…", "βˆ…", true}, {"βˆ…", "βˆ…", true},
{"βˆ…", "⊀", false}, {"βˆ…", "𝓀", false},
{"βˆ…", "int", false}, {"βˆ…", "int", false},
{"⊀", "βˆ…", true}, {"𝓀", "βˆ…", true},
{"⊀", "⊀", true}, {"𝓀", "𝓀", true},
{"⊀", "int", true}, {"𝓀", "int", true},
{"⊀", "~int", true}, {"𝓀", "~int", true},
{"~int", "int", true}, {"~int", "int", true},
{"~int", "~int", true}, {"~int", "~int", true},
{"int", "~int", false}, {"int", "~int", false},
@ -239,7 +239,7 @@ func TestTermlistSupersetOf(t *testing.T) {
{"int βˆͺ string", "~string", false}, {"int βˆͺ string", "~string", false},
{"~int βˆͺ string", "int", true}, {"~int βˆͺ string", "int", true},
{"~int βˆͺ string βˆͺ βˆ…", "string", true}, {"~int βˆͺ string βˆͺ βˆ…", "string", true},
{"~string βˆͺ βˆ… βˆͺ ⊀", "int", true}, {"~string βˆͺ βˆ… βˆͺ 𝓀", "int", true},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)
y := testTerm(test.typ) y := testTerm(test.typ)
@ -256,16 +256,16 @@ func TestTermlistSubsetOf(t *testing.T) {
want bool want bool
}{ }{
{"βˆ…", "βˆ…", true}, {"βˆ…", "βˆ…", true},
{"βˆ…", "⊀", true}, {"βˆ…", "𝓀", true},
{"⊀", "βˆ…", false}, {"𝓀", "βˆ…", false},
{"⊀", "⊀", true}, {"𝓀", "𝓀", true},
{"int", "int βˆͺ string", true}, {"int", "int βˆͺ string", true},
{"~int", "int βˆͺ string", false}, {"~int", "int βˆͺ string", false},
{"~int", "string βˆͺ string βˆͺ int βˆͺ ~int", true}, {"~int", "string βˆͺ string βˆͺ int βˆͺ ~int", true},
{"int βˆͺ string", "string", false}, {"int βˆͺ string", "string", false},
{"int βˆͺ string", "string βˆͺ int", true}, {"int βˆͺ string", "string βˆͺ int", true},
{"int βˆͺ ~string", "string βˆͺ int", false}, {"int βˆͺ ~string", "string βˆͺ int", false},
{"int βˆͺ ~string", "string βˆͺ int βˆͺ ⊀", true}, {"int βˆͺ ~string", "string βˆͺ int βˆͺ 𝓀", true},
{"int βˆͺ ~string", "string βˆͺ int βˆͺ βˆ… βˆͺ string", false}, {"int βˆͺ ~string", "string βˆͺ int βˆͺ βˆ… βˆͺ string", false},
} { } {
xl := maketl(test.xl) xl := maketl(test.xl)

22
src/cmd/compile/internal/types2/typeset.go
View file

@ -25,17 +25,19 @@ type TypeSet struct {
// IsEmpty reports whether type set s is the empty set. // IsEmpty reports whether type set s is the empty set.
func (s *TypeSet) IsEmpty() bool { return s.terms.isEmpty() } func (s *TypeSet) IsEmpty() bool { return s.terms.isEmpty() }
// IsTop reports whether type set s is the set of all types (corresponding to the empty interface). // IsAll reports whether type set s is the set of all types (corresponding to the empty interface).
func (s *TypeSet) IsTop() bool { return !s.comparable && len(s.methods) == 0 && s.terms.isTop() } func (s *TypeSet) IsAll() bool {
return !s.comparable && len(s.methods) == 0 && s.terms.isAll()
}
// TODO(gri) IsMethodSet is not a great name for this predicate. Find a better one. // TODO(gri) IsMethodSet is not a great name for this predicate. Find a better one.
// IsMethodSet reports whether the type set s is described by a single set of methods. // IsMethodSet reports whether the type set s is described by a single set of methods.
func (s *TypeSet) IsMethodSet() bool { return !s.comparable && s.terms.isTop() } func (s *TypeSet) IsMethodSet() bool { return !s.comparable && s.terms.isAll() }
// IsComparable reports whether each type in the set is comparable. // IsComparable reports whether each type in the set is comparable.
func (s *TypeSet) IsComparable() bool { func (s *TypeSet) IsComparable() bool {
if s.terms.isTop() { if s.terms.isAll() {
return s.comparable return s.comparable
} }
return s.is(func(t *term) bool { return s.is(func(t *term) bool {
@ -67,8 +69,8 @@ func (s *TypeSet) String() string {
switch { switch {
case s.IsEmpty(): case s.IsEmpty():
return "βˆ…" return "βˆ…"
case s.IsTop(): case s.IsAll():
return "⊀" return "𝓀"
} }
hasMethods := len(s.methods) > 0 hasMethods := len(s.methods) > 0
@ -103,7 +105,7 @@ func (s *TypeSet) String() string {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Implementation // Implementation
func (s *TypeSet) hasTerms() bool { return !s.terms.isTop() } func (s *TypeSet) hasTerms() bool { return !s.terms.isAll() }
func (s *TypeSet) structuralType() Type { return s.terms.structuralType() } func (s *TypeSet) structuralType() Type { return s.terms.structuralType() }
func (s *TypeSet) includes(t Type) bool { return s.terms.includes(t) } func (s *TypeSet) includes(t Type) bool { return s.terms.includes(t) }
func (s1 *TypeSet) subsetOf(s2 *TypeSet) bool { return s1.terms.subsetOf(s2.terms) } func (s1 *TypeSet) subsetOf(s2 *TypeSet) bool { return s1.terms.subsetOf(s2.terms) }
@ -156,7 +158,7 @@ func (s *TypeSet) underIs(f func(Type) bool) bool {
} }
// topTypeSet may be used as type set for the empty interface. // topTypeSet may be used as type set for the empty interface.
var topTypeSet = TypeSet{terms: topTermlist} var topTypeSet = TypeSet{terms: allTermlist}
// computeInterfaceTypeSet may be called with check == nil. // computeInterfaceTypeSet may be called with check == nil.
func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *TypeSet { func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *TypeSet {
@ -195,7 +197,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *T
// have valid interfaces. Mark the interface as complete to avoid // have valid interfaces. Mark the interface as complete to avoid
// infinite recursion if the validType check occurs later for some // infinite recursion if the validType check occurs later for some
// reason. // reason.
ityp.tset = &TypeSet{terms: topTermlist} // TODO(gri) is this sufficient? ityp.tset = &TypeSet{terms: allTermlist} // TODO(gri) is this sufficient?
// Methods of embedded interfaces are collected unchanged; i.e., the identity // 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 // of a method I.m's Func Object of an interface I is the same as that of
@ -256,7 +258,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *T
} }
// collect embedded elements // collect embedded elements
var allTerms = topTermlist var allTerms = allTermlist
for i, typ := range ityp.embeddeds { for i, typ := range ityp.embeddeds {
// The embedding position is nil for imported interfaces // The embedding position is nil for imported interfaces
// and also for interface copies after substitution (but // and also for interface copies after substitution (but

31
src/cmd/compile/internal/types2/typeterm.go
View file

@ -4,13 +4,10 @@
package types2 package types2
// TODO(gri) use a different symbol instead of ⊀ for the set of all types
// (⊀ is hard to distinguish from T in some fonts)
// A term describes elementary type sets: // A term describes elementary type sets:
// //
// βˆ…: (*term)(nil) == βˆ… // set of no types (empty set) // βˆ…: (*term)(nil) == βˆ… // set of no types (empty set)
// ⊀: &term{} == ⊀ // set of all types // 𝓀: &term{} == 𝓀 // set of all types (𝓀niverse)
// T: &term{false, T} == {T} // set of type T // T: &term{false, T} == {T} // set of type T
// ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t // ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t
// //
@ -24,7 +21,7 @@ func (x *term) String() string {
case x == nil: case x == nil:
return "βˆ…" return "βˆ…"
case x.typ == nil: case x.typ == nil:
return "⊀" return "𝓀"
case x.tilde: case x.tilde:
return "~" + x.typ.String() return "~" + x.typ.String()
default: default:
@ -41,7 +38,7 @@ func (x *term) equal(y *term) bool {
case x.typ == nil || y.typ == nil: case x.typ == nil || y.typ == nil:
return x.typ == y.typ return x.typ == y.typ
} }
// βˆ… βŠ‚ x, y βŠ‚ ⊀ // βˆ… βŠ‚ x, y βŠ‚ 𝓀
return x.tilde == y.tilde && Identical(x.typ, y.typ) return x.tilde == y.tilde && Identical(x.typ, y.typ)
} }
@ -57,11 +54,11 @@ func (x *term) union(y *term) (_, _ *term) {
case y == nil: case y == nil:
return x, nil // x βˆͺ βˆ… == x return x, nil // x βˆͺ βˆ… == x
case x.typ == nil: case x.typ == nil:
return x, nil // ⊀ βˆͺ y == ⊀ return x, nil // 𝓀 βˆͺ y == 𝓀
case y.typ == nil: case y.typ == nil:
return y, nil // x βˆͺ ⊀ == ⊀ return y, nil // x βˆͺ 𝓀 == 𝓀
} }
// βˆ… βŠ‚ x, y βŠ‚ ⊀ // βˆ… βŠ‚ x, y βŠ‚ 𝓀
if x.disjoint(y) { if x.disjoint(y) {
return x, y // x βˆͺ y == (x, y) if x ∩ y == βˆ… return x, y // x βˆͺ y == (x, y) if x ∩ y == βˆ…
@ -85,11 +82,11 @@ func (x *term) intersect(y *term) *term {
case x == nil || y == nil: case x == nil || y == nil:
return nil // βˆ… ∩ y == βˆ… and ∩ βˆ… == βˆ… return nil // βˆ… ∩ y == βˆ… and ∩ βˆ… == βˆ…
case x.typ == nil: case x.typ == nil:
return y // ⊀ ∩ y == y return y // 𝓀 ∩ y == y
case y.typ == nil: case y.typ == nil:
return x // x ∩ ⊀ == x return x // x ∩ 𝓀 == x
} }
// βˆ… βŠ‚ x, y βŠ‚ ⊀ // βˆ… βŠ‚ x, y βŠ‚ 𝓀
if x.disjoint(y) { if x.disjoint(y) {
return nil // x ∩ y == βˆ… if x ∩ y == βˆ… return nil // x ∩ y == βˆ… if x ∩ y == βˆ…
@ -113,9 +110,9 @@ func (x *term) includes(t Type) bool {
case x == nil: case x == nil:
return false // t ∈ βˆ… == false return false // t ∈ βˆ… == false
case x.typ == nil: case x.typ == nil:
return true // t ∈ ⊀ == true return true // t ∈ 𝓀 == true
} }
// βˆ… βŠ‚ x βŠ‚ ⊀ // βˆ… βŠ‚ x βŠ‚ 𝓀
u := t u := t
if x.tilde { if x.tilde {
@ -133,11 +130,11 @@ func (x *term) subsetOf(y *term) bool {
case y == nil: case y == nil:
return false // x βŠ† βˆ… == false since x != βˆ… return false // x βŠ† βˆ… == false since x != βˆ…
case y.typ == nil: case y.typ == nil:
return true // x βŠ† ⊀ == true return true // x βŠ† 𝓀 == true
case x.typ == nil: case x.typ == nil:
return false // ⊀ βŠ† y == false since y != ⊀ return false // 𝓀 βŠ† y == false since y != 𝓀
} }
// βˆ… βŠ‚ x, y βŠ‚ ⊀ // βˆ… βŠ‚ x, y βŠ‚ 𝓀
if x.disjoint(y) { if x.disjoint(y) {
return false // x βŠ† y == false if x ∩ y == βˆ… return false // x βŠ† y == false if x ∩ y == βˆ…

42
src/cmd/compile/internal/types2/typeterm_test.go
View file

@ -11,7 +11,7 @@ import (
var testTerms = map[string]*term{ var testTerms = map[string]*term{
"βˆ…": nil, "βˆ…": nil,
"⊀": {}, "𝓀": {},
"int": {false, Typ[Int]}, "int": {false, Typ[Int]},
"~int": {true, Typ[Int]}, "~int": {true, Typ[Int]},
"string": {false, Typ[String]}, "string": {false, Typ[String]},
@ -46,14 +46,14 @@ func testTerm(name string) *term {
func TestTermEqual(t *testing.T) { func TestTermEqual(t *testing.T) {
for _, test := range []string{ for _, test := range []string{
"βˆ… βˆ… T", "βˆ… βˆ… T",
"⊀ ⊀ T", "𝓀 𝓀 T",
"int int T", "int int T",
"~int ~int T", "~int ~int T",
"βˆ… ⊀ F", "βˆ… 𝓀 F",
"βˆ… int F", "βˆ… int F",
"βˆ… ~int F", "βˆ… ~int F",
"⊀ int F", "𝓀 int F",
"⊀ ~int F", "𝓀 ~int F",
"int ~int F", "int ~int F",
} { } {
args := split(test, 3) args := split(test, 3)
@ -74,12 +74,12 @@ func TestTermEqual(t *testing.T) {
func TestTermUnion(t *testing.T) { func TestTermUnion(t *testing.T) {
for _, test := range []string{ for _, test := range []string{
"βˆ… βˆ… βˆ… βˆ…", "βˆ… βˆ… βˆ… βˆ…",
"βˆ… ⊀ ⊀ βˆ…", "βˆ… 𝓀 𝓀 βˆ…",
"βˆ… int int βˆ…", "βˆ… int int βˆ…",
"βˆ… ~int ~int βˆ…", "βˆ… ~int ~int βˆ…",
"⊀ ⊀ ⊀ βˆ…", "𝓀 𝓀 𝓀 βˆ…",
"⊀ int ⊀ βˆ…", "𝓀 int 𝓀 βˆ…",
"⊀ ~int ⊀ βˆ…", "𝓀 ~int 𝓀 βˆ…",
"int int int βˆ…", "int int int βˆ…",
"int ~int ~int βˆ…", "int ~int ~int βˆ…",
"int string int string", "int string int string",
@ -87,11 +87,11 @@ func TestTermUnion(t *testing.T) {
"~int ~string ~int ~string", "~int ~string ~int ~string",
// union is symmetric, but the result order isn't - repeat symmetric cases explictly // union is symmetric, but the result order isn't - repeat symmetric cases explictly
"⊀ βˆ… ⊀ βˆ…", "𝓀 βˆ… 𝓀 βˆ…",
"int βˆ… int βˆ…", "int βˆ… int βˆ…",
"~int βˆ… ~int βˆ…", "~int βˆ… ~int βˆ…",
"int ⊀ ⊀ βˆ…", "int 𝓀 𝓀 βˆ…",
"~int ⊀ ⊀ βˆ…", "~int 𝓀 𝓀 βˆ…",
"~int int ~int βˆ…", "~int int ~int βˆ…",
"string int string int", "string int string int",
"~string int ~string int", "~string int ~string int",
@ -111,12 +111,12 @@ func TestTermUnion(t *testing.T) {
func TestTermIntersection(t *testing.T) { func TestTermIntersection(t *testing.T) {
for _, test := range []string{ for _, test := range []string{
"βˆ… βˆ… βˆ…", "βˆ… βˆ… βˆ…",
"βˆ… ⊀ βˆ…", "βˆ… 𝓀 βˆ…",
"βˆ… int βˆ…", "βˆ… int βˆ…",
"βˆ… ~int βˆ…", "βˆ… ~int βˆ…",
"⊀ ⊀ ⊀", "𝓀 𝓀 𝓀",
"⊀ int int", "𝓀 int int",
"⊀ ~int ~int", "𝓀 ~int ~int",
"int int int", "int int int",
"int ~int int", "int ~int int",
"int string βˆ…", "int string βˆ…",
@ -141,7 +141,7 @@ func TestTermIntersection(t *testing.T) {
func TestTermIncludes(t *testing.T) { func TestTermIncludes(t *testing.T) {
for _, test := range []string{ for _, test := range []string{
"βˆ… int F", "βˆ… int F",
"⊀ int T", "𝓀 int T",
"int int T", "int int T",
"~int int T", "~int int T",
"string int F", "string int F",
@ -160,14 +160,14 @@ func TestTermIncludes(t *testing.T) {
func TestTermSubsetOf(t *testing.T) { func TestTermSubsetOf(t *testing.T) {
for _, test := range []string{ for _, test := range []string{
"βˆ… βˆ… T", "βˆ… βˆ… T",
"⊀ ⊀ T", "𝓀 𝓀 T",
"int int T", "int int T",
"~int ~int T", "~int ~int T",
"βˆ… ⊀ T", "βˆ… 𝓀 T",
"βˆ… int T", "βˆ… int T",
"βˆ… ~int T", "βˆ… ~int T",
"⊀ int F", "𝓀 int F",
"⊀ ~int F", "𝓀 ~int F",
"int ~int T", "int ~int T",
} { } {
args := split(test, 3) args := split(test, 3)

2
src/cmd/compile/internal/types2/universe.go
View file

@ -99,7 +99,7 @@ func defPredeclaredTypes() {
{ {
obj := NewTypeName(nopos, nil, "comparable", nil) obj := NewTypeName(nopos, nil, "comparable", nil)
obj.setColor(black) obj.setColor(black)
ityp := &Interface{obj, nil, nil, nil, true, &TypeSet{true, nil, topTermlist}} ityp := &Interface{obj, nil, nil, nil, true, &TypeSet{true, nil, allTermlist}}
NewNamed(obj, ityp, nil) NewNamed(obj, ityp, nil)
def(obj) def(obj)
} }