typeterm.go

Documentation: golang.org/x/tools/internal/typeparams

     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  
     7  package typeparams
     8  
     9  import "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  //
    18  type term struct {
    19  	tilde bool // valid if typ != nil
    20  	typ   types.Type
    21  }
    22  
    23  func (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.
    37  func (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.
    51  func (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.
    83  func (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.
   111  func (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.
   129  func (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.
   157  func (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
View as plain text