171 lines
3.6 KiB
Go
171 lines
3.6 KiB
Go
// 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.
|
||
|
||
// Code generated by copytermlist.go DO NOT EDIT.
|
||
|
||
package typeparams
|
||
|
||
import "go/types"
|
||
|
||
// A term describes elementary type sets:
|
||
//
|
||
// ∅: (*term)(nil) == ∅ // set of no types (empty set)
|
||
// 𝓤: &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
|
||
//
|
||
type term struct {
|
||
tilde bool // valid if typ != nil
|
||
typ types.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 && types.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 types.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 types.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 {
|
||
if debug && (x.typ == nil || y.typ == nil) {
|
||
panic("invalid argument(s)")
|
||
}
|
||
ux := x.typ
|
||
if y.tilde {
|
||
ux = under(ux)
|
||
}
|
||
uy := y.typ
|
||
if x.tilde {
|
||
uy = under(uy)
|
||
}
|
||
return !types.Identical(ux, uy)
|
||
}
|