From 5aac85ad5ebfa9c2ecb01a3292bcf3513d876d7a Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 4 Aug 2021 15:18:37 -0700 Subject: [dev.typeparams] cmd/compile/internal/types2: better names for things (cleanup) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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 Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/instantiate.go | 2 +- src/cmd/compile/internal/types2/interface.go | 2 +- src/cmd/compile/internal/types2/termlist.go | 22 +++---- src/cmd/compile/internal/types2/termlist_test.go | 78 ++++++++++++------------ src/cmd/compile/internal/types2/typeset.go | 22 ++++--- src/cmd/compile/internal/types2/typeterm.go | 31 +++++----- src/cmd/compile/internal/types2/typeterm_test.go | 42 ++++++------- src/cmd/compile/internal/types2/universe.go | 2 +- 8 files changed, 100 insertions(+), 101 deletions(-) diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index b7ea193a06..0bb4ac956b 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -174,7 +174,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap // if iface is comparable, targ must be comparable // TODO(gri) the error messages needs to be better, here 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) return false } diff --git a/src/cmd/compile/internal/types2/interface.go b/src/cmd/compile/internal/types2/interface.go index aa7d0b05a0..f763f8ff44 100644 --- a/src/cmd/compile/internal/types2/interface.go +++ b/src/cmd/compile/internal/types2/interface.go @@ -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) } // 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. func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() } diff --git a/src/cmd/compile/internal/types2/termlist.go b/src/cmd/compile/internal/types2/termlist.go index 07056edd97..378ba6b8f4 100644 --- a/src/cmd/compile/internal/types2/termlist.go +++ b/src/cmd/compile/internal/types2/termlist.go @@ -13,9 +13,9 @@ import "bytes" // normal form. type termlist []*term -// topTermlist represents the set of all types. +// allTermlist represents the set of all types. // It is in normal form. -var topTermlist = termlist{new(term)} +var allTermlist = termlist{new(term)} // String prints the termlist exactly (without normalization). func (xl termlist) String() string { @@ -45,9 +45,9 @@ func (xl termlist) isEmpty() bool { return true } -// isTop reports whether the termlist xl represents the set of all types. -func (xl termlist) isTop() bool { - // If there's a ⊀ (top) term, the entire list is ⊀ (top). +// isAll reports whether the termlist xl represents the set of all types. +func (xl termlist) isAll() bool { + // If there's a 𝓀 term, the entire list is 𝓀. // If the termlist is in normal form, this requires at most // one iteration. for _, x := range xl { @@ -74,14 +74,14 @@ func (xl termlist) norm() termlist { continue } if u1, u2 := xi.union(xj); u2 == nil { - // If we encounter a ⊀ (top) term, the entire - // list is ⊀ (top). Exit early. + // If we encounter a 𝓀 term, the entire list is 𝓀. + // Exit early. // (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 // in normal form.) if u1.typ == nil { - return topTermlist + return allTermlist } xi = u1 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 } -// 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. func (xl termlist) structuralType() Type { 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 } diff --git a/src/cmd/compile/internal/types2/termlist_test.go b/src/cmd/compile/internal/types2/termlist_test.go index c36baeb86f..706b4c9756 100644 --- a/src/cmd/compile/internal/types2/termlist_test.go +++ b/src/cmd/compile/internal/types2/termlist_test.go @@ -21,20 +21,20 @@ func maketl(s string) termlist { } func TestTermlistTop(t *testing.T) { - if !topTermlist.isTop() { - t.Errorf("topTermlist is not top") + if !allTermlist.isAll() { + t.Errorf("allTermlist is not the set of all types") } } func TestTermlistString(t *testing.T) { for _, want := range []string{ "βˆ…", - "⊀", + "𝓀", "int", "~int", "βˆ… βˆͺ βˆ…", - "⊀ βˆͺ ⊀", - "βˆ… βˆͺ ⊀ βˆͺ int", + "𝓀 βˆͺ 𝓀", + "βˆ… βˆͺ 𝓀 βˆͺ int", } { if got := maketl(want).String(); got != want { t.Errorf("(%v).String() == %v", want, got) @@ -46,9 +46,9 @@ func TestTermlistIsEmpty(t *testing.T) { for test, want := range map[string]bool{ "βˆ…": true, "βˆ… βˆͺ βˆ…": true, - "βˆ… βˆͺ βˆ… βˆͺ ⊀": false, - "⊀": false, - "⊀ βˆͺ int": false, + "βˆ… βˆͺ βˆ… βˆͺ 𝓀": false, + "𝓀": false, + "𝓀 βˆͺ int": false, } { xl := maketl(test) 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{ "βˆ…": false, "βˆ… βˆͺ βˆ…": false, "int βˆͺ ~string": false, - "βˆ… βˆͺ βˆ… βˆͺ ⊀": true, - "⊀": true, - "⊀ βˆͺ int": true, + "βˆ… βˆͺ βˆ… βˆͺ 𝓀": true, + "𝓀": true, + "𝓀 βˆͺ int": true, } { xl := maketl(test) - got := xl.isTop() + got := xl.isAll() 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 βˆͺ ~string βˆͺ int", "int βˆͺ ~string"}, - {"~int βˆͺ string βˆͺ ⊀ βˆͺ ~string βˆͺ int", "⊀"}, + {"~int βˆͺ string βˆͺ 𝓀 βˆͺ ~string βˆͺ int", "𝓀"}, } { xl := maketl(test.xl) got := maketl(test.xl).norm() @@ -106,7 +106,7 @@ func TestTermlistStructuralType(t *testing.T) { for test, want := range map[string]string{ "βˆ…": "nil", - "⊀": "nil", + "𝓀": "nil", "int": "int", "~int": "int", "~int βˆͺ string": "nil", @@ -128,15 +128,15 @@ func TestTermlistUnion(t *testing.T) { }{ {"βˆ…", "βˆ…", "βˆ…"}, - {"βˆ…", "⊀", "⊀"}, + {"βˆ…", "𝓀", "𝓀"}, {"βˆ…", "int", "int"}, - {"⊀", "~int", "⊀"}, + {"𝓀", "~int", "𝓀"}, {"int", "~int", "~int"}, {"int", "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 βˆͺ 𝓀", "~string βˆͺ int", "𝓀"}, } { xl := maketl(test.xl) yl := maketl(test.yl) @@ -153,15 +153,15 @@ func TestTermlistIntersect(t *testing.T) { }{ {"βˆ…", "βˆ…", "βˆ…"}, - {"βˆ…", "⊀", "βˆ…"}, + {"βˆ…", "𝓀", "βˆ…"}, {"βˆ…", "int", "βˆ…"}, - {"⊀", "~int", "~int"}, + {"𝓀", "~int", "~int"}, {"int", "~int", "int"}, {"int", "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"}, } { xl := maketl(test.xl) yl := maketl(test.yl) @@ -178,10 +178,10 @@ func TestTermlistEqual(t *testing.T) { want bool }{ {"βˆ…", "βˆ…", true}, - {"βˆ…", "⊀", false}, - {"⊀", "⊀", true}, - {"⊀ βˆͺ int", "⊀", true}, - {"⊀ βˆͺ int", "string βˆͺ ⊀", true}, + {"βˆ…", "𝓀", false}, + {"𝓀", "𝓀", true}, + {"𝓀 βˆͺ int", "𝓀", true}, + {"𝓀 βˆͺ int", "string βˆͺ 𝓀", true}, {"int βˆͺ ~string", "string βˆͺ int", false}, {"int βˆͺ ~string βˆͺ βˆ…", "string βˆͺ int βˆͺ ~string", true}, } { @@ -200,14 +200,14 @@ func TestTermlistIncludes(t *testing.T) { want bool }{ {"βˆ…", "int", false}, - {"⊀", "int", true}, + {"𝓀", "int", true}, {"~int", "int", true}, {"int", "string", false}, {"~int", "string", false}, {"int βˆͺ string", "string", true}, {"~int βˆͺ string", "int", true}, {"~int βˆͺ string βˆͺ βˆ…", "string", true}, - {"~string βˆͺ βˆ… βˆͺ ⊀", "int", true}, + {"~string βˆͺ βˆ… βˆͺ 𝓀", "int", true}, } { xl := maketl(test.xl) yl := testTerm(test.typ).typ @@ -224,12 +224,12 @@ func TestTermlistSupersetOf(t *testing.T) { want bool }{ {"βˆ…", "βˆ…", true}, - {"βˆ…", "⊀", false}, + {"βˆ…", "𝓀", false}, {"βˆ…", "int", false}, - {"⊀", "βˆ…", true}, - {"⊀", "⊀", true}, - {"⊀", "int", true}, - {"⊀", "~int", true}, + {"𝓀", "βˆ…", true}, + {"𝓀", "𝓀", true}, + {"𝓀", "int", true}, + {"𝓀", "~int", true}, {"~int", "int", true}, {"~int", "~int", true}, {"int", "~int", false}, @@ -239,7 +239,7 @@ func TestTermlistSupersetOf(t *testing.T) { {"int βˆͺ string", "~string", false}, {"~int βˆͺ string", "int", true}, {"~int βˆͺ string βˆͺ βˆ…", "string", true}, - {"~string βˆͺ βˆ… βˆͺ ⊀", "int", true}, + {"~string βˆͺ βˆ… βˆͺ 𝓀", "int", true}, } { xl := maketl(test.xl) y := testTerm(test.typ) @@ -256,16 +256,16 @@ func TestTermlistSubsetOf(t *testing.T) { want bool }{ {"βˆ…", "βˆ…", true}, - {"βˆ…", "⊀", true}, - {"⊀", "βˆ…", false}, - {"⊀", "⊀", true}, + {"βˆ…", "𝓀", true}, + {"𝓀", "βˆ…", false}, + {"𝓀", "𝓀", true}, {"int", "int βˆͺ string", true}, {"~int", "int βˆͺ string", false}, {"~int", "string βˆͺ string βˆͺ int βˆͺ ~int", true}, {"int βˆͺ string", "string", false}, {"int βˆͺ string", "string βˆͺ int", true}, {"int βˆͺ ~string", "string βˆͺ int", false}, - {"int βˆͺ ~string", "string βˆͺ int βˆͺ ⊀", true}, + {"int βˆͺ ~string", "string βˆͺ int βˆͺ 𝓀", true}, {"int βˆͺ ~string", "string βˆͺ int βˆͺ βˆ… βˆͺ string", false}, } { xl := maketl(test.xl) diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index c5fcb97ff9..83df51389b 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -25,17 +25,19 @@ type TypeSet struct { // IsEmpty reports whether type set s is the empty set. 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). -func (s *TypeSet) IsTop() bool { return !s.comparable && len(s.methods) == 0 && s.terms.isTop() } +// IsAll reports whether type set s is the set of all types (corresponding to the empty interface). +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. // 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. func (s *TypeSet) IsComparable() bool { - if s.terms.isTop() { + if s.terms.isAll() { return s.comparable } return s.is(func(t *term) bool { @@ -67,8 +69,8 @@ func (s *TypeSet) String() string { switch { case s.IsEmpty(): return "βˆ…" - case s.IsTop(): - return "⊀" + case s.IsAll(): + return "𝓀" } hasMethods := len(s.methods) > 0 @@ -103,7 +105,7 @@ func (s *TypeSet) String() string { // ---------------------------------------------------------------------------- // 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) includes(t Type) bool { return s.terms.includes(t) } 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. -var topTypeSet = TypeSet{terms: topTermlist} +var topTypeSet = TypeSet{terms: allTermlist} // computeInterfaceTypeSet may be called with check == nil. 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 // infinite recursion if the validType check occurs later for some // 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 // 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 - var allTerms = topTermlist + var allTerms = allTermlist for i, typ := range ityp.embeddeds { // The embedding position is nil for imported interfaces // and also for interface copies after substitution (but diff --git a/src/cmd/compile/internal/types2/typeterm.go b/src/cmd/compile/internal/types2/typeterm.go index 59a89cb004..8edbefa579 100644 --- a/src/cmd/compile/internal/types2/typeterm.go +++ b/src/cmd/compile/internal/types2/typeterm.go @@ -4,13 +4,10 @@ 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: // // βˆ…: (*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{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: return "βˆ…" case x.typ == nil: - return "⊀" + return "𝓀" case x.tilde: return "~" + x.typ.String() default: @@ -41,7 +38,7 @@ func (x *term) equal(y *term) bool { case x.typ == nil || y.typ == nil: return x.typ == y.typ } - // βˆ… βŠ‚ x, y βŠ‚ ⊀ + // βˆ… βŠ‚ x, y βŠ‚ 𝓀 return x.tilde == y.tilde && Identical(x.typ, y.typ) } @@ -57,11 +54,11 @@ func (x *term) union(y *term) (_, _ *term) { case y == nil: return x, nil // x βˆͺ βˆ… == x case x.typ == nil: - return x, nil // ⊀ βˆͺ y == ⊀ + return x, nil // 𝓀 βˆͺ y == 𝓀 case y.typ == nil: - return y, nil // x βˆͺ ⊀ == ⊀ + return y, nil // x βˆͺ 𝓀 == 𝓀 } - // βˆ… βŠ‚ x, y βŠ‚ ⊀ + // βˆ… βŠ‚ x, y βŠ‚ 𝓀 if x.disjoint(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: return nil // βˆ… ∩ y == βˆ… and ∩ βˆ… == βˆ… case x.typ == nil: - return y // ⊀ ∩ y == y + return y // 𝓀 ∩ y == y case y.typ == nil: - return x // x ∩ ⊀ == x + return x // x ∩ 𝓀 == x } - // βˆ… βŠ‚ x, y βŠ‚ ⊀ + // βˆ… βŠ‚ x, y βŠ‚ 𝓀 if x.disjoint(y) { return nil // x ∩ y == βˆ… if x ∩ y == βˆ… @@ -113,9 +110,9 @@ func (x *term) includes(t Type) bool { case x == nil: return false // t ∈ βˆ… == false case x.typ == nil: - return true // t ∈ ⊀ == true + return true // t ∈ 𝓀 == true } - // βˆ… βŠ‚ x βŠ‚ ⊀ + // βˆ… βŠ‚ x βŠ‚ 𝓀 u := t if x.tilde { @@ -133,11 +130,11 @@ func (x *term) subsetOf(y *term) bool { case y == nil: return false // x βŠ† βˆ… == false since x != βˆ… case y.typ == nil: - return true // x βŠ† ⊀ == true + return true // x βŠ† 𝓀 == true case x.typ == nil: - return false // ⊀ βŠ† y == false since y != ⊀ + return false // 𝓀 βŠ† y == false since y != 𝓀 } - // βˆ… βŠ‚ x, y βŠ‚ ⊀ + // βˆ… βŠ‚ x, y βŠ‚ 𝓀 if x.disjoint(y) { return false // x βŠ† y == false if x ∩ y == βˆ… diff --git a/src/cmd/compile/internal/types2/typeterm_test.go b/src/cmd/compile/internal/types2/typeterm_test.go index cc4e30d989..a8cc362f56 100644 --- a/src/cmd/compile/internal/types2/typeterm_test.go +++ b/src/cmd/compile/internal/types2/typeterm_test.go @@ -11,7 +11,7 @@ import ( var testTerms = map[string]*term{ "βˆ…": nil, - "⊀": {}, + "𝓀": {}, "int": {false, Typ[Int]}, "~int": {true, Typ[Int]}, "string": {false, Typ[String]}, @@ -46,14 +46,14 @@ func testTerm(name string) *term { func TestTermEqual(t *testing.T) { for _, test := range []string{ "βˆ… βˆ… T", - "⊀ ⊀ T", + "𝓀 𝓀 T", "int int T", "~int ~int T", - "βˆ… ⊀ F", + "βˆ… 𝓀 F", "βˆ… int F", "βˆ… ~int F", - "⊀ int F", - "⊀ ~int F", + "𝓀 int F", + "𝓀 ~int F", "int ~int F", } { args := split(test, 3) @@ -74,12 +74,12 @@ func TestTermEqual(t *testing.T) { func TestTermUnion(t *testing.T) { for _, test := range []string{ "βˆ… βˆ… βˆ… βˆ…", - "βˆ… ⊀ ⊀ βˆ…", + "βˆ… 𝓀 𝓀 βˆ…", "βˆ… int int βˆ…", "βˆ… ~int ~int βˆ…", - "⊀ ⊀ ⊀ βˆ…", - "⊀ int ⊀ βˆ…", - "⊀ ~int ⊀ βˆ…", + "𝓀 𝓀 𝓀 βˆ…", + "𝓀 int 𝓀 βˆ…", + "𝓀 ~int 𝓀 βˆ…", "int int int βˆ…", "int ~int ~int βˆ…", "int string int string", @@ -87,11 +87,11 @@ func TestTermUnion(t *testing.T) { "~int ~string ~int ~string", // union is symmetric, but the result order isn't - repeat symmetric cases explictly - "⊀ βˆ… ⊀ βˆ…", + "𝓀 βˆ… 𝓀 βˆ…", "int βˆ… int βˆ…", "~int βˆ… ~int βˆ…", - "int ⊀ ⊀ βˆ…", - "~int ⊀ ⊀ βˆ…", + "int 𝓀 𝓀 βˆ…", + "~int 𝓀 𝓀 βˆ…", "~int int ~int βˆ…", "string int string int", "~string int ~string int", @@ -111,12 +111,12 @@ func TestTermUnion(t *testing.T) { func TestTermIntersection(t *testing.T) { for _, test := range []string{ "βˆ… βˆ… βˆ…", - "βˆ… ⊀ βˆ…", + "βˆ… 𝓀 βˆ…", "βˆ… int βˆ…", "βˆ… ~int βˆ…", - "⊀ ⊀ ⊀", - "⊀ int int", - "⊀ ~int ~int", + "𝓀 𝓀 𝓀", + "𝓀 int int", + "𝓀 ~int ~int", "int int int", "int ~int int", "int string βˆ…", @@ -141,7 +141,7 @@ func TestTermIntersection(t *testing.T) { func TestTermIncludes(t *testing.T) { for _, test := range []string{ "βˆ… int F", - "⊀ int T", + "𝓀 int T", "int int T", "~int int T", "string int F", @@ -160,14 +160,14 @@ func TestTermIncludes(t *testing.T) { func TestTermSubsetOf(t *testing.T) { for _, test := range []string{ "βˆ… βˆ… T", - "⊀ ⊀ T", + "𝓀 𝓀 T", "int int T", "~int ~int T", - "βˆ… ⊀ T", + "βˆ… 𝓀 T", "βˆ… int T", "βˆ… ~int T", - "⊀ int F", - "⊀ ~int F", + "𝓀 int F", + "𝓀 ~int F", "int ~int T", } { args := split(test, 3) diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go index 55bf0982b3..f14c079222 100644 --- a/src/cmd/compile/internal/types2/universe.go +++ b/src/cmd/compile/internal/types2/universe.go @@ -99,7 +99,7 @@ func defPredeclaredTypes() { { obj := NewTypeName(nopos, nil, "comparable", nil) 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) def(obj) } -- cgit v1.2.3-54-g00ecf