// 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 "package:expect/expect.dart";
import "compiler_helper.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 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 NULL = HType.NULL;
const NON_NULL = HType.NON_NULL;

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

HType jsIndexable;
HType jsReadableArray;
HType jsMutableArray;
HType jsFixedArray;
HType jsExtendableArray;
HType jsString;
HType jsStringOrNull;
HType jsArrayOrNull;
HType jsMutableArrayOrNull;
HType jsFixedArrayOrNull;
HType jsExtendableArrayOrNull;
HType jsIndexableOrNull;
HType jsInterceptorOrNull;


class Pair {
  final first;
  final second;
  Pair(this.first, this.second);
  int get hashCode => first.hashCode * 47 + second.hashCode;
  bool operator==(Pair other) =>
      identical(first, other.first) && identical(second, other.second);
}

class RuleSet {
  final name;
  final operate;
  final Set typesSeen = new Set();
  final Set pairsSeen = new Set();

  RuleSet(this.name, this.operate);

  void rule(type1, type2, result) {
    typesSeen..add(type1)..add(type2);
    var pair1 = new Pair(type1, type2);
    var pair2 = new Pair(type2, type1);
    if (pairsSeen.contains(pair1)) {
      Expect.isFalse(true, 'Redundant rule ($type1, $type2, ...)');
    }
    pairsSeen..add(pair1)..add(pair2);

    var r1 = operate(type1, type2);
    var r2 = operate(type2, type1);
    Expect.equals(result, r1);
    Expect.equals(r1, r2, 'symmetry violation');
  }

  void check(type1, type2, predicate) {
    typesSeen..add(type1)..add(type2);
    var pair = new Pair(type1, type2);
    pairsSeen..add(pair);
    var result = operate(type1, type2);
    Expect.isTrue(predicate(result));
  }

  void validateCoverage() {
    for (var type1 in typesSeen) {
      for (var type2 in typesSeen) {
        var pair = new Pair(type1, type2);
        if (!pairsSeen.contains(pair)) {
          Expect.isTrue(false, 'Missing rule: $name($type1, $type2)');
        }
      }
    }
  }
}

void testUnion(MockCompiler compiler) {
  RuleSet ruleSet = new RuleSet('union',
      (t1, t2) => t1.union(t2, compiler).simplify(compiler));
  rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
  check(type1, type2, predicate) => ruleSet.check(type1, type2, predicate);

  rule(CONFLICTING, CONFLICTING, CONFLICTING);
  rule(CONFLICTING, UNKNOWN, UNKNOWN);
  rule(CONFLICTING, BOOLEAN, BOOLEAN);
  rule(CONFLICTING, NUMBER, NUMBER);
  rule(CONFLICTING, INTEGER, INTEGER);
  rule(CONFLICTING, DOUBLE, DOUBLE);
  rule(CONFLICTING, jsIndexable, jsIndexable);
  rule(CONFLICTING, jsString, jsString);
  rule(CONFLICTING, jsReadableArray, jsReadableArray);
  rule(CONFLICTING, jsMutableArray, jsMutableArray);
  rule(CONFLICTING, jsExtendableArray, jsExtendableArray);
  rule(CONFLICTING, nonPrimitive1, nonPrimitive1);
  rule(CONFLICTING, nonPrimitive2, nonPrimitive2);
  rule(CONFLICTING, potentialArray, potentialArray);
  rule(CONFLICTING, potentialString, potentialString);
  rule(CONFLICTING, BOOLEAN_OR_NULL, BOOLEAN_OR_NULL);
  rule(CONFLICTING, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(CONFLICTING, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(CONFLICTING, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(CONFLICTING, jsStringOrNull, jsStringOrNull);
  rule(CONFLICTING, NULL, NULL);
  rule(CONFLICTING, jsFixedArray, jsFixedArray);

  rule(UNKNOWN, UNKNOWN, UNKNOWN);
  rule(UNKNOWN, BOOLEAN, UNKNOWN);
  rule(UNKNOWN, NUMBER, UNKNOWN);
  rule(UNKNOWN, INTEGER, UNKNOWN);
  rule(UNKNOWN, DOUBLE, UNKNOWN);
  rule(UNKNOWN, jsIndexable, UNKNOWN);
  rule(UNKNOWN, jsString, UNKNOWN);
  rule(UNKNOWN, jsReadableArray, UNKNOWN);
  rule(UNKNOWN, jsMutableArray, UNKNOWN);
  rule(UNKNOWN, jsExtendableArray, UNKNOWN);
  rule(UNKNOWN, nonPrimitive1, UNKNOWN);
  rule(UNKNOWN, nonPrimitive2, UNKNOWN);
  rule(UNKNOWN, potentialArray, UNKNOWN);
  rule(UNKNOWN, potentialString, UNKNOWN);
  rule(UNKNOWN, BOOLEAN_OR_NULL, UNKNOWN);
  rule(UNKNOWN, NUMBER_OR_NULL, UNKNOWN);
  rule(UNKNOWN, INTEGER_OR_NULL, UNKNOWN);
  rule(UNKNOWN, DOUBLE_OR_NULL, UNKNOWN);
  rule(UNKNOWN, jsStringOrNull, UNKNOWN);
  rule(UNKNOWN, NULL, UNKNOWN);
  rule(UNKNOWN, jsFixedArray, UNKNOWN);

  rule(BOOLEAN, BOOLEAN, BOOLEAN);
  rule(BOOLEAN, NUMBER, jsInterceptor);
  rule(BOOLEAN, INTEGER, jsInterceptor);
  rule(BOOLEAN, DOUBLE, jsInterceptor);
  rule(BOOLEAN, jsIndexable, NON_NULL);
  rule(BOOLEAN, jsString, jsInterceptor);
  rule(BOOLEAN, jsReadableArray, jsInterceptor);
  rule(BOOLEAN, jsMutableArray, jsInterceptor);
  rule(BOOLEAN, jsExtendableArray, jsInterceptor);
  rule(BOOLEAN, nonPrimitive1, NON_NULL);
  rule(BOOLEAN, nonPrimitive2, NON_NULL);
  rule(BOOLEAN, potentialArray, UNKNOWN);
  rule(BOOLEAN, potentialString, UNKNOWN);
  rule(BOOLEAN, BOOLEAN_OR_NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN, jsStringOrNull, jsInterceptorOrNull);
  rule(BOOLEAN, NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN, jsFixedArray, jsInterceptor);

  rule(NUMBER, NUMBER, NUMBER);
  rule(NUMBER, INTEGER, NUMBER);
  rule(NUMBER, DOUBLE, NUMBER);
  rule(NUMBER, jsIndexable, NON_NULL);
  rule(NUMBER, jsString, jsInterceptor);
  rule(NUMBER, jsReadableArray, jsInterceptor);
  rule(NUMBER, jsMutableArray, jsInterceptor);
  rule(NUMBER, jsExtendableArray, jsInterceptor);
  rule(NUMBER, nonPrimitive1, NON_NULL);
  rule(NUMBER, nonPrimitive2, NON_NULL);
  rule(NUMBER, potentialArray, UNKNOWN);
  rule(NUMBER, potentialString, UNKNOWN);
  rule(NUMBER, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(NUMBER, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER, INTEGER_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER, DOUBLE_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER, jsStringOrNull, jsInterceptorOrNull);
  rule(NUMBER, NULL, NUMBER_OR_NULL);
  rule(NUMBER, jsFixedArray, jsInterceptor);

  rule(INTEGER, INTEGER, INTEGER);
  rule(INTEGER, DOUBLE, NUMBER);
  rule(INTEGER, jsIndexable, NON_NULL);
  rule(INTEGER, jsString, jsInterceptor);
  rule(INTEGER, jsReadableArray, jsInterceptor);
  rule(INTEGER, jsMutableArray, jsInterceptor);
  rule(INTEGER, jsExtendableArray, jsInterceptor);
  rule(INTEGER, nonPrimitive1, NON_NULL);
  rule(INTEGER, nonPrimitive2, NON_NULL);
  rule(INTEGER, potentialArray, UNKNOWN);
  rule(INTEGER, potentialString, UNKNOWN);
  rule(INTEGER, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(INTEGER, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(INTEGER, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(INTEGER, DOUBLE_OR_NULL, NUMBER_OR_NULL);
  rule(INTEGER, jsStringOrNull, jsInterceptorOrNull);
  rule(INTEGER, NULL, INTEGER_OR_NULL);
  rule(INTEGER, jsFixedArray, jsInterceptor);

  rule(DOUBLE, DOUBLE, DOUBLE);
  rule(DOUBLE, jsIndexable, NON_NULL);
  rule(DOUBLE, jsString, jsInterceptor);
  rule(DOUBLE, jsReadableArray, jsInterceptor);
  rule(DOUBLE, jsMutableArray, jsInterceptor);
  rule(DOUBLE, jsExtendableArray, jsInterceptor);
  rule(DOUBLE, nonPrimitive1, NON_NULL);
  rule(DOUBLE, nonPrimitive2, NON_NULL);
  rule(DOUBLE, potentialArray, UNKNOWN);
  rule(DOUBLE, potentialString, UNKNOWN);
  rule(DOUBLE, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(DOUBLE, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(DOUBLE, INTEGER_OR_NULL, NUMBER_OR_NULL);
  rule(DOUBLE, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(DOUBLE, jsStringOrNull, jsInterceptorOrNull);
  rule(DOUBLE, NULL, DOUBLE_OR_NULL);
  rule(DOUBLE, jsFixedArray, jsInterceptor);

  rule(jsIndexable, jsIndexable, jsIndexable);
  rule(jsIndexable, jsString, jsIndexable);
  rule(jsIndexable, jsReadableArray, jsIndexable);
  rule(jsIndexable, jsMutableArray, jsIndexable);
  rule(jsIndexable, jsExtendableArray, jsIndexable);
  rule(jsIndexable, nonPrimitive1, NON_NULL);
  rule(jsIndexable, nonPrimitive2, NON_NULL);
  rule(jsIndexable, potentialArray, UNKNOWN);
  rule(jsIndexable, potentialString, UNKNOWN);
  rule(jsIndexable, BOOLEAN_OR_NULL, UNKNOWN);
  rule(jsIndexable, NUMBER_OR_NULL, UNKNOWN);
  rule(jsIndexable, INTEGER_OR_NULL, UNKNOWN);
  rule(jsIndexable, DOUBLE_OR_NULL, UNKNOWN);
  rule(jsIndexable, jsStringOrNull, jsIndexableOrNull);
  rule(jsIndexable, NULL, jsIndexableOrNull);
  rule(jsIndexable, jsFixedArray, jsIndexable);

  rule(jsString, jsString, jsString);
  rule(jsString, jsReadableArray, jsIndexable);
  rule(jsString, jsMutableArray, jsIndexable);
  rule(jsString, jsExtendableArray, jsIndexable);
  rule(jsString, nonPrimitive1, NON_NULL);
  rule(jsString, nonPrimitive2, NON_NULL);
  rule(jsString, potentialArray, UNKNOWN);
  rule(jsString, potentialString, potentialString);
  rule(jsString, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(jsString, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(jsString, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(jsString, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(jsString, jsStringOrNull, jsStringOrNull);
  rule(jsString, NULL, jsStringOrNull);
  rule(jsString, jsFixedArray, jsIndexable);

  rule(jsReadableArray, jsReadableArray, jsReadableArray);
  rule(jsReadableArray, jsMutableArray, jsReadableArray);
  rule(jsReadableArray, jsExtendableArray, jsReadableArray);
  rule(jsReadableArray, nonPrimitive1, NON_NULL);
  rule(jsReadableArray, nonPrimitive2, NON_NULL);
  rule(jsReadableArray, potentialArray, potentialArray);
  rule(jsReadableArray, potentialString, UNKNOWN);
  rule(jsReadableArray, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(jsReadableArray, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(jsReadableArray, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(jsReadableArray, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(jsReadableArray, jsStringOrNull, jsIndexableOrNull);
  rule(jsReadableArray, NULL, jsArrayOrNull);
  rule(jsReadableArray, jsFixedArray, jsReadableArray);

  rule(jsMutableArray, jsMutableArray, jsMutableArray);
  rule(jsMutableArray, jsExtendableArray, jsMutableArray);
  rule(jsMutableArray, nonPrimitive1, NON_NULL);
  rule(jsMutableArray, nonPrimitive2, NON_NULL);
  rule(jsMutableArray, potentialArray, potentialArray);
  rule(jsMutableArray, potentialString, UNKNOWN);
  rule(jsMutableArray, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(jsMutableArray, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(jsMutableArray, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(jsMutableArray, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(jsMutableArray, jsStringOrNull, jsIndexableOrNull);
  rule(jsMutableArray, NULL, jsMutableArrayOrNull);
  rule(jsMutableArray, jsFixedArray, jsMutableArray);

  rule(jsExtendableArray, jsExtendableArray, jsExtendableArray);
  rule(jsExtendableArray, nonPrimitive1, NON_NULL);
  rule(jsExtendableArray, nonPrimitive2, NON_NULL);
  rule(jsExtendableArray, potentialArray, potentialArray);
  rule(jsExtendableArray, potentialString, UNKNOWN);
  rule(jsExtendableArray, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(jsExtendableArray, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(jsExtendableArray, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(jsExtendableArray, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(jsExtendableArray, jsStringOrNull, jsIndexableOrNull);
  rule(jsExtendableArray, NULL, jsExtendableArrayOrNull);
  rule(jsExtendableArray, jsFixedArray, jsMutableArray);

  rule(nonPrimitive1, nonPrimitive1, nonPrimitive1);
  rule(nonPrimitive1, nonPrimitive2, NON_NULL);
  rule(nonPrimitive1, potentialArray, UNKNOWN);
  rule(nonPrimitive1, potentialString, UNKNOWN);
  rule(nonPrimitive1, BOOLEAN_OR_NULL, UNKNOWN);
  rule(nonPrimitive1, NUMBER_OR_NULL, UNKNOWN);
  rule(nonPrimitive1, INTEGER_OR_NULL, UNKNOWN);
  rule(nonPrimitive1, DOUBLE_OR_NULL, UNKNOWN);
  rule(nonPrimitive1, jsStringOrNull, UNKNOWN);
  rule(nonPrimitive1, jsFixedArray, NON_NULL);

  rule(nonPrimitive2, nonPrimitive2, nonPrimitive2);
  rule(nonPrimitive2, potentialArray, UNKNOWN);
  rule(nonPrimitive2, potentialString, UNKNOWN);
  rule(nonPrimitive2, BOOLEAN_OR_NULL, UNKNOWN);
  rule(nonPrimitive2, NUMBER_OR_NULL, UNKNOWN);
  rule(nonPrimitive2, INTEGER_OR_NULL, UNKNOWN);
  rule(nonPrimitive2, DOUBLE_OR_NULL, UNKNOWN);
  rule(nonPrimitive2, jsStringOrNull, UNKNOWN);
  rule(nonPrimitive2, jsFixedArray, NON_NULL);

  rule(potentialArray, potentialArray, potentialArray);
  rule(potentialArray, potentialString, UNKNOWN);
  rule(potentialArray, BOOLEAN_OR_NULL, UNKNOWN);
  rule(potentialArray, NUMBER_OR_NULL, UNKNOWN);
  rule(potentialArray, INTEGER_OR_NULL, UNKNOWN);
  rule(potentialArray, DOUBLE_OR_NULL, UNKNOWN);
  rule(potentialArray, jsStringOrNull, UNKNOWN);
  rule(potentialArray, NULL, potentialArray);
  rule(potentialArray, jsFixedArray, potentialArray);

  rule(potentialString, potentialString, potentialString);
  rule(potentialString, BOOLEAN_OR_NULL, UNKNOWN);
  rule(potentialString, NUMBER_OR_NULL, UNKNOWN);
  rule(potentialString, INTEGER_OR_NULL, UNKNOWN);
  rule(potentialString, DOUBLE_OR_NULL, UNKNOWN);
  rule(potentialString, jsStringOrNull, potentialString);
  rule(potentialString, NULL, potentialString);
  rule(potentialString, jsFixedArray, UNKNOWN);

  rule(BOOLEAN_OR_NULL, BOOLEAN_OR_NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN_OR_NULL, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN_OR_NULL, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN_OR_NULL, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN_OR_NULL, jsStringOrNull, jsInterceptorOrNull);
  rule(BOOLEAN_OR_NULL, NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN_OR_NULL, jsFixedArray, jsInterceptorOrNull);

  rule(NUMBER_OR_NULL, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, INTEGER_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, DOUBLE_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, jsStringOrNull, jsInterceptorOrNull);
  rule(NUMBER_OR_NULL, NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, jsFixedArray, jsInterceptorOrNull);

  rule(INTEGER_OR_NULL, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(INTEGER_OR_NULL, DOUBLE_OR_NULL, NUMBER_OR_NULL);
  rule(INTEGER_OR_NULL, jsStringOrNull, jsInterceptorOrNull);
  rule(INTEGER_OR_NULL, NULL, INTEGER_OR_NULL);
  rule(INTEGER_OR_NULL, jsFixedArray, jsInterceptorOrNull);

  rule(DOUBLE_OR_NULL, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, jsStringOrNull, jsInterceptorOrNull);
  rule(DOUBLE_OR_NULL, NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, jsFixedArray, jsInterceptorOrNull);

  rule(jsStringOrNull, jsStringOrNull, jsStringOrNull);
  rule(jsStringOrNull, NULL, jsStringOrNull);
  rule(jsStringOrNull, jsFixedArray, jsIndexableOrNull);

  rule(NULL, NULL, NULL);
  rule(NULL, jsFixedArray, jsFixedArrayOrNull);

  rule(jsFixedArray, jsFixedArray, jsFixedArray);

  check(nonPrimitive1, NULL, (type) => type is HBoundedType);
  check(nonPrimitive2, NULL, (type) => type is HBoundedType);
  check(NULL, nonPrimitive1, (type) => type.canBeNull());
  check(NULL, nonPrimitive2, (type) => type.canBeNull());

  ruleSet.validateCoverage();
}

void testIntersection(MockCompiler compiler) {
  RuleSet ruleSet = new RuleSet('intersection',
                                (t1, t2) => t1.intersection(t2, compiler));
  rule(type1, type2, result) => ruleSet.rule(type1, type2, result);

  rule(CONFLICTING, CONFLICTING, CONFLICTING);
  rule(CONFLICTING, UNKNOWN, CONFLICTING);
  rule(CONFLICTING, BOOLEAN, CONFLICTING);
  rule(CONFLICTING, NUMBER, CONFLICTING);
  rule(CONFLICTING, INTEGER, CONFLICTING);
  rule(CONFLICTING, DOUBLE, CONFLICTING);
  rule(CONFLICTING, jsIndexable, CONFLICTING);
  rule(CONFLICTING, jsString, CONFLICTING);
  rule(CONFLICTING, jsReadableArray, CONFLICTING);
  rule(CONFLICTING, jsMutableArray, CONFLICTING);
  rule(CONFLICTING, jsExtendableArray, CONFLICTING);
  rule(CONFLICTING, nonPrimitive1, CONFLICTING);
  rule(CONFLICTING, nonPrimitive2, CONFLICTING);
  rule(CONFLICTING, potentialArray, CONFLICTING);
  rule(CONFLICTING, potentialString, CONFLICTING);
  rule(CONFLICTING, BOOLEAN_OR_NULL, CONFLICTING);
  rule(CONFLICTING, NUMBER_OR_NULL, CONFLICTING);
  rule(CONFLICTING, INTEGER_OR_NULL, CONFLICTING);
  rule(CONFLICTING, DOUBLE_OR_NULL, CONFLICTING);
  rule(CONFLICTING, jsStringOrNull, CONFLICTING);
  rule(CONFLICTING, NULL, CONFLICTING);
  rule(CONFLICTING, jsFixedArray, CONFLICTING);

  rule(UNKNOWN, UNKNOWN, UNKNOWN);
  rule(UNKNOWN, BOOLEAN, BOOLEAN);
  rule(UNKNOWN, NUMBER, NUMBER);
  rule(UNKNOWN, INTEGER, INTEGER);
  rule(UNKNOWN, DOUBLE, DOUBLE);
  rule(UNKNOWN, jsIndexable, jsIndexable);
  rule(UNKNOWN, jsString, jsString);
  rule(UNKNOWN, jsReadableArray, jsReadableArray);
  rule(UNKNOWN, jsMutableArray, jsMutableArray);
  rule(UNKNOWN, jsExtendableArray, jsExtendableArray);
  rule(UNKNOWN, nonPrimitive1, nonPrimitive1);
  rule(UNKNOWN, nonPrimitive2, nonPrimitive2);
  rule(UNKNOWN, potentialArray, potentialArray);
  rule(UNKNOWN, potentialString, potentialString);
  rule(UNKNOWN, BOOLEAN_OR_NULL, BOOLEAN_OR_NULL);
  rule(UNKNOWN, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(UNKNOWN, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(UNKNOWN, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(UNKNOWN, jsStringOrNull, jsStringOrNull);
  rule(UNKNOWN, NULL, NULL);
  rule(UNKNOWN, jsFixedArray, jsFixedArray);

  rule(BOOLEAN, BOOLEAN, BOOLEAN);
  rule(BOOLEAN, NUMBER, CONFLICTING);
  rule(BOOLEAN, INTEGER, CONFLICTING);
  rule(BOOLEAN, DOUBLE, CONFLICTING);
  rule(BOOLEAN, jsIndexable, CONFLICTING);
  rule(BOOLEAN, jsString, CONFLICTING);
  rule(BOOLEAN, jsReadableArray, CONFLICTING);
  rule(BOOLEAN, jsMutableArray, CONFLICTING);
  rule(BOOLEAN, jsExtendableArray, CONFLICTING);
  rule(BOOLEAN, nonPrimitive1, CONFLICTING);
  rule(BOOLEAN, nonPrimitive2, CONFLICTING);
  rule(BOOLEAN, potentialArray, CONFLICTING);
  rule(BOOLEAN, potentialString, CONFLICTING);
  rule(BOOLEAN, BOOLEAN_OR_NULL, BOOLEAN);
  rule(BOOLEAN, NUMBER_OR_NULL, CONFLICTING);
  rule(BOOLEAN, INTEGER_OR_NULL, CONFLICTING);
  rule(BOOLEAN, DOUBLE_OR_NULL, CONFLICTING);
  rule(BOOLEAN, jsStringOrNull, CONFLICTING);
  rule(BOOLEAN, NULL, CONFLICTING);
  rule(BOOLEAN, jsFixedArray, CONFLICTING);

  rule(NUMBER, NUMBER, NUMBER);
  rule(NUMBER, INTEGER, INTEGER);
  rule(NUMBER, DOUBLE, DOUBLE);
  rule(NUMBER, jsIndexable, CONFLICTING);
  rule(NUMBER, jsString, CONFLICTING);
  rule(NUMBER, jsReadableArray, CONFLICTING);
  rule(NUMBER, jsMutableArray, CONFLICTING);
  rule(NUMBER, jsExtendableArray, CONFLICTING);
  rule(NUMBER, nonPrimitive1, CONFLICTING);
  rule(NUMBER, nonPrimitive2, CONFLICTING);
  rule(NUMBER, potentialArray, CONFLICTING);
  rule(NUMBER, potentialString, CONFLICTING);
  rule(NUMBER, BOOLEAN_OR_NULL, CONFLICTING);
  rule(NUMBER, NUMBER_OR_NULL, NUMBER);
  rule(NUMBER, INTEGER_OR_NULL, INTEGER);
  rule(NUMBER, DOUBLE_OR_NULL, DOUBLE);
  rule(NUMBER, jsStringOrNull, CONFLICTING);
  rule(NUMBER, NULL, CONFLICTING);
  rule(NUMBER, jsFixedArray, CONFLICTING);

  rule(INTEGER, INTEGER, INTEGER);
  rule(INTEGER, DOUBLE, CONFLICTING);
  rule(INTEGER, jsIndexable, CONFLICTING);
  rule(INTEGER, jsString, CONFLICTING);
  rule(INTEGER, jsReadableArray, CONFLICTING);
  rule(INTEGER, jsMutableArray, CONFLICTING);
  rule(INTEGER, jsExtendableArray, CONFLICTING);
  rule(INTEGER, nonPrimitive1, CONFLICTING);
  rule(INTEGER, nonPrimitive2, CONFLICTING);
  rule(INTEGER, potentialArray, CONFLICTING);
  rule(INTEGER, potentialString, CONFLICTING);
  rule(INTEGER, BOOLEAN_OR_NULL, CONFLICTING);
  rule(INTEGER, NUMBER_OR_NULL, INTEGER);
  rule(INTEGER, INTEGER_OR_NULL, INTEGER);
  rule(INTEGER, DOUBLE_OR_NULL, CONFLICTING);
  rule(INTEGER, jsStringOrNull, CONFLICTING);
  rule(INTEGER, NULL, CONFLICTING);
  rule(INTEGER, jsFixedArray, CONFLICTING);

  rule(DOUBLE, DOUBLE, DOUBLE);
  rule(DOUBLE, jsIndexable, CONFLICTING);
  rule(DOUBLE, jsString, CONFLICTING);
  rule(DOUBLE, jsReadableArray, CONFLICTING);
  rule(DOUBLE, jsMutableArray, CONFLICTING);
  rule(DOUBLE, jsExtendableArray, CONFLICTING);
  rule(DOUBLE, nonPrimitive1, CONFLICTING);
  rule(DOUBLE, nonPrimitive2, CONFLICTING);
  rule(DOUBLE, potentialArray, CONFLICTING);
  rule(DOUBLE, potentialString, CONFLICTING);
  rule(DOUBLE, BOOLEAN_OR_NULL, CONFLICTING);
  rule(DOUBLE, NUMBER_OR_NULL, DOUBLE);
  rule(DOUBLE, INTEGER_OR_NULL, CONFLICTING);
  rule(DOUBLE, DOUBLE_OR_NULL, DOUBLE);
  rule(DOUBLE, jsStringOrNull, CONFLICTING);
  rule(DOUBLE, NULL, CONFLICTING);
  rule(DOUBLE, jsFixedArray, CONFLICTING);

  rule(jsIndexable, jsIndexable, jsIndexable);
  rule(jsIndexable, jsString, jsString);
  rule(jsIndexable, jsReadableArray, jsReadableArray);
  rule(jsIndexable, jsMutableArray, jsMutableArray);
  rule(jsIndexable, jsExtendableArray, jsExtendableArray);
  rule(jsIndexable, nonPrimitive1, CONFLICTING);
  rule(jsIndexable, nonPrimitive2, CONFLICTING);
  rule(jsIndexable, potentialArray, new HType.nonNullSubtype(
      compiler.backend.jsArrayClass.computeType(compiler), compiler));
  rule(jsIndexable, potentialString, jsString);
  rule(jsIndexable, BOOLEAN_OR_NULL, CONFLICTING);
  rule(jsIndexable, NUMBER_OR_NULL, CONFLICTING);
  rule(jsIndexable, INTEGER_OR_NULL, CONFLICTING);
  rule(jsIndexable, DOUBLE_OR_NULL, CONFLICTING);
  rule(jsIndexable, jsStringOrNull, jsString);
  rule(jsIndexable, NULL, CONFLICTING);
  rule(jsIndexable, jsFixedArray, jsFixedArray);

  rule(jsString, jsString, jsString);
  rule(jsString, jsReadableArray, CONFLICTING);
  rule(jsString, jsMutableArray, CONFLICTING);
  rule(jsString, jsExtendableArray, CONFLICTING);
  rule(jsString, nonPrimitive1, CONFLICTING);
  rule(jsString, nonPrimitive2, CONFLICTING);
  rule(jsString, potentialArray, CONFLICTING);
  rule(jsString, potentialString, jsString);
  rule(jsString, BOOLEAN_OR_NULL, CONFLICTING);
  rule(jsString, NUMBER_OR_NULL, CONFLICTING);
  rule(jsString, INTEGER_OR_NULL, CONFLICTING);
  rule(jsString, DOUBLE_OR_NULL, CONFLICTING);
  rule(jsString, jsStringOrNull, jsString);
  rule(jsString, NULL, CONFLICTING);
  rule(jsString, jsFixedArray, CONFLICTING);

  rule(jsReadableArray, jsReadableArray, jsReadableArray);
  rule(jsReadableArray, jsMutableArray, jsMutableArray);
  rule(jsReadableArray, jsExtendableArray, jsExtendableArray);
  rule(jsReadableArray, nonPrimitive1, CONFLICTING);
  rule(jsReadableArray, nonPrimitive2, CONFLICTING);
  rule(jsReadableArray, potentialArray, jsReadableArray);
  rule(jsReadableArray, potentialString, CONFLICTING);
  rule(jsReadableArray, BOOLEAN_OR_NULL, CONFLICTING);
  rule(jsReadableArray, NUMBER_OR_NULL, CONFLICTING);
  rule(jsReadableArray, INTEGER_OR_NULL, CONFLICTING);
  rule(jsReadableArray, DOUBLE_OR_NULL, CONFLICTING);
  rule(jsReadableArray, jsStringOrNull, CONFLICTING);
  rule(jsReadableArray, NULL, CONFLICTING);
  rule(jsReadableArray, jsFixedArray, jsFixedArray);

  rule(jsMutableArray, jsMutableArray, jsMutableArray);
  rule(jsMutableArray, jsExtendableArray, jsExtendableArray);
  rule(jsMutableArray, nonPrimitive1, CONFLICTING);
  rule(jsMutableArray, nonPrimitive2, CONFLICTING);
  rule(jsMutableArray, potentialArray, jsMutableArray);
  rule(jsMutableArray, potentialString, CONFLICTING);
  rule(jsMutableArray, BOOLEAN_OR_NULL, CONFLICTING);
  rule(jsMutableArray, NUMBER_OR_NULL, CONFLICTING);
  rule(jsMutableArray, INTEGER_OR_NULL, CONFLICTING);
  rule(jsMutableArray, DOUBLE_OR_NULL, CONFLICTING);
  rule(jsMutableArray, jsStringOrNull, CONFLICTING);
  rule(jsMutableArray, NULL, CONFLICTING);
  rule(jsMutableArray, jsFixedArray, jsFixedArray);

  rule(jsExtendableArray, jsExtendableArray, jsExtendableArray);
  rule(jsExtendableArray, nonPrimitive1, CONFLICTING);
  rule(jsExtendableArray, nonPrimitive2, CONFLICTING);
  rule(jsExtendableArray, potentialArray, jsExtendableArray);
  rule(jsExtendableArray, potentialString, CONFLICTING);
  rule(jsExtendableArray, BOOLEAN_OR_NULL, CONFLICTING);
  rule(jsExtendableArray, NUMBER_OR_NULL, CONFLICTING);
  rule(jsExtendableArray, INTEGER_OR_NULL, CONFLICTING);
  rule(jsExtendableArray, DOUBLE_OR_NULL, CONFLICTING);
  rule(jsExtendableArray, jsStringOrNull, CONFLICTING);
  rule(jsExtendableArray, NULL, CONFLICTING);
  rule(jsExtendableArray, jsFixedArray, CONFLICTING);

  rule(nonPrimitive1, nonPrimitive1, nonPrimitive1);
  rule(nonPrimitive1, nonPrimitive2, CONFLICTING);
  rule(nonPrimitive1, potentialArray, CONFLICTING);
  rule(nonPrimitive1, potentialString, CONFLICTING);
  rule(nonPrimitive1, BOOLEAN_OR_NULL, CONFLICTING);
  rule(nonPrimitive1, NUMBER_OR_NULL, CONFLICTING);
  rule(nonPrimitive1, INTEGER_OR_NULL, CONFLICTING);
  rule(nonPrimitive1, DOUBLE_OR_NULL, CONFLICTING);
  rule(nonPrimitive1, jsStringOrNull, CONFLICTING);
  rule(nonPrimitive1, NULL, CONFLICTING);
  rule(nonPrimitive1, jsFixedArray, CONFLICTING);

  rule(nonPrimitive2, nonPrimitive2, nonPrimitive2);
  rule(nonPrimitive2, potentialArray, CONFLICTING);
  rule(nonPrimitive2, potentialString, CONFLICTING);
  rule(nonPrimitive2, BOOLEAN_OR_NULL, CONFLICTING);
  rule(nonPrimitive2, NUMBER_OR_NULL, CONFLICTING);
  rule(nonPrimitive2, INTEGER_OR_NULL, CONFLICTING);
  rule(nonPrimitive2, DOUBLE_OR_NULL, CONFLICTING);
  rule(nonPrimitive2, jsStringOrNull, CONFLICTING);
  rule(nonPrimitive2, NULL, CONFLICTING);
  rule(nonPrimitive2, jsFixedArray, CONFLICTING);

  rule(potentialArray, potentialArray, potentialArray);
  rule(potentialArray, potentialString, NULL);
  rule(potentialArray, BOOLEAN_OR_NULL, NULL);
  rule(potentialArray, NUMBER_OR_NULL, NULL);
  rule(potentialArray, INTEGER_OR_NULL, NULL);
  rule(potentialArray, DOUBLE_OR_NULL, NULL);
  rule(potentialArray, jsStringOrNull, NULL);
  rule(potentialArray, NULL, NULL);
  rule(potentialArray, jsFixedArray, jsFixedArray);

  rule(potentialString, potentialString, potentialString);
  rule(potentialString, BOOLEAN_OR_NULL, NULL);
  rule(potentialString, NUMBER_OR_NULL, NULL);
  rule(potentialString, INTEGER_OR_NULL, NULL);
  rule(potentialString, DOUBLE_OR_NULL, NULL);
  rule(potentialString, jsStringOrNull, jsStringOrNull);
  rule(potentialString, NULL, NULL);
  rule(potentialString, jsFixedArray, CONFLICTING);

  rule(BOOLEAN_OR_NULL, BOOLEAN_OR_NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN_OR_NULL, NUMBER_OR_NULL, NULL);
  rule(BOOLEAN_OR_NULL, INTEGER_OR_NULL, NULL);
  rule(BOOLEAN_OR_NULL, DOUBLE_OR_NULL, NULL);
  rule(BOOLEAN_OR_NULL, jsStringOrNull, NULL);
  rule(BOOLEAN_OR_NULL, NULL, NULL);
  rule(BOOLEAN_OR_NULL, jsFixedArray, CONFLICTING);

  rule(NUMBER_OR_NULL, NUMBER_OR_NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(NUMBER_OR_NULL, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(NUMBER_OR_NULL, jsStringOrNull, NULL);
  rule(NUMBER_OR_NULL, NULL, NULL);
  rule(NUMBER_OR_NULL, jsFixedArray, CONFLICTING);

  rule(INTEGER_OR_NULL, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(INTEGER_OR_NULL, DOUBLE_OR_NULL, NULL);
  rule(INTEGER_OR_NULL, jsStringOrNull, NULL);
  rule(INTEGER_OR_NULL, NULL, NULL);
  rule(INTEGER_OR_NULL, jsFixedArray, CONFLICTING);

  rule(DOUBLE_OR_NULL, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, jsStringOrNull, NULL);
  rule(DOUBLE_OR_NULL, NULL, NULL);
  rule(DOUBLE_OR_NULL, jsFixedArray, CONFLICTING);

  rule(jsStringOrNull, jsStringOrNull, jsStringOrNull);
  rule(jsStringOrNull, NULL, NULL);
  rule(jsStringOrNull, jsFixedArray, CONFLICTING);

  rule(NULL, NULL, NULL);
  rule(NULL, jsFixedArray, CONFLICTING);

  rule(jsFixedArray, jsFixedArray, jsFixedArray);

  ruleSet.validateCoverage();
}

void testRegressions(MockCompiler compiler) {
  HType nonNullPotentialString = new HType.nonNullSubtype(
      patternClass.computeType(compiler), compiler);
  Expect.equals(
      potentialString, jsStringOrNull.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);
  jsInterceptor = new HType.nonNullSubclass(
      compiler.backend.jsInterceptorClass.computeType(compiler), compiler);
  jsArrayOrNull = new HType.subclass(
      compiler.backend.jsArrayClass.computeType(compiler), compiler);
  jsReadableArray = new HType.nonNullSubclass(
      compiler.backend.jsArrayClass.computeType(compiler), compiler);
  jsMutableArrayOrNull = new HType.subclass(
      compiler.backend.jsMutableArrayClass.computeType(compiler), compiler);
  jsMutableArray = new HType.nonNullSubclass(
      compiler.backend.jsMutableArrayClass.computeType(compiler), compiler);
  jsFixedArrayOrNull = new HType.exact(
      compiler.backend.jsFixedArrayClass.computeType(compiler), compiler);
  jsFixedArray = new HType.nonNullExact(
      compiler.backend.jsFixedArrayClass.computeType(compiler), compiler);
  jsExtendableArrayOrNull = new HType.exact(
      compiler.backend.jsExtendableArrayClass.computeType(compiler), compiler);
  jsExtendableArray = new HType.nonNullExact(
      compiler.backend.jsExtendableArrayClass.computeType(compiler), compiler);
  jsIndexableOrNull = new HType.subtype(
      compiler.backend.jsIndexableClass.computeType(compiler), compiler);
  jsIndexable = new HType.nonNullSubtype(
      compiler.backend.jsIndexableClass.computeType(compiler), compiler);
  jsInterceptorOrNull = new HType.subclass(
      compiler.backend.jsInterceptorClass.computeType(compiler), compiler);
  jsStringOrNull = new HType.exact(
      compiler.backend.jsStringClass.computeType(compiler), compiler);
  jsString = new HType.nonNullExact(
      compiler.backend.jsStringClass.computeType(compiler), compiler);

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