Reformat untouched files.

tests/compiler/dart2js/world_test.dart

 // Copyright (c) 2015, 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.
 
 library world_test;
 
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'type_test_helper.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/elements/elements.dart'
     show ClassElement, LibraryElement;
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/universe/class_set.dart';
 import 'package:compiler/src/world.dart' show ClassQuery, ClosedWorld;
 
 void main() {
   asyncTest(() async {
     await testClassSets();
     await testProperties();
     await testNativeClasses();
     await testCommonSubclasses();
   });
 }
 
 testClassSets() async {
-  var env = await TypeEnvironment.create(
-      r"""
+  var env = await TypeEnvironment.create(r"""
       class A implements X {}
       class B {}
       class C_Super extends A {}
       class C extends C_Super {}
       class D implements A {}
       class E extends B implements A {}
       class F extends Object with A implements B {}
       class G extends Object with A, B {}
       class X {}
-      """,
-      mainSource: r"""
+      """, mainSource: r"""
       import 'dart:html' as html;
       main() {
         new A();
         new B();
         new C();
         new D();
         new E();
         new F();
         new G();
         html.window;
         new html.Worker('');
       }
-      """,
-      useMockCompiler: false);
+      """, useMockCompiler: false);
   ClosedWorld closedWorld = env.closedWorld;
 
   ClassElement Object_ = env.getElement("Object");
   ClassElement A = env.getElement("A");
   ClassElement B = env.getElement("B");
   ClassElement C = env.getElement("C");
   ClassElement D = env.getElement("D");
   ClassElement E = env.getElement("E");
   ClassElement F = env.getElement("F");
   ClassElement G = env.getElement("G");
@@ skipping 111 matching lines @@
   testMixinUses(B, [G.superclass]);
   testMixinUses(C, []);
   testMixinUses(D, []);
   testMixinUses(E, []);
   testMixinUses(F, []);
   testMixinUses(G, []);
   testMixinUses(X, []);
 }
 
 testProperties() async {
-  var env = await TypeEnvironment.create(
-      r"""
+  var env = await TypeEnvironment.create(r"""
       class A {}
       class A1 extends A {}
       class A2 implements A {}
       class A3 extends Object with A {}
 
       class B {}
       class B1 extends B {}
       class B2 implements B {}
       class B3 extends Object with B {}
 
@@ skipping 21 matching lines @@
       class G1 extends G {}
       class G2 extends G1 {}
       class G3 extends G2 implements G {}
       class G4 extends G2 with G {}
 
       class H {}
       class H1 extends H {}
       class H2 extends H1 {}
       class H3 extends H2 implements H {}
       class H4 extends H2 with H {}
-      """,
-      mainSource: r"""
+      """, mainSource: r"""
       main() {
         new B();
         new C1();
         new D2();
         new E3();
         new F1();
         new F2();
         new G2();
         new G3();
         new H4();
       }
-      """,
-      useMockCompiler: false);
+      """, useMockCompiler: false);
   ClosedWorld closedWorld = env.closedWorld;
 
   check(String name, {bool hasStrictSubtype, bool hasOnlySubclasses}) {
     ClassElement cls = env.getElement(name);
     Expect.equals(hasStrictSubtype, closedWorld.hasAnyStrictSubtype(cls),
         "Unexpected hasAnyStrictSubtype property on $cls.");
     Expect.equals(hasOnlySubclasses, closedWorld.hasOnlySubclasses(cls),
         "Unexpected hasOnlySubclasses property on $cls.");
   }
 
@@ skipping 346 matching lines @@
   check(B, ClassQuery.EXACT, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.EXACT, C, ClassQuery.SUBCLASS, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.EXACT, C, ClassQuery.SUBTYPE, []);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.EXACT, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBCLASS, []);
   check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBTYPE, []);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBCLASS, [G]);
   check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBTYPE, [F, G]);
 }