// with a different EnableAlias value, we panic.
//
// To achieve this, _aliasAny is a state machine:
//
//	0:        no type checking is occurring
//	negative: type checking is occurring without EnableAlias set
//	positive: type checking is occurring with EnableAlias set
var _aliasAny int32

func aliasAny() bool {
	return atomic.LoadInt32(&_aliasAny) >= 0 // default true
}

// panic.
//
// To achieve this, _aliasAny is a state machine:
//
//	0:        no type checking is occurring
//	negative: type checking is occurring without _EnableAlias set
//	positive: type checking is occurring with _EnableAlias set
var _aliasAny int32

func aliasAny() bool {
	v := gotypesalias.Value()
	useAlias := v != "0"
	inuse := atomic.LoadInt32(&_aliasAny)
	if inuse != 0 && useAlias != (inuse > 0) {

	// s.elems. The only external API to access scope elements is Lookup.
	//
	// TODO: remove this once gotypesalias=0 is no longer supported.
	if obj == universeAnyAlias && !aliasAny() {
		return universeAnyNoAlias
	}
	return obj
}

// LookupParent follows the parent chain of scopes starting with s until
// it finds a scope where Lookup(name) returns a non-nil object, and then

	// s.elems. The only external API to access scope elements is Lookup.
	//
	// TODO: remove this once gotypesalias=0 is no longer supported.
	if obj == universeAnyAlias && !aliasAny() {
		return universeAnyNoAlias
	}
	return obj
}

// LookupParent follows the parent chain of scopes starting with s until
// it finds a scope where Lookup(name) returns a non-nil object, and then

    AliasInfo& alias_info = resource_alias_info_map[assign_op.getResource()];
    // TODO(b/184420848): We may not need to skip aliasing for entire function
    // in case of multiple assigns.
    if (alias_info.output_index != kUnassigned) {
      LLVM_DEBUG(llvm::dbgs()
                 << "Skip adding aliasing information because of multiple "
                    "assigns to "

		x1, y1, v1 := x, y, Element{}

		// Calculate a reference f(x, y) without aliasing.
		if out := f(&v, &x, &y); out != &v && isInBounds(out) {
			return false
		}

		// Test aliasing the first argument and the receiver.
		v1 = x
		if out := f(&v1, &v1, &y); out != &v1 || v1 != v {
			return false
		}
		// Test aliasing the second argument and the receiver.
		v1 = y

		x1, y1, v1 := x, y, Scalar{}

		// Calculate a reference f(x, y) without aliasing.
		if out := f(&v, &x, &y); out != &v || !isReduced(out.Bytes()) {
			return false
		}

		// Test aliasing the first argument and the receiver.
		v1 = x
		if out := f(&v1, &v1, &y); out != &v1 || v1 != v || !isReduced(out.Bytes()) {
			return false
		}
		// Test aliasing the second argument and the receiver.
		v1 = y

    }
    tf_executor.fetch %island#0 : !tf_res
  }
  func.return
}

// -----

!tf_res = tensor<*x!tf_type.resource<tensor<f32>>>

// Tests that aliasing and non-aliasing values are correctly identified through
// multiple islands (`%iter_handle1`, `%iter_handle2`, `%island1#0` and
// `%island3#0` all point to the same resource here).
func.func @multiple_islands() {

type testcase struct {
	name  string
	data  []byte
	error string

	benchmark bool
}

func testcases() []testcase {
	return []testcase{
		{
			name:  "arrays of string aliases",
			error: "excessive aliasing",
			data: []byte(`
apiVersion: v1
data:

func checkAliasingOneArg(t *testing.T, f func(v, x *big.Int) *big.Int, v, x *big.Int) bool {
	x1, v1 := new(big.Int).Set(x), new(big.Int).Set(x)

	// Calculate a reference f(x) without aliasing.
	if out := f(v, x); out != v {
		return false
	}

	// Test aliasing the argument and the receiver.
	if out := f(v1, v1); out != v1 || !equal(v1, v) {
		t.Logf("f(v, x) != f(x, x)")
		return false
	}