Implement TypeMask.isDisjoint instead of using intersection.

tests/compiler/dart2js/type_mask_disjoint_test.dart

Index: tests/compiler/dart2js/type_mask_disjoint_test.dart
diff --git a/tests/compiler/dart2js/type_mask_disjoint_test.dart b/tests/compiler/dart2js/type_mask_disjoint_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f8419ec1e7e4148cb99c212e3e1e3aa9040e35d4
--- /dev/null
+++ b/tests/compiler/dart2js/type_mask_disjoint_test.dart
@@ -0,0 +1,175 @@
+// Copyright (c) 2013, 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:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+import 'package:compiler/src/types/types.dart';
+
+import 'compiler_helper.dart';
+
+const String CODE = """
+class A {}
+class B extends A {}
+class C extends A {}
+
+class D implements A {}
+
+class E {}
+class F extends E {}
+class G implements E {}
+
+class H {}
+class I implements H {}
+class J extends D implements I {}
+

[sra1, 2016/01/20 21:53:48]

Test mixins too (another kind of 'implements')

[Siggi Cherem (dart-lang), 2016/01/20 22:14:57]

Good idea. Done.

+main() {
+  print([new A(), new B(), new C(), new D(), new E(), new F(), new G(),
+      new H(), new I(), new J()]);
+}
+""";
+
+Uri uri = new Uri(scheme: 'source');
+var compiler = compilerFor(CODE, uri);
+var world = compiler.world;
+
+main() {
+  asyncTest(() => compiler.run(uri).then((_) {
+
+    // Empty
+    check(' ! ', ' ! ');  // both non-null
+    check(' ! ', '   ');  // one non-null
+    check('   ', ' ! ');  // one non-null
+    check('   ', '   ', areDisjoint: false); // null is common
+
+    // Exact
+    check('A!=', 'A!=', areDisjoint: false);
+    check('A!=', 'B!=');
+    check('A!=', 'E!=');
+    check('A =', 'E =', areDisjoint: false); // null is common
+
+    // Exact with subclass
+    check('A!=', 'A!<', areDisjoint: false);
+    check('B!=', 'A!<', areDisjoint: false);
+    check('A!=', 'B!<');
+    check('A!=', 'E!<');
+    check('A =', 'E!<');
+    check('A =', 'E <', areDisjoint: false);
+
+    // Exact with subtype
+    check('A!=', 'A!*', areDisjoint: false);
+    check('B!=', 'A!*', areDisjoint: false);
+    check('A!=', 'B!*');
+    check('A!=', 'E!*');
+    check('A!=', 'I!*');
+    check('J!=', 'H!*', areDisjoint: false);
+
+    // Subclass with subclass
+    check('A!<', 'A!<', areDisjoint: false);
+    check('A!<', 'B!<', areDisjoint: false);
+    check('A!<', 'E!<');
+    check('A!<', 'H!<');
+    check('D!<', 'I!<');
+
+    // Subclass with subtype
+    check('A!<', 'A!*', areDisjoint: false);
+    check('A!<', 'B!*', areDisjoint: false);
+    check('A!<', 'E!*');
+    check('A!<', 'H!*');
+    check('D!<', 'I!*', areDisjoint: false);
+
+    // Subtype with subtype
+    check('A!*', 'A!*', areDisjoint: false);
+    check('A!*', 'B!*', areDisjoint: false);
+    check('A!*', 'E!*');
+    check('A!*', 'H!*', areDisjoint: false);
+    check('D!*', 'I!*', areDisjoint: false);
+
+    // Unions!
+    checkUnions(['B!=', 'C!='], ['A!=']);
+    checkUnions(['B!=', 'C!='], ['A =']);
+    checkUnions(['B!=', 'C ='], ['A ='], areDisjoint: false);
+
+    checkUnions(['B!=', 'C!='], ['A!<'], areDisjoint: false);
+    checkUnions(['B!=', 'C!='], ['B!='], areDisjoint: false);
+    checkUnions(['A!<', 'E!<'], ['C!='], areDisjoint: false);
+    checkUnions(['A!<', 'E!<'], ['F!='], areDisjoint: false);
+
+    checkUnions(['A!=', 'E!='], ['C!=', 'F!=']);
+    checkUnions(['A!=', 'E!='], ['A!=', 'F!='], areDisjoint: false);
+    checkUnions(['B!=', 'E!='], ['A!<', 'F!='], areDisjoint: false);
+    checkUnions(['A!<', 'E!<'], ['C!=', 'F!='], areDisjoint: false);
+    checkUnions(['A!=', 'E!='], ['C!=', 'F!=']);
+  }));
+}
+
+/// Checks the expectation of `isDisjoint` for two mask. Also checks that the
+/// result is consistent with an equivalent (but slower) implementation based on
+/// intersection.
+checkMask(TypeMask m1, TypeMask m2, {areDisjoint: false}) {
+  print('masks: $m1 $m2');
+  Expect.equals(areDisjoint, m1.isDisjoint(m2, world));
+  Expect.equals(areDisjoint, m2.isDisjoint(m1, world));
+  var i1 = m1.intersection(m2, world);
+  Expect.equals(areDisjoint, i1.isEmpty && !i1.isNullable);
+  var i2 = m2.intersection(m1, world);
+  Expect.equals(areDisjoint, i2.isEmpty && !i2.isNullable);
+}
+
+/// Checks the expectation of `isDisjoint` for two mask descriptors (see
+/// [maskOf] for details).
+check(String typeMaskDescriptor1, String typeMaskDescriptor2,
+    {areDisjoint: true}) {
+  print('[$typeMaskDescriptor1] & [$typeMaskDescriptor2]');
+  checkMask(maskOf(typeMaskDescriptor1), maskOf(typeMaskDescriptor2),
+      areDisjoint: areDisjoint);
+}
+
+
+checkUnions(List descriptors1, List descriptors2, {areDisjoint: true}) {
+  print('[$descriptors1] & [$descriptors2]');
+  var m1 = new TypeMask.unionOf(descriptors1.map(maskOf).toList(), world);
+  var m2 = new TypeMask.unionOf(descriptors2.map(maskOf).toList(), world);
+  checkMask(m1, m2, areDisjoint: areDisjoint);
+}
+
+Map _maskCache = {};
+Map _elementCache = {};
+
+/// Parses a descriptor of a flat mask. A descriptor is of the form "AXY" where:
+///   A: either a type T or " " (base class or empty)
+///   X: can be either ! or " " (nullable/nonnullable)
+///   Y: can be either " " (no flag), = (exact), < (subclass), * (subtype)
+///
+/// Examples:
+///   "-! " - empty, non-null
+///   "-  " - null
+///   "Type!=" - non-null exact Type
+///   "Type =" - nullable exact Type
+///   "Type!<" - non-null subclass of Type
+///   "Type!*" - non-null subtype of Type
+TypeMask maskOf(String descriptor) =>
+  _maskCache.putIfAbsent(descriptor, () {
+    Expect.isTrue(descriptor.length >= 3);
+    var type = descriptor.substring(0, descriptor.length - 2);
+    bool isNullable = descriptor[descriptor.length - 2] != '!';
+    bool isExact = descriptor[descriptor.length - 1] == '=';
+    bool isSubclass = descriptor[descriptor.length - 1] == '<';
+    bool isSubtype = descriptor[descriptor.length - 1] == '*';
+
+    if (type == " ") {
+      Expect.isFalse(isExact || isSubclass || isSubtype);
+      return isNullable ? new TypeMask.empty() : new TypeMask.nonNullEmpty();
+    }
+
+    Expect.isTrue(isExact || isSubclass || isSubtype);
+    var element = _elementCache.putIfAbsent(type,
+        () => type == " " ? null : findElement(compiler, type));
+
+    var mask = isExact
+        ? new TypeMask.nonNullExact(element, world)
+        : (isSubclass
+            ? new TypeMask.nonNullSubclass(element, world)
+            : new TypeMask.nonNullSubtype(element, world));
+    return isNullable ? mask.nullable() : mask;
+  });