dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/shrinking_reductions.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.
 
 library dart2js.cps_ir.shrinking_reductions;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /**
@@ skipping 21 matching lines @@
       _ReductionTask task = _worklist.removeLast();
       _processTask(task);
     }
   }
 
   /// Call instead of [_iterateWorklist] to check at every step that no
   /// redex was missed.
   void _debugWorklist(FunctionDefinition root) {
     while (_worklist.isNotEmpty) {
       _ReductionTask task = _worklist.removeLast();
-      String irBefore = root.debugString({
-        task.node: '${task.kind} applied here'
-      });
+      String irBefore =
+          root.debugString({task.node: '${task.kind} applied here'});
       _processTask(task);
       Set seenRedexes = _worklist.where(isValidTask).toSet();
       Set actualRedexes = (new _RedexVisitor([])..visit(root)).worklist.toSet();
       if (!seenRedexes.containsAll(actualRedexes)) {
         _ReductionTask missedTask =
             actualRedexes.firstWhere((x) => !seenRedexes.contains(x));
         print('\nBEFORE $task:\n');
         print(irBefore);
         print('\nAFTER $task:\n');
-        root.debugPrint({
-          missedTask.node: 'MISSED ${missedTask.kind}'
-        });
+        root.debugPrint({missedTask.node: 'MISSED ${missedTask.kind}'});
         throw 'Missed $missedTask after processing $task';
       }
     }
   }
 
   bool isValidTask(_ReductionTask task) {
     switch (task.kind) {
       case _ReductionKind.DEAD_VAL:
         return _isDeadVal(task.node);
       case _ReductionKind.DEAD_CONT:
         return _isDeadCont(task.node);
       case _ReductionKind.BETA_CONT_LIN:
         return _isBetaContLin(task.node);
       case _ReductionKind.ETA_CONT:
         return _isEtaCont(task.node);
       case _ReductionKind.DEAD_PARAMETER:
         return _isDeadParameter(task.node);
       case _ReductionKind.BRANCH:
         return _isBranchRedex(task.node);
     }
   }
 
   /// Removes the given node from the CPS graph, replacing it with its body
   /// and marking it as deleted. The node's parent must be a [[InteriorNode]].
   void _removeNode(InteriorNode node) {
-    Node body           = node.body;
+    Node body = node.body;
     InteriorNode parent = node.parent;
     assert(parent.body == node);
 
     body.parent = parent;
     parent.body = body;
     node.parent = null;
 
     // The removed node could be the last node between a continuation and
     // an InvokeContinuation in the body.
     if (parent is Continuation) {
@@ skipping 191 matching lines @@
     if (condition is Constant) {
       target = isTruthyConstant(condition.value, strict: branch.isStrictCheck)
           ? branch.trueContinuation
           : branch.falseContinuation;
     } else if (_isBranchTargetOfUselessIf(branch.trueContinuation)) {
       target = branch.trueContinuation;
     } else {
       return;
     }
 
-    InvokeContinuation invoke = new InvokeContinuation(
-        target, <Primitive>[]
+    InvokeContinuation invoke = new InvokeContinuation(target, <Primitive>[]
         // TODO(sra): Add sourceInformation.
         /*, sourceInformation: branch.sourceInformation*/);
     branch.parent.body = invoke;
     invoke.parent = branch.parent;
     branch.parent = null;
 
     new _RemovalVisitor(_worklist).visit(branch);
   }
 
   void _reduceDeadParameter(_ReductionTask task) {
@@ skipping 43 matching lines @@
   }
 
   void _checkEtaCont(Continuation continuation) {
     if (_isEtaCont(continuation)) {
       _worklist.add(new _ReductionTask(_ReductionKind.ETA_CONT, continuation));
     }
   }
 
   void _checkUselessBranchTarget(Continuation continuation) {
     if (_isBranchTargetOfUselessIf(continuation)) {
-      _worklist.add(new _ReductionTask(_ReductionKind.BRANCH,
-          continuation.firstRef.parent));
+      _worklist.add(new _ReductionTask(
+          _ReductionKind.BRANCH, continuation.firstRef.parent));
     }
   }
 
   void _checkConstantBranchCondition(Primitive primitive) {
     if (primitive is! Constant) return;
     for (Reference ref = primitive.firstRef; ref != null; ref = ref.next) {
       Node use = ref.parent;
       if (use is Branch) {
         _worklist.add(new _ReductionTask(_ReductionKind.BRANCH, use));
       }
     }
   }
 
   void _checkDeadPrimitive(Primitive primitive) {
     primitive = primitive.unrefined;
     if (primitive is Parameter) {
       if (_isDeadParameter(primitive)) {
-        _worklist.add(new _ReductionTask(_ReductionKind.DEAD_PARAMETER,
-                                         primitive));
+        _worklist
+            .add(new _ReductionTask(_ReductionKind.DEAD_PARAMETER, primitive));
       }
     } else if (primitive.parent is LetPrim) {
       LetPrim letPrim = primitive.parent;
       if (_isDeadVal(letPrim)) {
         _worklist.add(new _ReductionTask(_ReductionKind.DEAD_VAL, letPrim));
       }
     }
   }
 }
 
 bool _isRemoved(InteriorNode node) {
   return node.parent == null;
 }
 
 bool _isParameterRemoved(Parameter parameter) {
   // A parameter can be removed directly or because its continuation is removed.
   return parameter.parent == null || _isRemoved(parameter.parent);
 }
 
 /// Returns true iff the bound primitive is unused, and has no effects
 /// preventing it from being eliminated.
 bool _isDeadVal(LetPrim node) {
   return !_isRemoved(node) &&
-         node.primitive.hasNoRefinedUses &&
-         node.primitive.isSafeForElimination;
+      node.primitive.hasNoRefinedUses &&
+      node.primitive.isSafeForElimination;
 }
 
 /// Returns true iff the continuation is unused.
 bool _isDeadCont(Continuation cont) {
   return !_isRemoved(cont) &&
-         !cont.isReturnContinuation &&
-         !cont.hasAtLeastOneUse;
+      !cont.isReturnContinuation &&
+      !cont.hasAtLeastOneUse;
 }
 
 /// Returns true iff the continuation has a body (i.e., it is not the return
 /// continuation), it is used exactly once, and that use is as the continuation
 /// of a continuation invocation.
 bool _isBetaContLin(Continuation cont) {
   if (_isRemoved(cont)) return false;
 
   // There is a restriction on continuation eta-redexes that the body is not an
   // invocation of the return continuation, because that leads to worse code
@@ skipping 112 matching lines @@
 
 bool _isUselessIf(Branch branch) {
   Continuation trueCont = branch.trueContinuation;
   Expression trueBody = _unfoldDeadRefinements(trueCont.body);
   if (trueBody is! InvokeContinuation) return false;
   Continuation falseCont = branch.falseContinuation;
   Expression falseBody = _unfoldDeadRefinements(falseCont.body);
   if (falseBody is! InvokeContinuation) return false;
   InvokeContinuation trueInvoke = trueBody;
   InvokeContinuation falseInvoke = falseBody;
-  if (trueInvoke.continuation !=
-      falseInvoke.continuation) {
+  if (trueInvoke.continuation != falseInvoke.continuation) {
     return false;
   }
   // Matching zero arguments should be adequate, since isomorphic true and false
   // invocations should result in redundant phis which are removed elsewhere.
   //
   // Note that the argument lists are not necessarily the same length here,
   // because we could be looking for new redexes in the middle of performing a
   // dead parameter reduction, where some but not all of the invocations have
   // been rewritten.  In that case, we will find the redex (once) after both
   // of these invocations have been rewritten.
@@ skipping 44 matching lines @@
 
     // Continuation beta- and eta-redexes can overlap, namely when an eta-redex
     // is invoked exactly once.  We prioritize continuation beta-redexes over
     // eta-redexes because some reductions (e.g., dead parameter elimination)
     // can destroy a continuation eta-redex.  If we prioritized eta- over
     // beta-redexes, this would implicitly "create" the corresponding beta-redex
     // (in the sense that it would still apply) and the algorithm would not
     // detect it.
     if (_isDeadCont(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.DEAD_CONT, node));
-    } else if (_isBetaContLin(node)){
+    } else if (_isBetaContLin(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.BETA_CONT_LIN, node));
     } else if (_isEtaCont(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.ETA_CONT, node));
     }
   }
 
   void processParameter(Parameter node) {
     if (_isDeadParameter(node)) {
       worklist.add(new _ReductionTask(_ReductionKind.DEAD_PARAMETER, node));
     }
@@ skipping 27 matching lines @@
     reference.unlink();
 
     if (reference.definition is Primitive) {
       Primitive primitive = reference.definition.unrefined;
       Node parent = primitive.parent;
       // The parent might be the deleted sentinel, or it might be a
       // Continuation or FunctionDefinition if the primitive is an argument.
       if (parent is LetPrim && _isDeadVal(parent)) {
         worklist.add(new _ReductionTask(_ReductionKind.DEAD_VAL, parent));
       } else if (primitive is Parameter && _isDeadParameter(primitive)) {
-        worklist.add(new _ReductionTask(_ReductionKind.DEAD_PARAMETER,
-            primitive));
+        worklist
+            .add(new _ReductionTask(_ReductionKind.DEAD_PARAMETER, primitive));
       }
     } else if (reference.definition is Continuation) {
       Continuation cont = reference.definition;
       Node parent = cont.parent;
       // The parent might be the deleted sentinel, or it might be a
       // Body if the continuation is the return continuation.
       if (parent is LetCont) {
         if (cont.isRecursive && cont.hasAtMostOneUse) {
           // Convert recursive to nonrecursive continuations.  If the
           // continuation is still in use, it is either dead and will be
@@ skipping 26 matching lines @@
 /// operator== since instantiations are used as Set elements.
 class _ReductionTask {
   final _ReductionKind kind;
   final Node node;
 
   int get hashCode {
     return (node.hashCode << 3) | kind.index;
   }
 
   _ReductionTask(this.kind, this.node) {
-    assert(node is Continuation || node is LetPrim || node is Parameter ||
-           node is Branch);
+    assert(node is Continuation ||
+        node is LetPrim ||
+        node is Parameter ||
+        node is Branch);
   }
 
-  bool operator==(_ReductionTask that) {
+  bool operator ==(_ReductionTask that) {
     return (that.kind == this.kind && that.node == this.node);
   }
 
   String toString() => "$kind: $node";
 }