// 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 INDEXABLE_PRIMITIVE = HType.INDEXABLE_PRIMITIVE;
const STRING = HType.STRING;
const READABLE_ARRAY = HType.READABLE_ARRAY;
const MUTABLE_ARRAY = HType.MUTABLE_ARRAY;
const FIXED_ARRAY = HType.FIXED_ARRAY;
const EXTENDABLE_ARRAY = HType.EXTENDABLE_ARRAY;
const BOOLEAN_OR_NULL = HType.BOOLEAN_OR_NULL;
const NUMBER_OR_NULL = HType.NUMBER_OR_NULL;
const INTEGER_OR_NULL = HType.INTEGER_OR_NULL;
const DOUBLE_OR_NULL = HType.DOUBLE_OR_NULL;
const STRING_OR_NULL = HType.STRING_OR_NULL;
const NULL = HType.NULL;
const NON_NULL = HType.NON_NULL;

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

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, INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE);
  rule(CONFLICTING, STRING, STRING);
  rule(CONFLICTING, READABLE_ARRAY, READABLE_ARRAY);
  rule(CONFLICTING, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(CONFLICTING, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  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, STRING_OR_NULL, STRING_OR_NULL);
  rule(CONFLICTING, NULL, NULL);
  rule(CONFLICTING, FIXED_ARRAY, FIXED_ARRAY);

  rule(UNKNOWN, UNKNOWN, UNKNOWN);
  rule(UNKNOWN, BOOLEAN, UNKNOWN);
  rule(UNKNOWN, NUMBER, UNKNOWN);
  rule(UNKNOWN, INTEGER, UNKNOWN);
  rule(UNKNOWN, DOUBLE, UNKNOWN);
  rule(UNKNOWN, INDEXABLE_PRIMITIVE, UNKNOWN);
  rule(UNKNOWN, STRING, UNKNOWN);
  rule(UNKNOWN, READABLE_ARRAY, UNKNOWN);
  rule(UNKNOWN, MUTABLE_ARRAY, UNKNOWN);
  rule(UNKNOWN, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, UNKNOWN);
  rule(UNKNOWN, NULL, UNKNOWN);
  rule(UNKNOWN, FIXED_ARRAY, UNKNOWN);

  rule(BOOLEAN, BOOLEAN, BOOLEAN);
  rule(BOOLEAN, NUMBER, jsInterceptor);
  rule(BOOLEAN, INTEGER, jsInterceptor);
  rule(BOOLEAN, DOUBLE, jsInterceptor);
  rule(BOOLEAN, INDEXABLE_PRIMITIVE, NON_NULL);
  rule(BOOLEAN, STRING, jsInterceptor);
  rule(BOOLEAN, READABLE_ARRAY, jsInterceptor);
  rule(BOOLEAN, MUTABLE_ARRAY, jsInterceptor);
  rule(BOOLEAN, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN, NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN, FIXED_ARRAY, jsInterceptor);

  rule(NUMBER, NUMBER, NUMBER);
  rule(NUMBER, INTEGER, NUMBER);
  rule(NUMBER, DOUBLE, NUMBER);
  rule(NUMBER, INDEXABLE_PRIMITIVE, NON_NULL);
  rule(NUMBER, STRING, jsInterceptor);
  rule(NUMBER, READABLE_ARRAY, jsInterceptor);
  rule(NUMBER, MUTABLE_ARRAY, jsInterceptor);
  rule(NUMBER, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(NUMBER, NULL, NUMBER_OR_NULL);
  rule(NUMBER, FIXED_ARRAY, jsInterceptor);

  rule(INTEGER, INTEGER, INTEGER);
  rule(INTEGER, DOUBLE, NUMBER);
  rule(INTEGER, INDEXABLE_PRIMITIVE, NON_NULL);
  rule(INTEGER, STRING, jsInterceptor);
  rule(INTEGER, READABLE_ARRAY, jsInterceptor);
  rule(INTEGER, MUTABLE_ARRAY, jsInterceptor);
  rule(INTEGER, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(INTEGER, NULL, INTEGER_OR_NULL);
  rule(INTEGER, FIXED_ARRAY, jsInterceptor);

  rule(DOUBLE, DOUBLE, DOUBLE);
  rule(DOUBLE, INDEXABLE_PRIMITIVE, NON_NULL);
  rule(DOUBLE, STRING, jsInterceptor);
  rule(DOUBLE, READABLE_ARRAY, jsInterceptor);
  rule(DOUBLE, MUTABLE_ARRAY, jsInterceptor);
  rule(DOUBLE, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(DOUBLE, NULL, DOUBLE_OR_NULL);
  rule(DOUBLE, FIXED_ARRAY, jsInterceptor);

  rule(INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, STRING, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, READABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, MUTABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, EXTENDABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, nonPrimitive1, NON_NULL);
  rule(INDEXABLE_PRIMITIVE, nonPrimitive2, NON_NULL);
  rule(INDEXABLE_PRIMITIVE, potentialArray, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, potentialString, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, BOOLEAN_OR_NULL, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, NUMBER_OR_NULL, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, INTEGER_OR_NULL, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, DOUBLE_OR_NULL, UNKNOWN);
  rule(INDEXABLE_PRIMITIVE, STRING_OR_NULL, jsIndexableOrNull);
  rule(INDEXABLE_PRIMITIVE, NULL, jsIndexableOrNull);
  rule(INDEXABLE_PRIMITIVE, FIXED_ARRAY, INDEXABLE_PRIMITIVE);

  rule(STRING, STRING, STRING);
  rule(STRING, READABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(STRING, MUTABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(STRING, EXTENDABLE_ARRAY, INDEXABLE_PRIMITIVE);
  rule(STRING, nonPrimitive1, NON_NULL);
  rule(STRING, nonPrimitive2, NON_NULL);
  rule(STRING, potentialArray, UNKNOWN);
  rule(STRING, potentialString, potentialString);
  rule(STRING, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(STRING, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(STRING, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(STRING, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(STRING, STRING_OR_NULL, STRING_OR_NULL);
  rule(STRING, NULL, STRING_OR_NULL);
  rule(STRING, FIXED_ARRAY, INDEXABLE_PRIMITIVE);

  rule(READABLE_ARRAY, READABLE_ARRAY, READABLE_ARRAY);
  rule(READABLE_ARRAY, MUTABLE_ARRAY, READABLE_ARRAY);
  rule(READABLE_ARRAY, EXTENDABLE_ARRAY, READABLE_ARRAY);
  rule(READABLE_ARRAY, nonPrimitive1, NON_NULL);
  rule(READABLE_ARRAY, nonPrimitive2, NON_NULL);
  rule(READABLE_ARRAY, potentialArray, potentialArray);
  rule(READABLE_ARRAY, potentialString, UNKNOWN);
  rule(READABLE_ARRAY, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(READABLE_ARRAY, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(READABLE_ARRAY, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(READABLE_ARRAY, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(READABLE_ARRAY, STRING_OR_NULL, jsIndexableOrNull);
  rule(READABLE_ARRAY, NULL, jsArrayOrNull);
  rule(READABLE_ARRAY, FIXED_ARRAY, READABLE_ARRAY);

  rule(MUTABLE_ARRAY, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(MUTABLE_ARRAY, EXTENDABLE_ARRAY, MUTABLE_ARRAY);
  rule(MUTABLE_ARRAY, nonPrimitive1, NON_NULL);
  rule(MUTABLE_ARRAY, nonPrimitive2, NON_NULL);
  rule(MUTABLE_ARRAY, potentialArray, potentialArray);
  rule(MUTABLE_ARRAY, potentialString, UNKNOWN);
  rule(MUTABLE_ARRAY, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(MUTABLE_ARRAY, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(MUTABLE_ARRAY, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(MUTABLE_ARRAY, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(MUTABLE_ARRAY, STRING_OR_NULL, jsIndexableOrNull);
  rule(MUTABLE_ARRAY, NULL, jsMutableArrayOrNull);
  rule(MUTABLE_ARRAY, FIXED_ARRAY, MUTABLE_ARRAY);

  rule(EXTENDABLE_ARRAY, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  rule(EXTENDABLE_ARRAY, nonPrimitive1, NON_NULL);
  rule(EXTENDABLE_ARRAY, nonPrimitive2, NON_NULL);
  rule(EXTENDABLE_ARRAY, potentialArray, potentialArray);
  rule(EXTENDABLE_ARRAY, potentialString, UNKNOWN);
  rule(EXTENDABLE_ARRAY, BOOLEAN_OR_NULL, jsInterceptorOrNull);
  rule(EXTENDABLE_ARRAY, NUMBER_OR_NULL, jsInterceptorOrNull);
  rule(EXTENDABLE_ARRAY, INTEGER_OR_NULL, jsInterceptorOrNull);
  rule(EXTENDABLE_ARRAY, DOUBLE_OR_NULL, jsInterceptorOrNull);
  rule(EXTENDABLE_ARRAY, STRING_OR_NULL, jsIndexableOrNull);
  rule(EXTENDABLE_ARRAY, NULL, jsExtendableArrayOrNull);
  rule(EXTENDABLE_ARRAY, FIXED_ARRAY, MUTABLE_ARRAY);

  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, STRING_OR_NULL, UNKNOWN);
  rule(nonPrimitive1, FIXED_ARRAY, 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, STRING_OR_NULL, UNKNOWN);
  rule(nonPrimitive2, FIXED_ARRAY, 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, STRING_OR_NULL, UNKNOWN);
  rule(potentialArray, NULL, potentialArray);
  rule(potentialArray, FIXED_ARRAY, 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, STRING_OR_NULL, potentialString);
  rule(potentialString, NULL, potentialString);
  rule(potentialString, FIXED_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(BOOLEAN_OR_NULL, NULL, BOOLEAN_OR_NULL);
  rule(BOOLEAN_OR_NULL, FIXED_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(NUMBER_OR_NULL, NULL, NUMBER_OR_NULL);
  rule(NUMBER_OR_NULL, FIXED_ARRAY, 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, STRING_OR_NULL, jsInterceptorOrNull);
  rule(INTEGER_OR_NULL, NULL, INTEGER_OR_NULL);
  rule(INTEGER_OR_NULL, FIXED_ARRAY, jsInterceptorOrNull);

  rule(DOUBLE_OR_NULL, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, STRING_OR_NULL, jsInterceptorOrNull);
  rule(DOUBLE_OR_NULL, NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, FIXED_ARRAY, jsInterceptorOrNull);

  rule(STRING_OR_NULL, STRING_OR_NULL, STRING_OR_NULL);
  rule(STRING_OR_NULL, NULL, STRING_OR_NULL);
  rule(STRING_OR_NULL, FIXED_ARRAY, jsIndexableOrNull);

  rule(NULL, NULL, NULL);
  rule(NULL, FIXED_ARRAY, jsFixedArrayOrNull);

  rule(FIXED_ARRAY, FIXED_ARRAY, FIXED_ARRAY);

  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, INDEXABLE_PRIMITIVE, CONFLICTING);
  rule(CONFLICTING, STRING, CONFLICTING);
  rule(CONFLICTING, READABLE_ARRAY, CONFLICTING);
  rule(CONFLICTING, MUTABLE_ARRAY, CONFLICTING);
  rule(CONFLICTING, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(CONFLICTING, NULL, CONFLICTING);
  rule(CONFLICTING, FIXED_ARRAY, CONFLICTING);

  rule(UNKNOWN, UNKNOWN, UNKNOWN);
  rule(UNKNOWN, BOOLEAN, BOOLEAN);
  rule(UNKNOWN, NUMBER, NUMBER);
  rule(UNKNOWN, INTEGER, INTEGER);
  rule(UNKNOWN, DOUBLE, DOUBLE);
  rule(UNKNOWN, INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE);
  rule(UNKNOWN, STRING, STRING);
  rule(UNKNOWN, READABLE_ARRAY, READABLE_ARRAY);
  rule(UNKNOWN, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(UNKNOWN, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  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, STRING_OR_NULL, STRING_OR_NULL);
  rule(UNKNOWN, NULL, NULL);
  rule(UNKNOWN, FIXED_ARRAY, FIXED_ARRAY);

  rule(BOOLEAN, BOOLEAN, BOOLEAN);
  rule(BOOLEAN, NUMBER, CONFLICTING);
  rule(BOOLEAN, INTEGER, CONFLICTING);
  rule(BOOLEAN, DOUBLE, CONFLICTING);
  rule(BOOLEAN, INDEXABLE_PRIMITIVE, CONFLICTING);
  rule(BOOLEAN, STRING, CONFLICTING);
  rule(BOOLEAN, READABLE_ARRAY, CONFLICTING);
  rule(BOOLEAN, MUTABLE_ARRAY, CONFLICTING);
  rule(BOOLEAN, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(BOOLEAN, NULL, CONFLICTING);
  rule(BOOLEAN, FIXED_ARRAY, CONFLICTING);

  rule(NUMBER, NUMBER, NUMBER);
  rule(NUMBER, INTEGER, INTEGER);
  rule(NUMBER, DOUBLE, DOUBLE);
  rule(NUMBER, INDEXABLE_PRIMITIVE, CONFLICTING);
  rule(NUMBER, STRING, CONFLICTING);
  rule(NUMBER, READABLE_ARRAY, CONFLICTING);
  rule(NUMBER, MUTABLE_ARRAY, CONFLICTING);
  rule(NUMBER, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(NUMBER, NULL, CONFLICTING);
  rule(NUMBER, FIXED_ARRAY, CONFLICTING);

  rule(INTEGER, INTEGER, INTEGER);
  rule(INTEGER, DOUBLE, CONFLICTING);
  rule(INTEGER, INDEXABLE_PRIMITIVE, CONFLICTING);
  rule(INTEGER, STRING, CONFLICTING);
  rule(INTEGER, READABLE_ARRAY, CONFLICTING);
  rule(INTEGER, MUTABLE_ARRAY, CONFLICTING);
  rule(INTEGER, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(INTEGER, NULL, CONFLICTING);
  rule(INTEGER, FIXED_ARRAY, CONFLICTING);

  rule(DOUBLE, DOUBLE, DOUBLE);
  rule(DOUBLE, INDEXABLE_PRIMITIVE, CONFLICTING);
  rule(DOUBLE, STRING, CONFLICTING);
  rule(DOUBLE, READABLE_ARRAY, CONFLICTING);
  rule(DOUBLE, MUTABLE_ARRAY, CONFLICTING);
  rule(DOUBLE, EXTENDABLE_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(DOUBLE, NULL, CONFLICTING);
  rule(DOUBLE, FIXED_ARRAY, CONFLICTING);

  rule(INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE, INDEXABLE_PRIMITIVE);
  rule(INDEXABLE_PRIMITIVE, STRING, STRING);
  rule(INDEXABLE_PRIMITIVE, READABLE_ARRAY, READABLE_ARRAY);
  rule(INDEXABLE_PRIMITIVE, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(INDEXABLE_PRIMITIVE, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  rule(INDEXABLE_PRIMITIVE, nonPrimitive1, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, nonPrimitive2, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, potentialArray, READABLE_ARRAY);
  rule(INDEXABLE_PRIMITIVE, potentialString, STRING);
  rule(INDEXABLE_PRIMITIVE, BOOLEAN_OR_NULL, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, NUMBER_OR_NULL, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, INTEGER_OR_NULL, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, DOUBLE_OR_NULL, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, STRING_OR_NULL, STRING);
  rule(INDEXABLE_PRIMITIVE, NULL, CONFLICTING);
  rule(INDEXABLE_PRIMITIVE, FIXED_ARRAY, FIXED_ARRAY);

  rule(STRING, STRING, STRING);
  rule(STRING, READABLE_ARRAY, CONFLICTING);
  rule(STRING, MUTABLE_ARRAY, CONFLICTING);
  rule(STRING, EXTENDABLE_ARRAY, CONFLICTING);
  rule(STRING, nonPrimitive1, CONFLICTING);
  rule(STRING, nonPrimitive2, CONFLICTING);
  rule(STRING, potentialArray, CONFLICTING);
  rule(STRING, potentialString, STRING);
  rule(STRING, BOOLEAN_OR_NULL, CONFLICTING);
  rule(STRING, NUMBER_OR_NULL, CONFLICTING);
  rule(STRING, INTEGER_OR_NULL, CONFLICTING);
  rule(STRING, DOUBLE_OR_NULL, CONFLICTING);
  rule(STRING, STRING_OR_NULL, STRING);
  rule(STRING, NULL, CONFLICTING);
  rule(STRING, FIXED_ARRAY, CONFLICTING);

  rule(READABLE_ARRAY, READABLE_ARRAY, READABLE_ARRAY);
  rule(READABLE_ARRAY, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(READABLE_ARRAY, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  rule(READABLE_ARRAY, nonPrimitive1, CONFLICTING);
  rule(READABLE_ARRAY, nonPrimitive2, CONFLICTING);
  rule(READABLE_ARRAY, potentialArray, READABLE_ARRAY);
  rule(READABLE_ARRAY, potentialString, CONFLICTING);
  rule(READABLE_ARRAY, BOOLEAN_OR_NULL, CONFLICTING);
  rule(READABLE_ARRAY, NUMBER_OR_NULL, CONFLICTING);
  rule(READABLE_ARRAY, INTEGER_OR_NULL, CONFLICTING);
  rule(READABLE_ARRAY, DOUBLE_OR_NULL, CONFLICTING);
  rule(READABLE_ARRAY, STRING_OR_NULL, CONFLICTING);
  rule(READABLE_ARRAY, NULL, CONFLICTING);
  rule(READABLE_ARRAY, FIXED_ARRAY, FIXED_ARRAY);

  rule(MUTABLE_ARRAY, MUTABLE_ARRAY, MUTABLE_ARRAY);
  rule(MUTABLE_ARRAY, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  rule(MUTABLE_ARRAY, nonPrimitive1, CONFLICTING);
  rule(MUTABLE_ARRAY, nonPrimitive2, CONFLICTING);
  rule(MUTABLE_ARRAY, potentialArray, MUTABLE_ARRAY);
  rule(MUTABLE_ARRAY, potentialString, CONFLICTING);
  rule(MUTABLE_ARRAY, BOOLEAN_OR_NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, NUMBER_OR_NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, INTEGER_OR_NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, DOUBLE_OR_NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, STRING_OR_NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, NULL, CONFLICTING);
  rule(MUTABLE_ARRAY, FIXED_ARRAY, FIXED_ARRAY);

  rule(EXTENDABLE_ARRAY, EXTENDABLE_ARRAY, EXTENDABLE_ARRAY);
  rule(EXTENDABLE_ARRAY, nonPrimitive1, CONFLICTING);
  rule(EXTENDABLE_ARRAY, nonPrimitive2, CONFLICTING);
  rule(EXTENDABLE_ARRAY, potentialArray, EXTENDABLE_ARRAY);
  rule(EXTENDABLE_ARRAY, potentialString, CONFLICTING);
  rule(EXTENDABLE_ARRAY, BOOLEAN_OR_NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, NUMBER_OR_NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, INTEGER_OR_NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, DOUBLE_OR_NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, STRING_OR_NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, NULL, CONFLICTING);
  rule(EXTENDABLE_ARRAY, FIXED_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(nonPrimitive1, NULL, CONFLICTING);
  rule(nonPrimitive1, FIXED_ARRAY, 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, STRING_OR_NULL, CONFLICTING);
  rule(nonPrimitive2, NULL, CONFLICTING);
  rule(nonPrimitive2, FIXED_ARRAY, 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, STRING_OR_NULL, NULL);
  rule(potentialArray, NULL, NULL);
  rule(potentialArray, FIXED_ARRAY, FIXED_ARRAY);

  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, STRING_OR_NULL, STRING_OR_NULL);
  rule(potentialString, NULL, NULL);
  rule(potentialString, FIXED_ARRAY, 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, STRING_OR_NULL, NULL);
  rule(BOOLEAN_OR_NULL, NULL, NULL);
  rule(BOOLEAN_OR_NULL, FIXED_ARRAY, 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, STRING_OR_NULL, NULL);
  rule(NUMBER_OR_NULL, NULL, NULL);
  rule(NUMBER_OR_NULL, FIXED_ARRAY, CONFLICTING);

  rule(INTEGER_OR_NULL, INTEGER_OR_NULL, INTEGER_OR_NULL);
  rule(INTEGER_OR_NULL, DOUBLE_OR_NULL, NULL);
  rule(INTEGER_OR_NULL, STRING_OR_NULL, NULL);
  rule(INTEGER_OR_NULL, NULL, NULL);
  rule(INTEGER_OR_NULL, FIXED_ARRAY, CONFLICTING);

  rule(DOUBLE_OR_NULL, DOUBLE_OR_NULL, DOUBLE_OR_NULL);
  rule(DOUBLE_OR_NULL, STRING_OR_NULL, NULL);
  rule(DOUBLE_OR_NULL, NULL, NULL);
  rule(DOUBLE_OR_NULL, FIXED_ARRAY, CONFLICTING);

  rule(STRING_OR_NULL, STRING_OR_NULL, STRING_OR_NULL);
  rule(STRING_OR_NULL, NULL, NULL);
  rule(STRING_OR_NULL, FIXED_ARRAY, CONFLICTING);

  rule(NULL, NULL, NULL);
  rule(NULL, FIXED_ARRAY, CONFLICTING);

  rule(FIXED_ARRAY, FIXED_ARRAY, FIXED_ARRAY);

  ruleSet.validateCoverage();
}

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

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

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

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

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