dart2js: run dartfmt on tests

tests/compiler/dart2js/type_mask_disjoint_test.dart

 // 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';
 
@@ skipping 22 matching lines @@
       new H(), new I(), new J(), new K(), new M(), new N()]);
 }
 """;
 
 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
 
-    // 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
+        check('M!=', 'K!=');
+        check('M!=', 'A!=');
 
-    // Exact
-    check('A!=', 'A!=', areDisjoint: false);
-    check('A!=', 'B!=');
-    check('A!=', 'E!=');
-    check('A =', 'E =', areDisjoint: false); // null is common
-    check('M!=', 'K!=');
-    check('M!=', 'A!=');
+        // 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);
+        check('M!=', 'K!<', areDisjoint: false);
+        check('M!=', 'A!<');
 
-    // 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);
-    check('M!=', 'K!<', areDisjoint: false);
-    check('M!=', 'A!<');
+        // 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);
+        check('M!=', 'K!*', areDisjoint: false);
+        check('M!=', 'A!*', 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);
-    check('M!=', 'K!*', areDisjoint: false);
-    check('M!=', 'A!*', areDisjoint: false);
+        // Subclass with subclass
+        check('A!<', 'A!<', areDisjoint: false);
+        check('A!<', 'B!<', areDisjoint: false);
+        check('A!<', 'E!<');
+        check('A!<', 'H!<');
+        check('D!<', 'I!<');
+        check('H!<', 'I!*', areDisjoint: false);
 
-    // Subclass with subclass
-    check('A!<', 'A!<', areDisjoint: false);
-    check('A!<', 'B!<', areDisjoint: false);
-    check('A!<', 'E!<');
-    check('A!<', 'H!<');
-    check('D!<', 'I!<');
-    check('H!<', 'I!*', areDisjoint: false);
+        // Subclass with subtype
+        check('A!<', 'A!*', areDisjoint: false);
+        check('A!<', 'B!*', areDisjoint: false);
+        check('A!<', 'E!*');
+        check('A!<', 'H!*');
+        check('D!<', 'I!*', areDisjoint: false);
 
-    // 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);
 
-    // 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);
 
-    // 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(['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!=']);
-  }));
+        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] == '*';
+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();
-    }
+      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));
+      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;
-  });
+      var mask = isExact
+          ? new TypeMask.nonNullExact(element, world)
+          : (isSubclass
+              ? new TypeMask.nonNullSubclass(element, world)
+              : new TypeMask.nonNullSubtype(element, world));
+      return isNullable ? mask.nullable() : mask;
+    });