dartfmt pkg/compiler

pkg/compiler/lib/src/js_emitter/type_test_registry.dart

 // Copyright (c) 2014, 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.
 
 part of dart2js.js_emitter;
 
 class TypeTestRegistry {
   /**
    * Raw ClassElement symbols occuring in is-checks and type assertions.  If the
    * program contains parameterized checks `x is Set<int>` and
@@ skipping 61 matching lines @@
       for (ClassElement cls in classes) {
         addClassWithSuperclasses(cls);
       }
     }
 
     // 1.  Add classes that are referenced by type arguments or substitutions in
     //     argument checks.
     // TODO(karlklose): merge this case with 2 when unifying argument and
     // object checks.
     RuntimeTypes rti = backend.rti;
-    rti.getRequiredArgumentClasses(backend)
-       .forEach(addClassWithSuperclasses);
+    rti.getRequiredArgumentClasses(backend).forEach(addClassWithSuperclasses);
 
     // 2.  Add classes that are referenced by substitutions in object checks and
     //     their superclasses.
     TypeChecks requiredChecks =
         rti.computeChecks(rtiNeededClasses, checkedClasses);
     Set<ClassElement> classesUsedInSubstitutions =
         rti.getClassesUsedInSubstitutions(backend, requiredChecks);
     addClassesWithSuperclasses(classesUsedInSubstitutions);
 
     // 3.  Add classes that contain checked generic function types. These are
     //     needed to store the signature encoding.
     for (FunctionType type in checkedFunctionTypes) {
       ClassElement contextClass = Types.getClassContext(type);
       if (contextClass != null) {
         rtiNeededClasses.add(contextClass);
       }
     }
 
     bool canTearOff(Element function) {
       if (!function.isFunction ||
           function.isConstructor ||
           function.isAccessor) {
         return false;
       } else if (function.isInstanceMember) {
         if (!function.enclosingClass.isClosure) {
-          return compiler.codegenWorld.hasInvokedGetter(
-              function, compiler.world);
+          return compiler.codegenWorld
+              .hasInvokedGetter(function, compiler.world);
         }
       }
       return false;
     }
 
     bool canBeReflectedAsFunction(Element element) {
       return element.kind == ElementKind.FUNCTION ||
           element.kind == ElementKind.GETTER ||
           element.kind == ElementKind.SETTER ||
           element.kind == ElementKind.GENERATIVE_CONSTRUCTOR;
@@ skipping 16 matching lines @@
         }
       }
     });
 
     return rtiNeededClasses;
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null && checkedFunctionTypes == null);
 
-    backend.rti.addImplicitChecks(compiler.codegenWorld,
-                                  classesUsingTypeVariableTests);
+    backend.rti.addImplicitChecks(
+        compiler.codegenWorld, classesUsingTypeVariableTests);
 
     checkedClasses = new Set<ClassElement>();
     checkedFunctionTypes = new Set<FunctionType>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) {
         checkedClasses.add(t.element);
       } else if (t is FunctionType) {
         checkedFunctionTypes.add(t);
       }
     });
   }
 }