dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/gvn.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.gvn;
 
 import 'cps_ir_nodes.dart';
 import '../elements/elements.dart';
 import 'optimizers.dart' show Pass;
 import 'loop_hierarchy.dart';
@@ skipping 77 matching lines @@
   // ------------------ GLOBAL VALUE NUMBERING ---------------------
 
   /// True if [prim] can be eliminated if its value is already in scope.
   bool canReplaceWithExistingValue(Primitive prim) {
     // Primitives that have no side effects other than potentially throwing are
     // known not the throw if the value is already in scope. Handling those
     // specially is equivalent to updating refinements during GVN.
     // GetLazyStatic cannot have side effects because the field has already
     // been initialized.
     return prim.isSafeForElimination ||
-           prim is GetField ||
-           prim is GetLength ||
-           prim is GetIndex ||
-           prim is GetLazyStatic;
+        prim is GetField ||
+        prim is GetLength ||
+        prim is GetIndex ||
+        prim is GetLazyStatic;
   }
 
   @override
   Expression traverseLetPrim(LetPrim node) {
     Expression next = node.body;
     Primitive prim = node.primitive;
 
     loopHeaderFor[prim] = currentLoopHeader;
 
     if (prim is Refinement) {
@@ skipping 31 matching lines @@
 
     // Try to reuse a previously computed value with the same GVN.
     Primitive existing = environment[gvn];
     if (existing != null &&
         canReplaceWithExistingValue(prim) &&
         !isFastConstant(prim)) {
       if (prim is Interceptor) {
         Interceptor interceptor = existing;
         interceptor.interceptedClasses.addAll(prim.interceptedClasses);
       }
-      prim..replaceUsesWith(existing)..destroy();
+      prim
+        ..replaceUsesWith(existing)
+        ..destroy();
       node.remove();
       return next;
     }
 
     if (tryToHoistOutOfLoop(prim, gvn)) {
       return next;
     }
 
     // The primitive could not be hoisted.  Put the primitive in the
     // environment while processing the body of the LetPrim.
@@ skipping 76 matching lines @@
     });
 
     // Bail out if it can not be hoisted further out than it is now.
     if (hoistDepth == loopHierarchy.getDepth(currentLoopHeader)) return false;
 
     // Walk up the loop hierarchy and check at every step that any heap
     // dependencies can safely be hoisted out of the loop.
     Continuation enclosingLoop = currentLoopHeader;
     Continuation hoistTarget = null;
     while (loopHierarchy.getDepth(enclosingLoop) > hoistDepth &&
-           canHoistHeapDependencyOutOfLoop(prim, enclosingLoop)) {
+        canHoistHeapDependencyOutOfLoop(prim, enclosingLoop)) {
       hoistTarget = enclosingLoop;
       enclosingLoop = loopHierarchy.getEnclosingLoop(enclosingLoop);
     }
 
     // Bail out if heap dependencies prohibit any hoisting at all.
     if (hoistTarget == null) return false;
 
     if (isFastConstant(prim)) {
       // The overhead from introducting a temporary might be greater than
       // the overhead of evaluating this primitive at every iteration.
@@ skipping 26 matching lines @@
           if (loopHierarchy.getDepth(loop) <= target) break;
           Refinement refinement = input;
           input = refinement.value.definition;
         }
         ref.changeTo(input);
       });
     }
 
     // Put the primitive in the environment while processing the loop.
     environment[gvn] = prim;
-    loopHoistedBindings
-        .putIfAbsent(hoistTarget, () => <int>[])
-        .add(gvn);
+    loopHoistedBindings.putIfAbsent(hoistTarget, () => <int>[]).add(gvn);
     return true;
   }
 
   /// If the given primitive is a trivial primitive that should be hoisted
   /// on-demand, hoist it and its dependent values above [loopBinding].
-  void hoistTrivialPrimitive(Primitive prim,
-                             LetCont loopBinding,
-                             Continuation enclosingLoop) {
+  void hoistTrivialPrimitive(
+      Primitive prim, LetCont loopBinding, Continuation enclosingLoop) {
     assert(isFastConstant(prim));
 
     // The primitive might already be bound in an outer scope.  Do not relocate
     // the primitive unless we are lifting it. For example;
     //    t1 = a + b
     //    t2 = t1 + c
     //    t3 = t1 * t2
     // If it was decided that `t3` should be hoisted, `t1` will be seen twice by
     // this method: by the direct reference and by reference through `t2`.
     // The second time it is seen, it will already have been moved.
@@ skipping 114 matching lines @@
     return _table.putIfAbsent(new GvnEntry(vector), _makeNewGvn);
   }
 }
 
 /// Wrapper around a [List] that compares for equality based on contents
 /// instead of object identity.
 class GvnEntry {
   final List vector;
   final int hashCode;
 
-  GvnEntry(List vector) : vector = vector, hashCode = computeHashCode(vector);
+  GvnEntry(List vector)
+      : vector = vector,
+        hashCode = computeHashCode(vector);
 
-  bool operator==(other) {
+  bool operator ==(other) {
     if (other is! GvnEntry) return false;
     GvnEntry entry = other;
     List otherVector = entry.vector;
     if (vector.length != otherVector.length) return false;
     for (int i = 0; i < vector.length; ++i) {
       if (vector[i] != otherVector[i]) return false;
     }
     return true;
   }
 
   /// Combines the hash codes of [vector] using Jenkin's hash function, with
   /// intermediate results truncated to SMI range.
   static int computeHashCode(List vector) {
     int hash = 0;
     for (int i = 0; i < vector.length; ++i) {
       hash = 0x1fffffff & (hash + vector[i].hashCode);
       hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
       hash = hash ^ (hash >> 6);
     }
-    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 }
 
 /// Converts GVN'able primitives to a vector containing all the values
 /// to be considered when computing a GVN for it.
 ///
 /// This includes the instruction type, inputs, effect numbers for any part
 /// of the heap being depended on, as well as any instruction-specific payload
@@ skipping 118 matching lines @@
   static const int GET_INDEX = 6;
   static const int GET_STATIC = 7;
   static const int CONSTANT = 8;
   static const int REIFY_RUNTIME_TYPE = 9;
   static const int READ_TYPE_VARIABLE = 10;
   static const int TYPE_EXPRESSION = 11;
   static const int INTERCEPTOR = 12;
 }
 
 typedef ReferenceCallback(Reference ref);
+
 class InputVisitor extends DeepRecursiveVisitor {
   ReferenceCallback callback;
 
   InputVisitor(this.callback);
 
   @override
   processReference(Reference ref) {
     callback(ref);
   }
 
   static void forEach(Primitive node, ReferenceCallback callback) {
     new InputVisitor(callback).visit(node);
   }
 }