// 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("../../../lib/compiler/implementation/ssa/ssa.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;
HType nonPrimitive1;
HType nonPrimitive2;
HType potentialArray;
HType potentialString;

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(UNKNOWN, 
                BOOLEAN.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                BOOLEAN.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                BOOLEAN.union(FIXED_ARRAY, compiler));

  Expect.equals(NUMBER, 
                NUMBER.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                NUMBER.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NUMBER.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                NUMBER.union(FIXED_ARRAY, compiler));

  Expect.equals(INTEGER, 
                INTEGER.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                INTEGER.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                INTEGER.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                INTEGER.union(FIXED_ARRAY, compiler));

  Expect.equals(DOUBLE, 
                DOUBLE.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                DOUBLE.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                DOUBLE.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                DOUBLE.union(FIXED_ARRAY, compiler));

  Expect.equals(INDEXABLE_PRIMITIVE, 
                INDEXABLE_PRIMITIVE.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                INDEXABLE_PRIMITIVE.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                STRING.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                STRING.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                STRING.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                STRING.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                READABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                READABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                READABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                READABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                READABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                MUTABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                MUTABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                MUTABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                MUTABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                MUTABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                EXTENDABLE_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                EXTENDABLE_ARRAY.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                EXTENDABLE_ARRAY.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                EXTENDABLE_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                EXTENDABLE_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                nonPrimitive1.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive1.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(nonPrimitive1, 
                nonPrimitive1.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                nonPrimitive1.union(FIXED_ARRAY, compiler));

  Expect.equals(nonPrimitive2, 
                nonPrimitive2.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(DOUBLE, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                nonPrimitive2.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                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(UNKNOWN, 
                STRING_OR_NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING_OR_NULL, 
                STRING_OR_NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                STRING_OR_NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                STRING_OR_NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                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(UNKNOWN, 
                NULL.union(INDEXABLE_PRIMITIVE, compiler));
  Expect.equals(STRING_OR_NULL, 
                NULL.union(STRING, compiler));
  Expect.equals(UNKNOWN, 
                NULL.union(READABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NULL.union(MUTABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NULL.union(EXTENDABLE_ARRAY, compiler));
  Expect.equals(UNKNOWN, 
                NULL.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                NULL.union(nonPrimitive2, compiler));
  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(UNKNOWN, 
                NULL.union(FIXED_ARRAY, compiler));

  Expect.equals(FIXED_ARRAY, 
                FIXED_ARRAY.union(CONFLICTING, compiler));
  Expect.equals(UNKNOWN, 
                FIXED_ARRAY.union(UNKNOWN, compiler));
  Expect.equals(UNKNOWN, 
                FIXED_ARRAY.union(BOOLEAN, compiler));
  Expect.equals(UNKNOWN, 
                FIXED_ARRAY.union(NUMBER, compiler));
  Expect.equals(UNKNOWN, 
                FIXED_ARRAY.union(INTEGER, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                FIXED_ARRAY.union(nonPrimitive1, compiler));
  Expect.equals(UNKNOWN, 
                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(UNKNOWN, 
                FIXED_ARRAY.union(STRING_OR_NULL, compiler));
  Expect.equals(UNKNOWN, 
                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(CONFLICTING, 
                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 main() {
  MockCompiler compiler = new MockCompiler();
  nonPrimitive1 = new HBoundedType.nonNull(
      compiler.mapClass.computeType(compiler));
  nonPrimitive2 = new HBoundedType.nonNull(
      compiler.functionClass.computeType(compiler));
  potentialArray = new HBoundedPotentialPrimitiveArray(
      compiler.listClass.computeType(compiler), true);
  potentialString = new HBoundedPotentialPrimitiveString(
      compiler.stringClass.computeType(compiler), true);
  testUnion(compiler);
  testIntersection(compiler);
}