1// Copyright 2021 The Go Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style 3// license that can be found in the LICENSE file. 4 5// Code generated by copytermlist.go DO NOT EDIT. 6 7package typeparams 8 9import "go/types" 10 11// A term describes elementary type sets: 12// 13// ∅: (*term)(nil) == ∅ // set of no types (empty set) 14// : &term{} == // set of all types (niverse) 15// T: &term{false, T} == {T} // set of type T 16// ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t 17// 18type term struct { 19 tilde bool // valid if typ != nil 20 typ types.Type 21} 22 23func (x *term) String() string { 24 switch { 25 case x == nil: 26 return "∅" 27 case x.typ == nil: 28 return "" 29 case x.tilde: 30 return "~" + x.typ.String() 31 default: 32 return x.typ.String() 33 } 34} 35 36// equal reports whether x and y represent the same type set. 37func (x *term) equal(y *term) bool { 38 // easy cases 39 switch { 40 case x == nil || y == nil: 41 return x == y 42 case x.typ == nil || y.typ == nil: 43 return x.typ == y.typ 44 } 45 // ∅ ⊂ x, y ⊂ 46 47 return x.tilde == y.tilde && types.Identical(x.typ, y.typ) 48} 49 50// union returns the union x ∪ y: zero, one, or two non-nil terms. 51func (x *term) union(y *term) (_, _ *term) { 52 // easy cases 53 switch { 54 case x == nil && y == nil: 55 return nil, nil // ∅ ∪ ∅ == ∅ 56 case x == nil: 57 return y, nil // ∅ ∪ y == y 58 case y == nil: 59 return x, nil // x ∪ ∅ == x 60 case x.typ == nil: 61 return x, nil // ∪ y == 62 case y.typ == nil: 63 return y, nil // x ∪ == 64 } 65 // ∅ ⊂ x, y ⊂ 66 67 if x.disjoint(y) { 68 return x, y // x ∪ y == (x, y) if x ∩ y == ∅ 69 } 70 // x.typ == y.typ 71 72 // ~t ∪ ~t == ~t 73 // ~t ∪ T == ~t 74 // T ∪ ~t == ~t 75 // T ∪ T == T 76 if x.tilde || !y.tilde { 77 return x, nil 78 } 79 return y, nil 80} 81 82// intersect returns the intersection x ∩ y. 83func (x *term) intersect(y *term) *term { 84 // easy cases 85 switch { 86 case x == nil || y == nil: 87 return nil // ∅ ∩ y == ∅ and ∩ ∅ == ∅ 88 case x.typ == nil: 89 return y // ∩ y == y 90 case y.typ == nil: 91 return x // x ∩ == x 92 } 93 // ∅ ⊂ x, y ⊂ 94 95 if x.disjoint(y) { 96 return nil // x ∩ y == ∅ if x ∩ y == ∅ 97 } 98 // x.typ == y.typ 99 100 // ~t ∩ ~t == ~t 101 // ~t ∩ T == T 102 // T ∩ ~t == T 103 // T ∩ T == T 104 if !x.tilde || y.tilde { 105 return x 106 } 107 return y 108} 109 110// includes reports whether t ∈ x. 111func (x *term) includes(t types.Type) bool { 112 // easy cases 113 switch { 114 case x == nil: 115 return false // t ∈ ∅ == false 116 case x.typ == nil: 117 return true // t ∈ == true 118 } 119 // ∅ ⊂ x ⊂ 120 121 u := t 122 if x.tilde { 123 u = under(u) 124 } 125 return types.Identical(x.typ, u) 126} 127 128// subsetOf reports whether x ⊆ y. 129func (x *term) subsetOf(y *term) bool { 130 // easy cases 131 switch { 132 case x == nil: 133 return true // ∅ ⊆ y == true 134 case y == nil: 135 return false // x ⊆ ∅ == false since x != ∅ 136 case y.typ == nil: 137 return true // x ⊆ == true 138 case x.typ == nil: 139 return false // ⊆ y == false since y != 140 } 141 // ∅ ⊂ x, y ⊂ 142 143 if x.disjoint(y) { 144 return false // x ⊆ y == false if x ∩ y == ∅ 145 } 146 // x.typ == y.typ 147 148 // ~t ⊆ ~t == true 149 // ~t ⊆ T == false 150 // T ⊆ ~t == true 151 // T ⊆ T == true 152 return !x.tilde || y.tilde 153} 154 155// disjoint reports whether x ∩ y == ∅. 156// x.typ and y.typ must not be nil. 157func (x *term) disjoint(y *term) bool { 158 if debug && (x.typ == nil || y.typ == nil) { 159 panic("invalid argument(s)") 160 } 161 ux := x.typ 162 if y.tilde { 163 ux = under(ux) 164 } 165 uy := y.typ 166 if x.tilde { 167 uy = under(uy) 168 } 169 return !types.Identical(ux, uy) 170} 171