dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/mutable_ssa.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.mutable_ssa;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 
 /// Determines which mutable variables should be rewritten to phi assignments
@@ skipping 92 matching lines @@
         mutableVariables.removeLast();
       }
     }
   }
 
   bool shouldRewrite(MutableVariable variable) {
     return !analysis.hasAssignmentInTry.contains(variable);
   }
 
   bool isJoinContinuation(Continuation cont) {
-    return !cont.hasExactlyOneUse ||
-           cont.firstRef.parent is InvokeContinuation;
+    return !cont.hasExactlyOneUse || cont.firstRef.parent is InvokeContinuation;
   }
 
   /// If some useful source information is attached to exactly one of the
   /// two definitions, the information is copied onto the other.
   void mergeHints(MutableVariable variable, Primitive value) {
     if (variable.hint == null) {
       variable.hint = value.hint;
     } else if (value.hint == null) {
       value.hint = variable.hint;
     }
   }
 
   /// Processes a basic block, replacing mutable variable uses with direct
   /// references to their values.
   ///
   /// [environment] is the current value of each mutable variable. The map
   /// will be mutated during the processing.
   ///
   /// Continuations to be processed are put on the stack for later processing.
-  void processBlock(Expression node,
-                    Map<MutableVariable, Primitive> environment) {
+  void processBlock(
+      Expression node, Map<MutableVariable, Primitive> environment) {
     Expression next = node.next;
     for (; node is! TailExpression; node = next, next = node.next) {
       if (node is LetMutable && shouldRewrite(node.variable)) {
         // Put the new mutable variable on the stack while processing the body,
         // and pop it off again when done with the body.
         mutableVariables.add(node.variable);
         stack.add(new VariableItem());
 
         // Put the initial value into the environment.
         Primitive value = node.value;
@@ skipping 68 matching lines @@
       for (int i = 0; i < phiCount; ++i) {
         Primitive value = environment[mutableVariables[i]];
         Reference<Primitive> arg = new Reference<Primitive>(value);
         node.argumentRefs.add(arg);
         arg.parent = node;
       }
     } else if (node is Branch) {
       // Enqueue both branches with the current environment.
       // Clone the environments once so the processing of one branch does not
       // mutate the environment needed to process the other branch.
-      stack.add(new ContinuationItem(
-          node.trueContinuation,
+      stack.add(new ContinuationItem(node.trueContinuation,
           new Map<MutableVariable, Primitive>.from(environment)));
-      stack.add(new ContinuationItem(
-          node.falseContinuation,
-          environment));
+      stack.add(new ContinuationItem(node.falseContinuation, environment));
     } else {
       assert(node is Throw || node is Unreachable);
     }
   }
 }
 
 abstract class StackItem {}
 
 /// Represents a mutable variable that is in scope.
 ///
 /// The topmost mutable variable falls out of scope when this item is
 /// taken off the stack.
 class VariableItem extends StackItem {}
 
 /// Represents a yet unprocessed continuation together with the
 /// environment in which to process it.
 class ContinuationItem extends StackItem {
   final Continuation continuation;
   final Map<MutableVariable, Primitive> environment;
 
   ContinuationItem(this.continuation, this.environment);
 }