dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/bounds_checker.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.bounds_checker;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart' show Pass;
 import 'octagon.dart';
 import '../constants/values.dart';
@@ skipping 106 matching lines @@
   SignedVariable getLength(Primitive indexableObject, int effectNumber) {
     indexableObject = indexableObject.effectiveDefinition;
     TypeMask type = indexableObject.type.nonNullable();
     if (types.isDefinitelyFixedLengthIndexable(type)) {
       // Always use the same effect number if the length is immutable.
       effectNumber = 0;
     }
     return lengthOf
         .putIfAbsent(indexableObject, () => <int, SignedVariable>{})
         .putIfAbsent(effectNumber, () {
-            int length = types.getContainerLength(type);
-            if (length != null) {
-              return octagon.makeVariable(length, length);
-            } else {
-              return octagon.makeVariable(0, MAX_UINT32);
-            }
-        });
+      int length = types.getContainerLength(type);
+      if (length != null) {
+        return octagon.makeVariable(length, length);
+      } else {
+        return octagon.makeVariable(0, MAX_UINT32);
+      }
+    });
   }
 
   // ------------- CONSTRAINT HELPERS -----------------
 
   /// Puts the given constraint "in scope" by adding it to the octagon, and
   /// pushing a stack action that will remove it again.
   void applyConstraint(SignedVariable v1, SignedVariable v2, int k) {
     Constraint constraint = new Constraint(v1, v2, k);
     octagon.pushConstraint(constraint);
     pushAction(() => octagon.popConstraint(constraint));
@@ skipping 342 matching lines @@
 
   @override
   void visitGetLength(GetLength node) {
     valueOf[node] = getLength(node.object, currentEffectNumber);
   }
 
   @override
   void visitBoundsCheck(BoundsCheck node) {
     if (node.checks == BoundsCheck.NONE) return;
     assert(node.indexRef != null); // Because there is at least one check.
-    SignedVariable length = node.lengthRef == null
-        ? null
-        : getValue(node.length);
+    SignedVariable length =
+        node.lengthRef == null ? null : getValue(node.length);
     SignedVariable index = getValue(node.index);
     if (node.hasUpperBoundCheck) {
       if (isDefinitelyLessThan(index, length)) {
         node.checks &= ~BoundsCheck.UPPER_BOUND;
       } else {
         makeLessThan(index, length);
       }
     }
     if (node.hasLowerBoundCheck) {
       if (isDefinitelyGreaterThanOrEqualToConstant(index, 0)) {
         node.checks &= ~BoundsCheck.LOWER_BOUND;
       } else {
         makeGreaterThanOrEqualToConstant(index, 0);
       }
     }
     if (node.hasEmptinessCheck) {
       if (isDefinitelyGreaterThanOrEqualToConstant(length, 1)) {
         node.checks &= ~BoundsCheck.EMPTINESS;
       } else {
         makeGreaterThanOrEqualToConstant(length, 1);
       }
     }
     if (!node.lengthUsedInCheck && node.lengthRef != null) {
-      node..lengthRef.unlink()..lengthRef = null;
+      node
+        ..lengthRef.unlink()
+        ..lengthRef = null;
     }
     if (node.checks == BoundsCheck.NONE) {
       // We can't remove the bounds check node because it may still be used to
       // restrict code motion.  But the index is no longer needed.
-      node..indexRef.unlink()..indexRef = null;
+      node
+        ..indexRef.unlink()
+        ..indexRef = null;
     }
   }
 
   void analyzeLoopEntry(InvokeContinuation node) {
     foundLoop = true;
     Continuation cont = node.continuation;
     if (isStrongLoopPass) {
       for (int i = 0; i < node.argumentRefs.length; ++i) {
         Parameter param = cont.parameters[i];
         if (!isInt(param)) continue;
@@ skipping 160 matching lines @@
     }
     return node.body;
   }
 }
 
 /// Lattice representing the known (weak) monotonicity of a loop variable.
 ///
 /// The lattice bottom is represented by `null` and represents the case where
 /// the loop variable never changes value during the loop.
 enum Monotonicity { NotMonotone, Increasing, Decreasing, }