dart2js: run dartfmt on tests

tests/compiler/dart2js/type_combination_test.dart

 // 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:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/js_backend/backend_helpers.dart';
 import 'package:compiler/src/js_backend/js_backend.dart';
 import 'package:compiler/src/types/types.dart';
 import 'package:compiler/src/world.dart';
@@ skipping 29 matching lines @@
 TypeMask jsString;
 TypeMask jsStringOrNull;
 TypeMask jsArrayOrNull;
 TypeMask jsMutableArrayOrNull;
 TypeMask jsFixedArrayOrNull;
 TypeMask jsExtendableArrayOrNull;
 TypeMask jsUnmodifiableArrayOrNull;
 TypeMask jsIndexableOrNull;
 TypeMask jsInterceptorOrNull;
 
-
 class Pair {
   final first;
   final second;
   Pair(this.first, this.second);
   int get hashCode => first.hashCode * 47 + second.hashCode;
-  bool operator==(Pair other) =>
+  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,
-        "Unexpected result of $name($type1,$type2)");
+    Expect.equals(result, r1, "Unexpected result of $name($type1,$type2)");
     Expect.equals(r1, r2, 'Symmetry violation of $name($type1,$type2)');
   }
 
   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) => simplify(t1.union(t2, compiler.world), compiler));
+  RuleSet ruleSet = new RuleSet(
+      'union', (t1, t2) => simplify(t1.union(t2, compiler.world), compiler));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
   check(type1, type2, predicate) => ruleSet.check(type1, type2, predicate);
 
   rule(emptyType, emptyType, emptyType);
   rule(emptyType, dynamicType, dynamicType);
   rule(emptyType, jsBoolean, jsBoolean);
   rule(emptyType, jsNumber, jsNumber);
   rule(emptyType, jsInteger, jsInteger);
   rule(emptyType, jsDouble, jsDouble);
   rule(emptyType, jsIndexable, jsIndexable);
@@ skipping 291 matching lines @@
   check(nonPrimitive2, nullType, (type) => type == nonPrimitive2.nullable());
   check(nullType, nonPrimitive1, (type) => type == nonPrimitive1.nullable());
   check(nullType, nonPrimitive2, (type) => type == nonPrimitive2.nullable());
 
   ruleSet.validateCoverage();
 }
 
 void testIntersection(MockCompiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   BackendHelpers helpers = backend.helpers;
-  RuleSet ruleSet = new RuleSet('intersection',
-      (t1, t2) => t1.intersection(t2, compiler.world));
+  RuleSet ruleSet = new RuleSet(
+      'intersection', (t1, t2) => t1.intersection(t2, compiler.world));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
 
   rule(emptyType, emptyType, emptyType);
   rule(emptyType, dynamicType, emptyType);
   rule(emptyType, jsBoolean, emptyType);
   rule(emptyType, jsNumber, emptyType);
   rule(emptyType, jsInteger, emptyType);
   rule(emptyType, jsDouble, emptyType);
   rule(emptyType, jsIndexable, emptyType);
   rule(emptyType, jsString, emptyType);
@@ skipping 119 matching lines @@
   rule(jsDouble, jsFixedArray, emptyType);
 
   rule(jsIndexable, jsIndexable, jsIndexable);
   rule(jsIndexable, jsString, jsString);
   rule(jsIndexable, jsReadableArray, jsReadableArray);
   rule(jsIndexable, jsMutableArray, jsMutableArray);
   rule(jsIndexable, jsExtendableArray, jsExtendableArray);
   rule(jsIndexable, jsUnmodifiableArray, jsUnmodifiableArray);
   rule(jsIndexable, nonPrimitive1, emptyType);
   rule(jsIndexable, nonPrimitive2, emptyType);
-  rule(jsIndexable, potentialArray, new TypeMask.nonNullSubtype(
-      helpers.jsArrayClass, compiler.world));
-  rule(jsIndexable, potentialString, new TypeMask.nonNullSubtype(
-      helpers.jsStringClass, compiler.world));
+  rule(jsIndexable, potentialArray,
+      new TypeMask.nonNullSubtype(helpers.jsArrayClass, compiler.world));
+  rule(jsIndexable, potentialString,
+      new TypeMask.nonNullSubtype(helpers.jsStringClass, compiler.world));
   rule(jsIndexable, jsBooleanOrNull, emptyType);
   rule(jsIndexable, jsNumberOrNull, emptyType);
   rule(jsIndexable, jsIntegerOrNull, emptyType);
   rule(jsIndexable, jsDoubleOrNull, emptyType);
   rule(jsIndexable, jsStringOrNull, jsString);
   rule(jsIndexable, nullType, emptyType);
   rule(jsIndexable, jsFixedArray, jsFixedArray);
 
   rule(jsString, jsString, jsString);
   rule(jsString, jsReadableArray, emptyType);
@@ skipping 144 matching lines @@
 
   rule(nullType, nullType, nullType);
   rule(nullType, jsFixedArray, emptyType);
 
   rule(jsFixedArray, jsFixedArray, jsFixedArray);
 
   ruleSet.validateCoverage();
 }
 
 void testRegressions(MockCompiler compiler) {
-  TypeMask nonNullPotentialString = new TypeMask.nonNullSubtype(
-      patternClass, compiler.world);
-  Expect.equals(
-      potentialString, jsStringOrNull.union(
-          nonNullPotentialString, compiler.world));
+  TypeMask nonNullPotentialString =
+      new TypeMask.nonNullSubtype(patternClass, compiler.world);
+  Expect.equals(potentialString,
+      jsStringOrNull.union(nonNullPotentialString, compiler.world));
 }
 
 void main() {
   asyncTest(() async {
     MockCompiler compiler = new MockCompiler.internal();
     await compiler.init("""
     class PatternImpl implements Pattern {}
     """);
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
     World world = compiler.world;
     helpers.interceptorsLibrary.forEachLocalMember((element) {
       if (element.isClass) {
         element.ensureResolved(compiler.resolution);
-        backend.registerInstantiatedType(
-            element.rawType,
-            compiler.enqueuer.resolution,
-            compiler.globalDependencies);
+        backend.registerInstantiatedType(element.rawType,
+            compiler.enqueuer.resolution, compiler.globalDependencies);
       }
     });
     ClassElement patternImplClass = compiler.mainApp.find('PatternImpl');
     patternImplClass.ensureResolved(compiler.resolution);
 
-    backend.registerInstantiatedType(
-        compiler.coreTypes.mapType(),
-        compiler.enqueuer.resolution,
-        compiler.globalDependencies);
-    backend.registerInstantiatedType(
-        compiler.coreTypes.functionType,
-        compiler.enqueuer.resolution,
-        compiler.globalDependencies);
-    backend.registerInstantiatedType(
-        patternImplClass.rawType,
-        compiler.enqueuer.resolution,
-        compiler.globalDependencies);
+    backend.registerInstantiatedType(compiler.coreTypes.mapType(),
+        compiler.enqueuer.resolution, compiler.globalDependencies);
+    backend.registerInstantiatedType(compiler.coreTypes.functionType,
+        compiler.enqueuer.resolution, compiler.globalDependencies);
+    backend.registerInstantiatedType(patternImplClass.rawType,
+        compiler.enqueuer.resolution, compiler.globalDependencies);
     compiler.world.populate();
 
     // Grab hold of a supertype for String so we can produce potential
     // string types.
     patternClass = compiler.commonElements.coreLibrary.find('Pattern');
 
-    nonPrimitive1 = new TypeMask.nonNullSubtype(
-        compiler.coreClasses.mapClass, world);
-    nonPrimitive2 = new TypeMask.nonNullSubtype(
-        compiler.coreClasses.functionClass, world);
-    potentialArray = new TypeMask.subtype(
-        compiler.coreClasses.listClass, world);
+    nonPrimitive1 =
+        new TypeMask.nonNullSubtype(compiler.coreClasses.mapClass, world);
+    nonPrimitive2 =
+        new TypeMask.nonNullSubtype(compiler.coreClasses.functionClass, world);
+    potentialArray =
+        new TypeMask.subtype(compiler.coreClasses.listClass, world);
     potentialString = new TypeMask.subtype(patternClass, world);
-    jsInterceptor = new TypeMask.nonNullSubclass(helpers.jsInterceptorClass,
-        world);
+    jsInterceptor =
+        new TypeMask.nonNullSubclass(helpers.jsInterceptorClass, world);
     jsArrayOrNull = new TypeMask.subclass(helpers.jsArrayClass, world);
-    jsReadableArray = new TypeMask.nonNullSubclass(helpers.jsArrayClass,
-        world);
-    jsMutableArrayOrNull = new TypeMask.subclass(helpers.jsMutableArrayClass,
-        world);
-    jsMutableArray = new TypeMask.nonNullSubclass(helpers.jsMutableArrayClass,
-        world);
+    jsReadableArray = new TypeMask.nonNullSubclass(helpers.jsArrayClass, world);
+    jsMutableArrayOrNull =
+        new TypeMask.subclass(helpers.jsMutableArrayClass, world);
+    jsMutableArray =
+        new TypeMask.nonNullSubclass(helpers.jsMutableArrayClass, world);
     jsFixedArrayOrNull = new TypeMask.exact(helpers.jsFixedArrayClass, world);
     jsFixedArray = new TypeMask.nonNullExact(helpers.jsFixedArrayClass, world);
-    jsExtendableArrayOrNull = new TypeMask.exact(helpers.jsExtendableArrayClass,
-        world);
-    jsExtendableArray = new TypeMask.nonNullExact(
-        helpers.jsExtendableArrayClass, world);
+    jsExtendableArrayOrNull =
+        new TypeMask.exact(helpers.jsExtendableArrayClass, world);
+    jsExtendableArray =
+        new TypeMask.nonNullExact(helpers.jsExtendableArrayClass, world);
     jsUnmodifiableArrayOrNull =
         new TypeMask.exact(helpers.jsUnmodifiableArrayClass, world);
     jsUnmodifiableArray =
         new TypeMask.nonNullExact(helpers.jsUnmodifiableArrayClass, world);
     jsIndexableOrNull = new TypeMask.subtype(helpers.jsIndexableClass, world);
     jsIndexable = new TypeMask.nonNullSubtype(helpers.jsIndexableClass, world);
-    jsInterceptorOrNull = new TypeMask.subclass(helpers.jsInterceptorClass,
-        world);
+    jsInterceptorOrNull =
+        new TypeMask.subclass(helpers.jsInterceptorClass, world);
     jsStringOrNull = new TypeMask.exact(helpers.jsStringClass, world);
     jsString = new TypeMask.nonNullExact(helpers.jsStringClass, world);
     jsBoolean = new TypeMask.nonNullExact(helpers.jsBoolClass, world);
     jsNumber = new TypeMask.nonNullSubclass(helpers.jsNumberClass, world);
     jsInteger = new TypeMask.nonNullExact(helpers.jsIntClass, world);
     jsDouble = new TypeMask.nonNullExact(helpers.jsDoubleClass, world);
     jsBooleanOrNull = new TypeMask.exact(helpers.jsBoolClass, world);
     jsNumberOrNull = new TypeMask.subclass(helpers.jsNumberClass, world);
     jsIntegerOrNull = new TypeMask.exact(helpers.jsIntClass, world);
     jsDoubleOrNull = new TypeMask.exact(helpers.jsDoubleClass, world);
     nullType = const TypeMask.empty();
-    objectType = new TypeMask.nonNullSubclass(
-        compiler.coreClasses.objectClass, world);
+    objectType =
+        new TypeMask.nonNullSubclass(compiler.coreClasses.objectClass, world);
     emptyType = const TypeMask.nonNullEmpty();
-    dynamicType = new TypeMask.subclass(
-        compiler.coreClasses.objectClass, world);
+    dynamicType =
+        new TypeMask.subclass(compiler.coreClasses.objectClass, world);
 
-    Expect.notEquals(emptyType, nonPrimitive1,
-        "nonPrimitive1 expected to be non-empty.");
+    Expect.notEquals(
+        emptyType, nonPrimitive1, "nonPrimitive1 expected to be non-empty.");
     Expect.notEquals(jsStringOrNull, potentialString,
         "potentialString expected not to be exact JSString");
     Expect.notEquals(jsArrayOrNull, potentialArray,
         "potentialArray expected not to be JSArray subclass");
 
     testUnion(compiler);
     testIntersection(compiler);
     testRegressions(compiler);
   });
 }