// 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:

	// 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:

	// 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:

	Tu := under(T)
	Vp, _ := V.(*TypeParam)
	Tp, _ := T.(*TypeParam)

	// "V and T have identical underlying types if tags are ignored
	// and V and T are not type parameters"
	if IdenticalIgnoreTags(Vu, Tu) && Vp == nil && Tp == nil {
		return true
	}

	// "V and T are unnamed pointer types and their pointer base types
	// have identical underlying types if tags are ignored
	// and their pointer base types are not type parameters"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "fmt"

var x any
var y interface{}

var _ = &x == &y // assert x and y have identical types

func main() {
	fmt.Printf("%T\n%T\n", &x, &y)

// Copyright 2018 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.

//go:build cgo

// Test that we can have two identical cgo packages in a single binary.
// No runtime test; just make sure it compiles.

package cgotest

import (
	_ "cmd/cgo/internal/test/issue23555a"
	_ "cmd/cgo/internal/test/issue23555b"

Module with a function that prints file name for the top stack frame.
Different versions of this module are identical, but they should return
different file names with -trimpath.
-- .mod --
module example.com/stack

go 1.14
-- .info --
{"Version":"v1.0.0"}
-- stack.go --
package stack

import "runtime"

func TopFile() string {
	_, file, _, _ := runtime.Caller(0)
	return file

Module with a function that prints file name for the top stack frame.
Different versions of this module are identical, but they should return
different file names with -trimpath.
-- .mod --
module example.com/stack

go 1.14
-- .info --
{"Version":"v1.0.1"}
-- stack.go --
package stack

import "runtime"

func TopFile() string {
	_, file, _, _ := runtime.Caller(0)
	return file

	var _ float64 = b.F(0)
	var _ a.Rune = int32(0)

	// embedded types can have different names but the same types
	var s a.S
	s.Int = 1
	s.IntAlias = s.Int
	s.IntAlias2 = s.Int

	// aliases denote identical types across packages
	var c a.Context = b.C
	var _ b.MyContext = c

}

func _[T ~[]byte](x, y T) {
	copy(x, y)
	copy(x, "foo")
	copy("foo" /* ERROR "expects slice arguments" */ , y)

	var x2 []byte
	copy(x2, y) // element types are identical
	copy(y, x2) // element types are identical

	type myByte byte
	var x3 []myByte
	copy(x3 /* ERROR "different element types" */ , y)
	copy(y /* ERROR "different element types" */ , x3)
}

func _[T ~[]E, E any](x T, y []E) {