// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import "mock_compiler.dart";
import "parser_helper.dart";
import "../../../sdk/lib/_internal/compiler/implementation/ssa/ssa.dart";
import "../../../sdk/lib/_internal/compiler/implementation/types/types.dart";

const CONFLICTING = HType.CONFLICTING;
const UNKNOWN = HType.UNKNOWN;
const BOOLEAN = HType.BOOLEAN;
const NUMBER = HType.NUMBER;
const INTEGER = HType.INTEGER;
const DOUBLE = HType.DOUBLE;
const INDEXABLE_PRIMITIVE = HType.INDEXABLE_PRIMITIVE;
const STRING = HType.STRING;
const READABLE_ARRAY = HType.READABLE_ARRAY;
const MUTABLE_ARRAY = HType.MUTABLE_ARRAY;
const FIXED_ARRAY = HType.FIXED_ARRAY;
const EXTENDABLE_ARRAY = HType.EXTENDABLE_ARRAY;
const BOOLEAN_OR_NULL = HType.BOOLEAN_OR_NULL;
const NUMBER_OR_NULL = HType.NUMBER_OR_NULL;
const INTEGER_OR_NULL = HType.INTEGER_OR_NULL;
const DOUBLE_OR_NULL = HType.DOUBLE_OR_NULL;
const STRING_OR_NULL = HType.STRING_OR_NULL;
const NULL = HType.NULL;
const NON_NULL = HType.NON_NULL;

var patternClass;
HType nonPrimitive1;
HType nonPrimitive2;
HType potentialArray;
HType potentialString;

HType jsArrayOrNull;
HType jsMutableArrayOrNull;
HType jsFixedArrayOrNull;
HType jsExtendableArrayOrNull;
HType jsIndexableOrNull;

void testUnion(MockCompiler compiler) {
  Expect.equals(CONFLICTING,
                CONFLICTING.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                CONFLICTING.union(UNKNOWN, compiler));
  Expect.equals(BOOLEAN,
                CONFLICTING.union(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                CONFLICTING.union(NUMBER, compiler));
  Expect.equals(INTEGER,
                CONFLICTING.union(INTEGER, compiler));
  Expect.equals(DOUBLE,
                CONFLICTING.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                CONFLICTING.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                CONFLICTING.union(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                CONFLICTING.union(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                CONFLICTING.union(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                CONFLICTING.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(nonPrimitive1,
                CONFLICTING.union(nonPrimitive1, compiler));
  Expect.equals(nonPrimitive2,
                CONFLICTING.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                CONFLICTING.union(potentialArray, compiler));
  Expect.equals(potentialString,
                CONFLICTING.union(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                CONFLICTING.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                CONFLICTING.union(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                CONFLICTING.union(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                CONFLICTING.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                CONFLICTING.union(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                CONFLICTING.union(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                CONFLICTING.union(FIXED_ARRAY, compiler));

  Expect.equals(UNKNOWN,
                UNKNOWN.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(NUMBER, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(INTEGER, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.union(FIXED_ARRAY, compiler));

  Expect.equals(BOOLEAN,
                BOOLEAN.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(UNKNOWN, compiler));
  Expect.equals(BOOLEAN,
                BOOLEAN.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(STRING, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN.union(STRING_OR_NULL, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN.union(NULL, compiler));
  Expect.equals(NON_NULL,
                BOOLEAN.union(FIXED_ARRAY, compiler));

  Expect.equals(NUMBER,
                NUMBER.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                NUMBER.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                NUMBER.union(NUMBER, compiler));
  Expect.equals(NUMBER,
                NUMBER.union(INTEGER, compiler));
  Expect.equals(NUMBER,
                NUMBER.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(STRING, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                NUMBER.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                NUMBER.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                NUMBER.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER.union(NUMBER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER.union(INTEGER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                NUMBER.union(STRING_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER.union(NULL, compiler));
  Expect.equals(NON_NULL,
                NUMBER.union(FIXED_ARRAY, compiler));

  Expect.equals(INTEGER,
                INTEGER.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                INTEGER.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                INTEGER.union(NUMBER, compiler));
  Expect.equals(INTEGER,
                INTEGER.union(INTEGER, compiler));
  Expect.equals(NUMBER,
                INTEGER.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(STRING, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                INTEGER.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                INTEGER.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                INTEGER.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER.union(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER.union(INTEGER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                INTEGER.union(STRING_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER.union(NULL, compiler));
  Expect.equals(NON_NULL,
                INTEGER.union(FIXED_ARRAY, compiler));

  Expect.equals(DOUBLE,
                DOUBLE.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                DOUBLE.union(NUMBER, compiler));
  Expect.equals(NUMBER,
                DOUBLE.union(INTEGER, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(STRING, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE.union(NUMBER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE.union(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE.union(STRING_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE.union(NULL, compiler));
  Expect.equals(NON_NULL,
                DOUBLE.union(FIXED_ARRAY, compiler));

  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(INDEXABLE_PRIMITIVE,
                compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(STRING, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(READABLE_ARRAY, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(MUTABLE_ARRAY, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(EXTENDABLE_ARRAY,
                compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                INDEXABLE_PRIMITIVE.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                INDEXABLE_PRIMITIVE.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                INDEXABLE_PRIMITIVE.union(STRING_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                INDEXABLE_PRIMITIVE.union(NULL, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.union(FIXED_ARRAY, compiler));

  Expect.equals(STRING,
                STRING.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                STRING.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                STRING.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                STRING.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                STRING.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                STRING.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                STRING.union(STRING, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                STRING.union(READABLE_ARRAY, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                STRING.union(MUTABLE_ARRAY, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                STRING.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                STRING.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                STRING.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(potentialArray, compiler));
  Expect.equals(potentialString,
                STRING.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING.union(STRING_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING.union(NULL, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                STRING.union(FIXED_ARRAY, compiler));

  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                READABLE_ARRAY.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                READABLE_ARRAY.union(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.union(READABLE_ARRAY, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.union(MUTABLE_ARRAY, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                READABLE_ARRAY.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                READABLE_ARRAY.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                READABLE_ARRAY.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                READABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(jsArrayOrNull,
                READABLE_ARRAY.union(NULL, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.union(FIXED_ARRAY, compiler));

  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                MUTABLE_ARRAY.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                MUTABLE_ARRAY.union(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                MUTABLE_ARRAY.union(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.union(MUTABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                MUTABLE_ARRAY.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,MUTABLE_ARRAY.union(potentialArray,
                compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                MUTABLE_ARRAY.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                MUTABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(jsMutableArrayOrNull,
                MUTABLE_ARRAY.union(NULL, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.union(FIXED_ARRAY, compiler));

  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                EXTENDABLE_ARRAY.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                EXTENDABLE_ARRAY.union(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                EXTENDABLE_ARRAY.union(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                EXTENDABLE_ARRAY.union(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                EXTENDABLE_ARRAY.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                EXTENDABLE_ARRAY.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                EXTENDABLE_ARRAY.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                EXTENDABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(jsExtendableArrayOrNull,
                EXTENDABLE_ARRAY.union(NULL, compiler));
  Expect.equals(MUTABLE_ARRAY,
                EXTENDABLE_ARRAY.union(FIXED_ARRAY, compiler));

  Expect.equals(nonPrimitive1,
                nonPrimitive1.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(STRING, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(nonPrimitive1,
                nonPrimitive1.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive1.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive1.union(STRING_OR_NULL, compiler));
  Expect.isTrue(nonPrimitive1.union(NULL, compiler) is HBoundedType);
  Expect.equals(NON_NULL,
                nonPrimitive1.union(FIXED_ARRAY, compiler));

  Expect.equals(nonPrimitive2,
                nonPrimitive2.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(DOUBLE, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(STRING, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(READABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(MUTABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                nonPrimitive2.union(nonPrimitive1, compiler));
  Expect.equals(nonPrimitive2,
                nonPrimitive2.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                nonPrimitive2.union(STRING_OR_NULL, compiler));
  Expect.isTrue(nonPrimitive2.union(NULL, compiler) is HBoundedType);
  Expect.equals(NON_NULL,
                nonPrimitive2.union(FIXED_ARRAY, compiler));

  Expect.equals(potentialArray,
                potentialArray.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(NUMBER, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(INTEGER, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(STRING, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(READABLE_ARRAY, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(MUTABLE_ARRAY, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialArray.union(STRING_OR_NULL, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(NULL, compiler));
  Expect.equals(potentialArray,
                potentialArray.union(FIXED_ARRAY, compiler));

  Expect.equals(potentialString,
                potentialString.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(NUMBER, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(INTEGER, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(potentialString,
                potentialString.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(potentialArray, compiler));
  Expect.equals(potentialString,
                potentialString.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(potentialString,
                potentialString.union(STRING_OR_NULL, compiler));
  Expect.equals(potentialString,
                potentialString.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                potentialString.union(FIXED_ARRAY, compiler));

  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(UNKNOWN, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(NUMBER, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(INTEGER, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                BOOLEAN_OR_NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(BOOLEAN, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(NUMBER, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(INTEGER, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                NUMBER_OR_NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(BOOLEAN, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER_OR_NULL.union(NUMBER, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.union(INTEGER, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER_OR_NULL.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER_OR_NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                INTEGER_OR_NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                INTEGER_OR_NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(BOOLEAN, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE_OR_NULL.union(NUMBER, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE_OR_NULL.union(INTEGER, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE_OR_NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                DOUBLE_OR_NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.union(NULL, compiler));
  Expect.equals(UNKNOWN,
                DOUBLE_OR_NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(NUMBER, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(INTEGER, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(DOUBLE, compiler));
  Expect.equals(jsIndexableOrNull,
                STRING_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.union(STRING, compiler));
  Expect.equals(jsIndexableOrNull,
                STRING_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(jsIndexableOrNull,
                STRING_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(jsIndexableOrNull,
                STRING_OR_NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(nonPrimitive2, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(potentialArray, compiler));
  Expect.equals(potentialString,
                STRING_OR_NULL.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                STRING_OR_NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.union(NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                STRING_OR_NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(NULL,
                NULL.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                NULL.union(UNKNOWN, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                NULL.union(BOOLEAN, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NULL.union(NUMBER, compiler));
  Expect.equals(INTEGER_OR_NULL,
                NULL.union(INTEGER, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                NULL.union(DOUBLE, compiler));
  Expect.equals(jsIndexableOrNull,
                NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING_OR_NULL,
                NULL.union(STRING, compiler));
  Expect.equals(jsArrayOrNull,
                NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(jsMutableArrayOrNull,
                NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(jsExtendableArrayOrNull,
                NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.isTrue(NULL.union(nonPrimitive1, compiler).canBeNull());
  Expect.isTrue(NULL.union(nonPrimitive2, compiler).canBeNull());
  Expect.equals(potentialArray,
                NULL.union(potentialArray, compiler));
  Expect.equals(potentialString,
                NULL.union(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                NULL.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NULL.union(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                NULL.union(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                NULL.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                NULL.union(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.union(NULL, compiler));
  Expect.equals(jsFixedArrayOrNull,
                NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(UNKNOWN, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(NUMBER, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(INTEGER, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                FIXED_ARRAY.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                FIXED_ARRAY.union(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                FIXED_ARRAY.union(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                FIXED_ARRAY.union(MUTABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                FIXED_ARRAY.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(NON_NULL,
                FIXED_ARRAY.union(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                FIXED_ARRAY.union(potentialArray, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(potentialString, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(BOOLEAN_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(NUMBER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(INTEGER_OR_NULL, compiler));
  Expect.equals(UNKNOWN,
                FIXED_ARRAY.union(DOUBLE_OR_NULL, compiler));
  Expect.equals(jsIndexableOrNull,
                FIXED_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(jsFixedArrayOrNull,
                FIXED_ARRAY.union(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.union(FIXED_ARRAY, compiler));
}

void testIntersection(MockCompiler compiler) {
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(CONFLICTING, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                CONFLICTING.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                UNKNOWN.intersection(CONFLICTING, compiler));
  Expect.equals(UNKNOWN,
                UNKNOWN.intersection(UNKNOWN, compiler));
  Expect.equals(BOOLEAN,
                UNKNOWN.intersection(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                UNKNOWN.intersection(NUMBER, compiler));
  Expect.equals(INTEGER,
                UNKNOWN.intersection(INTEGER, compiler));
  Expect.equals(DOUBLE,
                UNKNOWN.intersection(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                UNKNOWN.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                UNKNOWN.intersection(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                UNKNOWN.intersection(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                UNKNOWN.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                UNKNOWN.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(nonPrimitive1,
                UNKNOWN.intersection(nonPrimitive1, compiler));
  Expect.equals(nonPrimitive2,
                UNKNOWN.intersection(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                UNKNOWN.intersection(potentialArray, compiler));
  Expect.equals(potentialString,
                UNKNOWN.intersection(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                UNKNOWN.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                UNKNOWN.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                UNKNOWN.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                UNKNOWN.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                UNKNOWN.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                UNKNOWN.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                UNKNOWN.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(CONFLICTING, compiler));
  Expect.equals(BOOLEAN,
                BOOLEAN.intersection(UNKNOWN, compiler));
  Expect.equals(BOOLEAN,
                BOOLEAN.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(potentialString, compiler));
  Expect.equals(BOOLEAN,
                BOOLEAN.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                NUMBER.intersection(CONFLICTING, compiler));
  Expect.equals(NUMBER,
                NUMBER.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                NUMBER.intersection(NUMBER, compiler));
  Expect.equals(INTEGER,
                NUMBER.intersection(INTEGER, compiler));
  Expect.equals(DOUBLE,
                NUMBER.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER,
                NUMBER.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER,
                NUMBER.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE,
                NUMBER.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                NUMBER.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                INTEGER.intersection(CONFLICTING, compiler));
  Expect.equals(INTEGER,
                INTEGER.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(BOOLEAN, compiler));
  Expect.equals(INTEGER,
                INTEGER.intersection(NUMBER, compiler));
  Expect.equals(INTEGER,
                INTEGER.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(INTEGER,
                INTEGER.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER,
                INTEGER.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                INTEGER.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                DOUBLE.intersection(CONFLICTING, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(BOOLEAN, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(INTEGER, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE,
                DOUBLE.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(CONFLICTING, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(DOUBLE, compiler));
  Expect.equals(INDEXABLE_PRIMITIVE,
                INDEXABLE_PRIMITIVE.intersection(INDEXABLE_PRIMITIVE,
                compiler));
  Expect.equals(STRING,
                INDEXABLE_PRIMITIVE.intersection(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                INDEXABLE_PRIMITIVE.intersection(READABLE_ARRAY,
                compiler));
  Expect.equals(MUTABLE_ARRAY,
                INDEXABLE_PRIMITIVE.intersection(MUTABLE_ARRAY,
                compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                INDEXABLE_PRIMITIVE.intersection(EXTENDABLE_ARRAY,
                compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(nonPrimitive2, compiler));
  Expect.equals(READABLE_ARRAY,
                INDEXABLE_PRIMITIVE.intersection(potentialArray,
                compiler));
  Expect.equals(STRING,
                INDEXABLE_PRIMITIVE.intersection(potentialString,
                compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING,
                INDEXABLE_PRIMITIVE.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                INDEXABLE_PRIMITIVE.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                INDEXABLE_PRIMITIVE.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                STRING.intersection(CONFLICTING, compiler));
  Expect.equals(STRING,
                STRING.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(DOUBLE, compiler));
  Expect.equals(STRING,
                STRING.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                STRING.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(potentialArray, compiler));
  Expect.equals(STRING,
                STRING.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING,
                STRING.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(CONFLICTING, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(DOUBLE, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.intersection(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                READABLE_ARRAY.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                READABLE_ARRAY.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(nonPrimitive2, compiler));
  Expect.equals(READABLE_ARRAY,
                READABLE_ARRAY.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                READABLE_ARRAY.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                READABLE_ARRAY.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(CONFLICTING, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(DOUBLE, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(STRING, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.intersection(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                MUTABLE_ARRAY.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(nonPrimitive2, compiler));
  Expect.equals(MUTABLE_ARRAY,
                MUTABLE_ARRAY.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                MUTABLE_ARRAY.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                MUTABLE_ARRAY.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(CONFLICTING, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(DOUBLE, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(INDEXABLE_PRIMITIVE,
                compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(STRING, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(READABLE_ARRAY,
                compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(EXTENDABLE_ARRAY,
                compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(nonPrimitive2, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                EXTENDABLE_ARRAY.intersection(potentialArray,
                compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                EXTENDABLE_ARRAY.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(CONFLICTING, compiler));
  Expect.equals(nonPrimitive1,
                nonPrimitive1.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(nonPrimitive1,
                nonPrimitive1.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive1.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(CONFLICTING, compiler));
  Expect.equals(nonPrimitive2,
                nonPrimitive2.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(nonPrimitive1, compiler));
  Expect.equals(nonPrimitive2,
                nonPrimitive2.intersection(nonPrimitive2, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                nonPrimitive2.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                potentialArray.intersection(CONFLICTING, compiler));
  Expect.equals(potentialArray,
                potentialArray.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(DOUBLE, compiler));
  Expect.equals(READABLE_ARRAY,
                potentialArray.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(STRING, compiler));
  Expect.equals(READABLE_ARRAY,
                potentialArray.intersection(READABLE_ARRAY, compiler));
  Expect.equals(MUTABLE_ARRAY,
                potentialArray.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(EXTENDABLE_ARRAY,
                potentialArray.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                potentialArray.intersection(nonPrimitive2, compiler));
  Expect.equals(potentialArray,
                potentialArray.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(potentialString, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialArray.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                potentialArray.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                potentialString.intersection(CONFLICTING, compiler));
  Expect.equals(potentialString,
                potentialString.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(DOUBLE, compiler));
  Expect.equals(STRING,
                potentialString.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                potentialString.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                potentialString.intersection(potentialArray, compiler));
  Expect.equals(potentialString,
                potentialString.intersection(potentialString, compiler));
  Expect.equals(NULL,
                potentialString.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialString.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialString.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialString.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                potentialString.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                potentialString.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                potentialString.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(CONFLICTING, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.intersection(UNKNOWN, compiler));
  Expect.equals(BOOLEAN,
                BOOLEAN_OR_NULL.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(potentialString, compiler));
  Expect.equals(BOOLEAN_OR_NULL,
                BOOLEAN_OR_NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                BOOLEAN_OR_NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                BOOLEAN_OR_NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(CONFLICTING, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(BOOLEAN, compiler));
  Expect.equals(NUMBER,
                NUMBER_OR_NULL.intersection(NUMBER, compiler));
  Expect.equals(INTEGER,
                NUMBER_OR_NULL.intersection(INTEGER, compiler));
  Expect.equals(DOUBLE,
                NUMBER_OR_NULL.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                NUMBER_OR_NULL.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                NUMBER_OR_NULL.intersection(potentialString, compiler));
  Expect.equals(NULL,
                NUMBER_OR_NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NUMBER_OR_NULL,
                NUMBER_OR_NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                NUMBER_OR_NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                NUMBER_OR_NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                NUMBER_OR_NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                NUMBER_OR_NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                NUMBER_OR_NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(CONFLICTING, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(BOOLEAN, compiler));
  Expect.equals(INTEGER,
                INTEGER_OR_NULL.intersection(NUMBER, compiler));
  Expect.equals(INTEGER,
                INTEGER_OR_NULL.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(potentialString, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(INTEGER_OR_NULL,
                INTEGER_OR_NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                INTEGER_OR_NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                INTEGER_OR_NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(CONFLICTING, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(BOOLEAN, compiler));
  Expect.equals(DOUBLE,
                DOUBLE_OR_NULL.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(INTEGER, compiler));
  Expect.equals(DOUBLE,
                DOUBLE_OR_NULL.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(potentialString, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(DOUBLE_OR_NULL,
                DOUBLE_OR_NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                DOUBLE_OR_NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                DOUBLE_OR_NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(CONFLICTING, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(DOUBLE, compiler));
  Expect.equals(STRING,
                STRING_OR_NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING,
                STRING_OR_NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(potentialArray, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.intersection(potentialString, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(STRING_OR_NULL,
                STRING_OR_NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                STRING_OR_NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                STRING_OR_NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                NULL.intersection(CONFLICTING, compiler));
  Expect.equals(NULL,
                NULL.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(DOUBLE, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(STRING, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(READABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(nonPrimitive2, compiler));
  Expect.equals(NULL,
                NULL.intersection(potentialArray, compiler));
  Expect.equals(NULL,
                NULL.intersection(potentialString, compiler));
  Expect.equals(NULL,
                NULL.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.intersection(STRING_OR_NULL, compiler));
  Expect.equals(NULL,
                NULL.intersection(NULL, compiler));
  Expect.equals(CONFLICTING,
                NULL.intersection(FIXED_ARRAY, compiler));

  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(CONFLICTING, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(UNKNOWN, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(BOOLEAN, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(NUMBER, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(INTEGER, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(DOUBLE, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(STRING, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(READABLE_ARRAY, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(MUTABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(EXTENDABLE_ARRAY, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(nonPrimitive1, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(nonPrimitive2, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(potentialArray, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(potentialString, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(BOOLEAN_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(NUMBER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(INTEGER_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(DOUBLE_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(STRING_OR_NULL, compiler));
  Expect.equals(CONFLICTING,
                FIXED_ARRAY.intersection(NULL, compiler));
  Expect.equals(FIXED_ARRAY,
                FIXED_ARRAY.intersection(FIXED_ARRAY, compiler));
}

void testRegressions(MockCompiler compiler) {
  HType nonNullPotentialString = new HType.nonNullSubtype(
      patternClass.computeType(compiler), compiler);
  Expect.equals(
      potentialString, STRING_OR_NULL.union(nonNullPotentialString, compiler));
}

void main() {
  MockCompiler compiler = new MockCompiler();
  compiler.interceptorsLibrary.forEachLocalMember((element) {
    if (element.isClass()) {
      compiler.enqueuer.resolution.registerInstantiatedClass(
          element, compiler.globalDependencies);
    }
  });
  compiler.enqueuer.resolution.registerInstantiatedClass(
      compiler.mapClass, compiler.globalDependencies);
  compiler.world.populate();

  // Grab hold of a supertype for String so we can produce potential
  // string types.
  patternClass = compiler.coreLibrary.find(buildSourceString('Pattern'));

  nonPrimitive1 = new HType.nonNullSubtype(
      compiler.mapClass.computeType(compiler), compiler);
  nonPrimitive2 = new HType.nonNullSubtype(
      compiler.functionClass.computeType(compiler), compiler);
  potentialArray = new HType.subtype(
      compiler.listClass.computeType(compiler), compiler);
  potentialString = new HType.subtype(
      patternClass.computeType(compiler), compiler);
  jsArrayOrNull = new HType.subclass(
      compiler.backend.jsArrayClass.computeType(compiler), compiler);
  jsMutableArrayOrNull = new HType.subclass(
      compiler.backend.jsMutableArrayClass.computeType(compiler), compiler);
  jsFixedArrayOrNull = new HType.exact(
      compiler.backend.jsFixedArrayClass.computeType(compiler), compiler);
  jsExtendableArrayOrNull = new HType.exact(
      compiler.backend.jsExtendableArrayClass.computeType(compiler), compiler);
  jsIndexableOrNull = new HType.subtype(
      compiler.backend.jsIndexableClass.computeType(compiler), compiler);

  testUnion(compiler);
  testIntersection(compiler);
  testRegressions(compiler);
}