mirror of
https://github.com/golang/go
synced 2024-07-19 19:44:12 +00:00
[dev.typeparams] cmd/compile/internal/types2: implement type terms
Type terms will be used to represent a type set as a list of type terms. Eventually, a type term may also include a method set. Groundwork for the implementation of lazily computed type sets for union expressions. Change-Id: Ic88750af21f697ce0b52a2259eff40bee115964c Reviewed-on: https://go-review.googlesource.com/c/go/+/338049 Trust: Robert Griesemer <gri@golang.org> Reviewed-by: Robert Findley <rfindley@google.com>
This commit is contained in:
Robert Griesemer
parent
f4f503e0a3
commit
2fa8f00915
166
src/cmd/compile/internal/types2/typeterm.go
Normal file
166
src/cmd/compile/internal/types2/typeterm.go
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
// Copyright 2021 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
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
|
||||
// T: &term{false, T} == {T} // set of type T
|
||||
// ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t
|
||||
//
|
||||
type term struct {
|
||||
tilde bool // valid if typ != nil
|
||||
typ Type
|
||||
}
|
||||
|
||||
func (x *term) String() string {
|
||||
switch {
|
||||
case x == nil:
|
||||
return "∅"
|
||||
case x.typ == nil:
|
||||
return "⊤"
|
||||
case x.tilde:
|
||||
return "~" + x.typ.String()
|
||||
default:
|
||||
return x.typ.String()
|
||||
}
|
||||
}
|
||||
|
||||
// equal reports whether x and y represent the same type set.
|
||||
func (x *term) equal(y *term) bool {
|
||||
// easy cases
|
||||
switch {
|
||||
case x == nil || y == nil:
|
||||
return x == y
|
||||
case x.typ == nil || y.typ == nil:
|
||||
return x.typ == y.typ
|
||||
}
|
||||
// ∅ ⊂ x, y ⊂ ⊤
|
||||
|
||||
return x.tilde == y.tilde && Identical(x.typ, y.typ)
|
||||
}
|
||||
|
||||
// union returns the union x ∪ y: zero, one, or two non-nil terms.
|
||||
func (x *term) union(y *term) (_, _ *term) {
|
||||
// easy cases
|
||||
switch {
|
||||
case x == nil && y == nil:
|
||||
return nil, nil // ∅ ∪ ∅ == ∅
|
||||
case x == nil:
|
||||
return y, nil // ∅ ∪ y == y
|
||||
case y == nil:
|
||||
return x, nil // x ∪ ∅ == x
|
||||
case x.typ == nil:
|
||||
return x, nil // ⊤ ∪ y == ⊤
|
||||
case y.typ == nil:
|
||||
return y, nil // x ∪ ⊤ == ⊤
|
||||
}
|
||||
// ∅ ⊂ x, y ⊂ ⊤
|
||||
|
||||
if x.disjoint(y) {
|
||||
return x, y // x ∪ y == (x, y) if x ∩ y == ∅
|
||||
}
|
||||
// x.typ == y.typ
|
||||
|
||||
// ~t ∪ ~t == ~t
|
||||
// ~t ∪ T == ~t
|
||||
// T ∪ ~t == ~t
|
||||
// T ∪ T == T
|
||||
if x.tilde || !y.tilde {
|
||||
return x, nil
|
||||
}
|
||||
return y, nil
|
||||
}
|
||||
|
||||
// intersect returns the intersection x ∩ y.
|
||||
func (x *term) intersect(y *term) *term {
|
||||
// easy cases
|
||||
switch {
|
||||
case x == nil || y == nil:
|
||||
return nil // ∅ ∩ y == ∅ and ∩ ∅ == ∅
|
||||
case x.typ == nil:
|
||||
return y // ⊤ ∩ y == y
|
||||
case y.typ == nil:
|
||||
return x // x ∩ ⊤ == x
|
||||
}
|
||||
// ∅ ⊂ x, y ⊂ ⊤
|
||||
|
||||
if x.disjoint(y) {
|
||||
return nil // x ∩ y == ∅ if x ∩ y == ∅
|
||||
}
|
||||
// x.typ == y.typ
|
||||
|
||||
// ~t ∩ ~t == ~t
|
||||
// ~t ∩ T == T
|
||||
// T ∩ ~t == T
|
||||
// T ∩ T == T
|
||||
if !x.tilde || y.tilde {
|
||||
return x
|
||||
}
|
||||
return y
|
||||
}
|
||||
|
||||
// includes reports whether t ∈ x.
|
||||
func (x *term) includes(t Type) bool {
|
||||
// easy cases
|
||||
switch {
|
||||
case x == nil:
|
||||
return false // t ∈ ∅ == false
|
||||
case x.typ == nil:
|
||||
return true // t ∈ ⊤ == true
|
||||
}
|
||||
// ∅ ⊂ x ⊂ ⊤
|
||||
|
||||
u := t
|
||||
if x.tilde {
|
||||
u = under(u)
|
||||
}
|
||||
return Identical(x.typ, u)
|
||||
}
|
||||
|
||||
// subsetOf reports whether x ⊆ y.
|
||||
func (x *term) subsetOf(y *term) bool {
|
||||
// easy cases
|
||||
switch {
|
||||
case x == nil:
|
||||
return true // ∅ ⊆ y == true
|
||||
case y == nil:
|
||||
return false // x ⊆ ∅ == false since x != ∅
|
||||
case y.typ == nil:
|
||||
return true // x ⊆ ⊤ == true
|
||||
case x.typ == nil:
|
||||
return false // ⊤ ⊆ y == false since y != ⊤
|
||||
}
|
||||
// ∅ ⊂ x, y ⊂ ⊤
|
||||
|
||||
if x.disjoint(y) {
|
||||
return false // x ⊆ y == false if x ∩ y == ∅
|
||||
}
|
||||
// x.typ == y.typ
|
||||
|
||||
// ~t ⊆ ~t == true
|
||||
// ~t ⊆ T == false
|
||||
// T ⊆ ~t == true
|
||||
// T ⊆ T == true
|
||||
return !x.tilde || y.tilde
|
||||
}
|
||||
|
||||
// disjoint reports whether x ∩ y == ∅.
|
||||
// x.typ and y.typ must not be nil.
|
||||
func (x *term) disjoint(y *term) bool {
|
||||
ux := x.typ
|
||||
if y.tilde {
|
||||
ux = under(ux)
|
||||
}
|
||||
uy := y.typ
|
||||
if x.tilde {
|
||||
uy = under(uy)
|
||||
}
|
||||
return !Identical(ux, uy)
|
||||
}
|
||||
205
src/cmd/compile/internal/types2/typeterm_test.go
Normal file
205
src/cmd/compile/internal/types2/typeterm_test.go
Normal file
|
|
@ -0,0 +1,205 @@
|
|||
// Copyright 2021 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package types2
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var testTerms = map[string]*term{
|
||||
"∅": nil,
|
||||
"⊤": &term{},
|
||||
"int": &term{false, Typ[Int]},
|
||||
"~int": &term{true, Typ[Int]},
|
||||
"string": &term{false, Typ[String]},
|
||||
"~string": &term{true, Typ[String]},
|
||||
// TODO(gri) add a defined type
|
||||
}
|
||||
|
||||
func TestTermString(t *testing.T) {
|
||||
for want, x := range testTerms {
|
||||
if got := x.String(); got != want {
|
||||
t.Errorf("%v.String() == %v; want %v", x, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func split(s string, n int) []string {
|
||||
r := strings.Split(s, " ")
|
||||
if len(r) != n {
|
||||
panic("invalid test case: " + s)
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func testTerm(name string) *term {
|
||||
r, ok := testTerms[name]
|
||||
if !ok {
|
||||
panic("invalid test argument: " + name)
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
func TestTermEqual(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"∅ ∅ T",
|
||||
"⊤ ⊤ T",
|
||||
"int int T",
|
||||
"~int ~int T",
|
||||
"∅ ⊤ F",
|
||||
"∅ int F",
|
||||
"∅ ~int F",
|
||||
"⊤ int F",
|
||||
"⊤ ~int F",
|
||||
"int ~int F",
|
||||
} {
|
||||
args := split(test, 3)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1])
|
||||
want := args[2] == "T"
|
||||
if got := x.equal(y); got != want {
|
||||
t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
// equal is symmetric
|
||||
x, y = y, x
|
||||
if got := x.equal(y); got != want {
|
||||
t.Errorf("%v.equal(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTermUnion(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"∅ ∅ ∅ ∅",
|
||||
"∅ ⊤ ⊤ ∅",
|
||||
"∅ int int ∅",
|
||||
"∅ ~int ~int ∅",
|
||||
"⊤ ⊤ ⊤ ∅",
|
||||
"⊤ int ⊤ ∅",
|
||||
"⊤ ~int ⊤ ∅",
|
||||
"int int int ∅",
|
||||
"int ~int ~int ∅",
|
||||
"int string int string",
|
||||
"int ~string int ~string",
|
||||
"~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 ∅",
|
||||
"string int string int",
|
||||
"~string int ~string int",
|
||||
"~string ~int ~string ~int",
|
||||
} {
|
||||
args := split(test, 4)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1])
|
||||
want1 := testTerm(args[2])
|
||||
want2 := testTerm(args[3])
|
||||
if got1, got2 := x.union(y); !got1.equal(want1) || !got2.equal(want2) {
|
||||
t.Errorf("%v.union(%v) = %v, %v; want %v, %v", x, y, got1, got2, want1, want2)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTermIntersection(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"∅ ∅ ∅",
|
||||
"∅ ⊤ ∅",
|
||||
"∅ int ∅",
|
||||
"∅ ~int ∅",
|
||||
"⊤ ⊤ ⊤",
|
||||
"⊤ int int",
|
||||
"⊤ ~int ~int",
|
||||
"int int int",
|
||||
"int ~int int",
|
||||
"int string ∅",
|
||||
"int ~string ∅",
|
||||
"~int ~string ∅",
|
||||
} {
|
||||
args := split(test, 3)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1])
|
||||
want := testTerm(args[2])
|
||||
if got := x.intersect(y); !got.equal(want) {
|
||||
t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
// intersect is symmetric
|
||||
x, y = y, x
|
||||
if got := x.intersect(y); !got.equal(want) {
|
||||
t.Errorf("%v.intersect(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTermIncludes(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"∅ int F",
|
||||
"⊤ int T",
|
||||
"int int T",
|
||||
"~int int T",
|
||||
"string int F",
|
||||
"~string int F",
|
||||
} {
|
||||
args := split(test, 3)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1]).typ
|
||||
want := args[2] == "T"
|
||||
if got := x.includes(y); got != want {
|
||||
t.Errorf("%v.includes(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTermSubsetOf(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"∅ ∅ T",
|
||||
"⊤ ⊤ T",
|
||||
"int int T",
|
||||
"~int ~int T",
|
||||
"∅ ⊤ T",
|
||||
"∅ int T",
|
||||
"∅ ~int T",
|
||||
"⊤ int F",
|
||||
"⊤ ~int F",
|
||||
"int ~int T",
|
||||
} {
|
||||
args := split(test, 3)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1])
|
||||
want := args[2] == "T"
|
||||
if got := x.subsetOf(y); got != want {
|
||||
t.Errorf("%v.subsetOf(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTermDisjoint(t *testing.T) {
|
||||
for _, test := range []string{
|
||||
"int int F",
|
||||
"~int ~int F",
|
||||
"int ~int F",
|
||||
"int string T",
|
||||
"int ~string T",
|
||||
"~int ~string T",
|
||||
} {
|
||||
args := split(test, 3)
|
||||
x := testTerm(args[0])
|
||||
y := testTerm(args[1])
|
||||
want := args[2] == "T"
|
||||
if got := x.disjoint(y); got != want {
|
||||
t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
// disjoint is symmetric
|
||||
x, y = y, x
|
||||
if got := x.disjoint(y); got != want {
|
||||
t.Errorf("%v.disjoint(%v) = %v; want %v", x, y, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue