dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/optimize_interceptors.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 dart2js.cps_ir.optimize_interceptors;
 
 import 'optimizers.dart';
 import 'cps_ir_nodes.dart';
 import 'loop_hierarchy.dart';
 import 'cps_fragment.dart';
@@ skipping 41 matching lines @@
     Continuation oldLoopHeader = currentLoopHeader;
     currentLoopHeader = loopHierarchy.getLoopHeader(cont);
     pushAction(() {
       currentLoopHeader = oldLoopHeader;
     });
     return cont.body;
   }
 
   bool hasNoFalsyValues(ClassElement class_) {
     return class_ != helpers.jsInterceptorClass &&
-       class_ != helpers.jsNullClass &&
-       class_ != helpers.jsBoolClass &&
-       class_ != helpers.jsStringClass &&
-       !class_.isSubclassOf(helpers.jsNumberClass);
+        class_ != helpers.jsNullClass &&
+        class_ != helpers.jsBoolClass &&
+        class_ != helpers.jsStringClass &&
+        !class_.isSubclassOf(helpers.jsNumberClass);
   }
 
   Continuation getCurrentOuterLoop({Continuation scope}) {
     Continuation inner = null, outer = currentLoopHeader;
     while (outer != scope) {
       inner = outer;
       outer = loopHierarchy.getEnclosingLoop(outer);
     }
     return inner;
   }
 
   /// Binds the given constant in a primitive, in scope of the [useSite].
   ///
   /// The constant will be hoisted out of loops, and shared with other requests
   /// for the same constant as long as it is in scope.
   Primitive makeConstantFor(ConstantValue constant,
-                            {Expression useSite,
-                             TypeMask type,
-                             SourceInformation sourceInformation,
-                             Entity hint}) {
+      {Expression useSite,
+      TypeMask type,
+      SourceInformation sourceInformation,
+      Entity hint}) {
     Constant prim =
         new Constant(constant, sourceInformation: sourceInformation);
     prim.hint = hint;
     prim.type = type;
     LetPrim letPrim = new LetPrim(prim);
     Continuation loop = getCurrentOuterLoop();
     if (loop != null) {
       LetCont loopBinding = loop.parent;
       letPrim.insertAbove(loopBinding);
     } else {
       letPrim.insertAbove(useSite);
     }
     return prim;
   }
 
   void computeInterceptedClasses(Interceptor interceptor) {
     Set<ClassElement> intercepted = interceptor.interceptedClasses;
     intercepted.clear();
     for (Reference ref = interceptor.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
       if (use is InvokeMethod) {
         TypeMask type = use.receiver.type;
         bool canOccurAsReceiver(ClassElement elem) {
           return classWorld.isInstantiated(elem) &&
-              !typeSystem.areDisjoint(type,
-                  typeSystem.getInterceptorSubtypes(elem));
+              !typeSystem.areDisjoint(
+                  type, typeSystem.getInterceptorSubtypes(elem));
         }
         Iterable<ClassElement> classes =
             backend.getInterceptedClassesOn(use.selector.name);
         intercepted.addAll(classes.where(canOccurAsReceiver));
       } else {
         intercepted.clear();
         intercepted.add(backend.helpers.jsInterceptorClass);
         break;
       }
     }
@@ skipping 81 matching lines @@
 
     if (classElement == null) return false;
     ConstantValue constant = new InterceptorConstantValue(classElement.rawType);
 
     if (!input.type.isNullable) {
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type,
           sourceInformation: interceptor.sourceInformation);
       constantPrim.useElementAsHint(interceptor.hint);
-      interceptor..replaceUsesWith(constantPrim)..destroy();
+      interceptor
+        ..replaceUsesWith(constantPrim)
+        ..destroy();
       let.remove();
     } else {
       Primitive constantPrim = makeConstantFor(constant,
           useSite: let,
           type: interceptor.type.nonNullable(),
           sourceInformation: interceptor.sourceInformation);
       CpsFragment cps = new CpsFragment(interceptor.sourceInformation);
       Parameter param = new Parameter(interceptor.hint);
       param.type = interceptor.type;
       Continuation cont = cps.letCont(<Parameter>[param]);
       if (hasNoFalsyValues(classElement)) {
         // If null is the only falsy value, compile as "x && CONST".
         cps.ifFalsy(input).invokeContinuation(cont, [input]);
       } else {
         // If there are other falsy values compile as "x == null ? x : CONST".
-        Primitive condition = cps.applyBuiltin(
-            BuiltinOperator.LooseEq,
-            [input, cps.makeNull()]);
+        Primitive condition =
+            cps.applyBuiltin(BuiltinOperator.LooseEq, [input, cps.makeNull()]);
         cps.ifTruthy(condition).invokeContinuation(cont, [input]);
       }
       cps.invokeContinuation(cont, [constantPrim]);
       cps.context = cont;
       cps.insertAbove(let);
-      interceptor..replaceUsesWith(param)..destroy();
+      interceptor
+        ..replaceUsesWith(param)
+        ..destroy();
       let.remove();
     }
     return true;
   }
 
   @override
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
     visit(node.primitive);
     return next;
@@ skipping 48 matching lines @@
 class ShareConstants extends TrampolineRecursiveVisitor {
   Map<ConstantValue, Constant> sharedConstantFor = <ConstantValue, Constant>{};
 
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
     if (node.primitive is Constant && shouldShareConstant(node.primitive)) {
       Constant prim = node.primitive;
       Constant existing = sharedConstantFor[prim.value];
       if (existing != null) {
         existing.useElementAsHint(prim.hint);
-        prim..replaceUsesWith(existing)..destroy();
+        prim
+          ..replaceUsesWith(existing)
+          ..destroy();
         node.remove();
         return next;
       }
       sharedConstantFor[prim.value] = prim;
       pushAction(() {
         assert(sharedConstantFor[prim.value] == prim);
         sharedConstantFor.remove(prim.value);
       });
     }
     return next;
   }
 
   bool shouldShareConstant(Constant constant) {
     return constant.value.isInterceptor;
   }
 }