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