File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.19.4/src/cmd/compile/internal/types2

opt / golang / 1.19.4 / src / cmd / compile / internal / types2 /

📁 ..
📄 api.go(17.37 KB)
📄 api_test.go(79.44 KB)
📄 array.go(803 B)
📄 assignments.go(13.89 KB)
📄 basic.go(1.48 KB)
📄 builtins.go(23.73 KB)
📄 builtins_test.go(9.89 KB)
📄 call.go(19.08 KB)
📄 chan.go(910 B)
📄 check.go(17.12 KB)
📄 check_test.go(8.96 KB)
📄 compilersupport.go(1.05 KB)
📄 context.go(4.34 KB)
📄 context_test.go(2.3 KB)
📄 conversions.go(8.27 KB)
📄 decl.go(27.86 KB)
📄 errorcalls_test.go(1.15 KB)
📄 errors.go(7.62 KB)
📄 errors_test.go(1.01 KB)
📄 example_test.go(7.41 KB)
📄 expr.go(54.01 KB)
📄 gccgosizes.go(1017 B)
📄 hilbert_test.go(3.63 KB)
📄 importer_test.go(913 B)
📄 index.go(11.13 KB)
📄 infer.go(24.86 KB)
📄 initorder.go(9.55 KB)
📄 instantiate.go(9.93 KB)
📄 instantiate_test.go(5.98 KB)
📄 interface.go(6.04 KB)
📄 issues_test.go(17.4 KB)
📄 labels.go(7.05 KB)
📄 lookup.go(17.01 KB)
📄 main_test.go(336 B)
📄 map.go(659 B)
📄 mono.go(9.03 KB)
📄 mono_test.go(2.65 KB)
📄 named.go(22.4 KB)
📄 named_test.go(2.35 KB)
📄 object.go(18.8 KB)
📄 object_test.go(5.13 KB)
📄 objset.go(928 B)
📄 operand.go(10.62 KB)
📄 package.go(2.67 KB)
📄 pointer.go(635 B)
📄 predicates.go(14.64 KB)
📄 resolver.go(24.88 KB)
📄 resolver_test.go(4.81 KB)
📄 return.go(4.34 KB)
📄 scope.go(9.38 KB)
📄 selection.go(3.99 KB)
📄 self_test.go(2.58 KB)
📄 signature.go(12.1 KB)
📄 sizeof_test.go(1.28 KB)
📄 sizes.go(7.56 KB)
📄 sizes_test.go(3.25 KB)
📄 slice.go(577 B)
📄 stdlib_test.go(8.8 KB)
📄 stmt.go(25.66 KB)
📄 struct.go(6.24 KB)
📄 subst.go(10.78 KB)
📄 termlist.go(3.68 KB)
📄 termlist_test.go(7.18 KB)
📁 testdata
📄 tuple.go(929 B)
📄 type.go(2.92 KB)
📄 typelists.go(1.84 KB)
📄 typeparam.go(4.75 KB)
📄 typeset.go(13.87 KB)
📄 typeset_test.go(2.41 KB)
📄 typestring.go(10.61 KB)
📄 typestring_test.go(4.11 KB)
📄 typeterm.go(3.52 KB)
📄 typeterm_test.go(5.08 KB)
📄 typexpr.go(14.8 KB)
📄 unify.go(18.34 KB)
📄 union.go(6.1 KB)
📄 universe.go(7.58 KB)
📄 validtype.go(7.77 KB)
📄 version.go(2.13 KB)

Editing: typeterm.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.

package types2

// 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   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 {
	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 !Identical(ux, uy)
}

X7ROOT File Manager

Editing: typeterm.go

Upload File

Create Folder