dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/type_propagation.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.type_propagation;
 
 import 'optimizers.dart';
 
-import '../closure.dart' show
-    ClosureClassElement;
+import '../closure.dart' show ClosureClassElement;
 import '../common.dart';
-import '../common/names.dart' show
-    Identifiers,
-    Selectors;
-import '../compiler.dart' as dart2js show
-    Compiler;
+import '../common/names.dart' show Identifiers, Selectors;
+import '../compiler.dart' as dart2js show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../dart_types.dart' as types;
 import '../elements/elements.dart';
-import '../io/source_information.dart' show
-    SourceInformation;
-import '../js_backend/backend_helpers.dart' show
-    BackendHelpers;
-import '../js_backend/js_backend.dart' show
-    JavaScriptBackend;
-import '../js_backend/codegen/task.dart' show
-    CpsFunctionCompiler;
+import '../io/source_information.dart' show SourceInformation;
+import '../js_backend/backend_helpers.dart' show BackendHelpers;
+import '../js_backend/js_backend.dart' show JavaScriptBackend;
+import '../js_backend/codegen/task.dart' show CpsFunctionCompiler;
 import '../resolution/operators.dart';
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
-import '../types/abstract_value_domain.dart' show
-    AbstractBool;
-import '../universe/selector.dart' show
-    Selector;
+import '../types/abstract_value_domain.dart' show AbstractBool;
+import '../universe/selector.dart' show Selector;
 import '../world.dart' show World;
 import 'cps_fragment.dart';
 import 'cps_ir_nodes.dart';
 import 'type_mask_system.dart';
 import 'effects.dart';
 
 class ConstantPropagationLattice {
   final TypeMaskSystem typeSystem;
   final ConstantSystem constantSystem;
   final types.DartTypes dartTypes;
   final AbstractConstantValue anything;
   final AbstractConstantValue nothing = new AbstractConstantValue.nothing();
   final AbstractConstantValue nullValue;
   final AbstractConstantValue trueValue;
   final AbstractConstantValue falseValue;
 
   ConstantPropagationLattice(CpsFunctionCompiler functionCompiler)
-    : typeSystem = functionCompiler.typeSystem,
-      constantSystem = functionCompiler.compiler.backend.constantSystem,
-      dartTypes = functionCompiler.compiler.types,
-      anything = new AbstractConstantValue.nonConstant(
-          functionCompiler.typeSystem.dynamicType),
-      nullValue = new AbstractConstantValue.constantValue(
-          new NullConstantValue(), new TypeMask.empty()),
-      trueValue = new AbstractConstantValue.constantValue(
-          new TrueConstantValue(), functionCompiler.typeSystem.boolType),
-      falseValue = new AbstractConstantValue.constantValue(
-          new FalseConstantValue(), functionCompiler.typeSystem.boolType);
+      : typeSystem = functionCompiler.typeSystem,
+        constantSystem = functionCompiler.compiler.backend.constantSystem,
+        dartTypes = functionCompiler.compiler.types,
+        anything = new AbstractConstantValue.nonConstant(
+            functionCompiler.typeSystem.dynamicType),
+        nullValue = new AbstractConstantValue.constantValue(
+            new NullConstantValue(), new TypeMask.empty()),
+        trueValue = new AbstractConstantValue.constantValue(
+            new TrueConstantValue(), functionCompiler.typeSystem.boolType),
+        falseValue = new AbstractConstantValue.constantValue(
+            new FalseConstantValue(), functionCompiler.typeSystem.boolType);
 
   AbstractConstantValue constant(ConstantValue value, [TypeMask type]) {
     if (type == null) type = typeSystem.getTypeOf(value);
     return new AbstractConstantValue.constantValue(value, type);
   }
 
   AbstractConstantValue nonConstant([TypeMask type]) {
     if (type == null) type = typeSystem.dynamicType;
     return new AbstractConstantValue.nonConstant(type);
   }
@@ skipping 11 matching lines @@
       return x;
     } else {
       return new AbstractConstantValue.nonConstant(
           typeSystem.join(x.type, y.type));
     }
   }
 
   /// True if all members of this value are booleans.
   bool isDefinitelyBool(AbstractConstantValue value, {bool allowNull: false}) {
     return value.isNothing ||
-      typeSystem.isDefinitelyBool(value.type, allowNull: allowNull);
+        typeSystem.isDefinitelyBool(value.type, allowNull: allowNull);
   }
 
   /// True if all members of this value are numbers.
   bool isDefinitelyNum(AbstractConstantValue value, {bool allowNull: false}) {
     return value.isNothing ||
-      typeSystem.isDefinitelyNum(value.type, allowNull: allowNull);
+        typeSystem.isDefinitelyNum(value.type, allowNull: allowNull);
   }
 
   /// True if all members of this value are strings.
   bool isDefinitelyString(AbstractConstantValue value,
-                          {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
-      typeSystem.isDefinitelyString(value.type, allowNull: allowNull);
+        typeSystem.isDefinitelyString(value.type, allowNull: allowNull);
   }
 
   /// True if all members of this value are numbers, strings, or booleans.
   bool isDefinitelyNumStringBool(AbstractConstantValue value,
-                                 {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
-      typeSystem.isDefinitelyNumStringBool(value.type, allowNull: allowNull);
+        typeSystem.isDefinitelyNumStringBool(value.type, allowNull: allowNull);
   }
 
   /// True if this value cannot be a string, number, or boolean.
   bool isDefinitelyNotNumStringBool(AbstractConstantValue value) {
     return value.isNothing ||
-      typeSystem.isDefinitelyNotNumStringBool(value.type);
+        typeSystem.isDefinitelyNotNumStringBool(value.type);
   }
 
   /// True if this value cannot be a non-integer double.
   ///
   /// In other words, if true is returned, and the value is a number, then
   /// it is a whole number and is not NaN, Infinity, or minus Infinity.
   bool isDefinitelyNotNonIntegerDouble(AbstractConstantValue value) {
     return value.isNothing ||
-      value.isConstant && !value.constant.isDouble ||
-      typeSystem.isDefinitelyNotNonIntegerDouble(value.type);
+        value.isConstant && !value.constant.isDouble ||
+        typeSystem.isDefinitelyNotNonIntegerDouble(value.type);
   }
 
-  bool isDefinitelyInt(AbstractConstantValue value,
-                       {bool allowNull: false}) {
+  bool isDefinitelyInt(AbstractConstantValue value, {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyInt(value.type, allowNull: allowNull);
   }
 
   bool isDefinitelyUint31(AbstractConstantValue value,
-                          {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyUint31(value.type, allowNull: allowNull);
   }
 
   bool isDefinitelyUint32(AbstractConstantValue value,
-                          {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyUint32(value.type, allowNull: allowNull);
   }
 
-  bool isDefinitelyUint(AbstractConstantValue value,
-                       {bool allowNull: false}) {
+  bool isDefinitelyUint(AbstractConstantValue value, {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyUint(value.type, allowNull: allowNull);
   }
 
-  bool isDefinitelyArray(AbstractConstantValue value,
-                              {bool allowNull: false}) {
+  bool isDefinitelyArray(AbstractConstantValue value, {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyArray(value.type, allowNull: allowNull);
   }
 
   bool isDefinitelyMutableArray(AbstractConstantValue value,
-                                     {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
-         typeSystem.isDefinitelyMutableArray(value.type,
-                                                  allowNull: allowNull);
+        typeSystem.isDefinitelyMutableArray(value.type, allowNull: allowNull);
   }
 
   bool isDefinitelyFixedArray(AbstractConstantValue value,
-                              {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
-        typeSystem.isDefinitelyFixedArray(value.type,
-                                          allowNull: allowNull);
+        typeSystem.isDefinitelyFixedArray(value.type, allowNull: allowNull);
   }
 
   bool isDefinitelyExtendableArray(AbstractConstantValue value,
-                                   {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyExtendableArray(value.type,
-                                               allowNull: allowNull);
+            allowNull: allowNull);
   }
 
   bool isDefinitelyIndexable(AbstractConstantValue value,
-                             {bool allowNull: false}) {
+      {bool allowNull: false}) {
     return value.isNothing ||
         typeSystem.isDefinitelyIndexable(value.type, allowNull: allowNull);
   }
 
   /// Returns `true` if [value] represents an int value that must be in the
   /// inclusive range.
   bool isDefinitelyIntInRange(AbstractConstantValue value, {int min, int max}) {
     if (value.isNothing) return true;
     if (!isDefinitelyInt(value)) return false;
     PrimitiveConstantValue constant = value.constant;
     if (constant == null) return false;
     if (!constant.isInt) return false;
     if (min != null && constant.primitiveValue < min) return false;
     if (max != null && constant.primitiveValue > max) return false;
     return true;
   }
 
   /// Returns whether the given [value] is an instance of [type].
   ///
   /// Since [value] and [type] are not always known, [AbstractBool.Maybe] is
   /// returned if the answer is not known.
   ///
   /// [AbstractBool.Nothing] is returned if [value] is nothing.
   ///
   /// If [allowNull] is true, `null` is considered an instance of anything,
   /// otherwise it is only considered an instance of [Object], [dynamic], and
   /// [Null].
-  AbstractBool isSubtypeOf(AbstractConstantValue value,
-                           types.DartType type,
-                           {bool allowNull}) {
+  AbstractBool isSubtypeOf(AbstractConstantValue value, types.DartType type,
+      {bool allowNull}) {
     assert(allowNull != null);
     if (value.isNothing) {
       return AbstractBool.Nothing;
     }
     if (value.isConstant) {
       if (value.constant.isNull) {
         if (allowNull ||
             type.isObject ||
             type.isDynamic ||
             type == dartTypes.coreTypes.nullType) {
           return AbstractBool.True;
         }
         if (type is types.TypeVariableType) {
           return AbstractBool.Maybe;
         }
         return AbstractBool.False;
       }
       if (type == dartTypes.coreTypes.intType) {
         return constantSystem.isInt(value.constant)
-          ? AbstractBool.True
-          : AbstractBool.False;
+            ? AbstractBool.True
+            : AbstractBool.False;
       }
       types.DartType valueType = value.constant.getType(dartTypes.coreTypes);
       if (constantSystem.isSubtype(dartTypes, valueType, type)) {
         return AbstractBool.True;
       }
       if (!dartTypes.isPotentialSubtype(valueType, type)) {
         return AbstractBool.False;
       }
       return AbstractBool.Maybe;
     }
     return typeSystem.isSubtypeOf(value.type, type, allowNull: allowNull);
   }
 
   /// Returns the possible results of applying [operator] to [value],
   /// assuming the operation does not throw.
   ///
   /// Because we do not explicitly track thrown values, we currently use the
   /// convention that constant values are returned from this method only
   /// if the operation is known not to throw.
   ///
   /// This method returns `null` if a good result could not be found. In that
   /// case, it is best to fall back on interprocedural type information.
-  AbstractConstantValue unaryOp(UnaryOperator operator,
-                                AbstractConstantValue value) {
+  AbstractConstantValue unaryOp(
+      UnaryOperator operator, AbstractConstantValue value) {
     switch (operator.kind) {
       case UnaryOperatorKind.COMPLEMENT:
         return bitNotSpecial(value);
       case UnaryOperatorKind.NEGATE:
         return negateSpecial(value);
       default:
         break;
     }
     // TODO(asgerf): Also return information about whether this can throw?
     if (value.isNothing) {
@@ skipping 11 matching lines @@
   /// Returns the possible results of applying [operator] to [left], [right],
   /// assuming the operation does not throw.
   ///
   /// Because we do not explicitly track thrown values, we currently use the
   /// convention that constant values are returned from this method only
   /// if the operation is known not to throw.
   ///
   /// This method returns `null` if a good result could not be found. In that
   /// case, it is best to fall back on interprocedural type information.
   AbstractConstantValue binaryOp(BinaryOperator operator,
-                         AbstractConstantValue left,
-                         AbstractConstantValue right) {
+      AbstractConstantValue left, AbstractConstantValue right) {
     switch (operator.kind) {
       case BinaryOperatorKind.ADD:
         return addSpecial(left, right);
 
       case BinaryOperatorKind.SUB:
         return subtractSpecial(left, right);
 
       case BinaryOperatorKind.MUL:
         return multiplySpecial(left, right);
 
@@ skipping 44 matching lines @@
       return nothing;
     }
     if (left.isConstant && right.isConstant) {
       BinaryOperation operation = constantSystem.lookupBinary(operator);
       ConstantValue result = operation.fold(left.constant, right.constant);
       if (result != null) return constant(result);
     }
     return null; // The caller will use return type from type inference.
   }
 
-  AbstractConstantValue foldUnary(UnaryOperation operation,
-                                  AbstractConstantValue value) {
+  AbstractConstantValue foldUnary(
+      UnaryOperation operation, AbstractConstantValue value) {
     if (value.isNothing) return nothing;
     if (value.isConstant) {
       ConstantValue result = operation.fold(value.constant);
       if (result != null) return constant(result);
     }
     return null;
   }
 
   AbstractConstantValue bitNotSpecial(AbstractConstantValue value) {
     return foldUnary(constantSystem.bitNot, value);
   }
 
   AbstractConstantValue negateSpecial(AbstractConstantValue value) {
     AbstractConstantValue folded = foldUnary(constantSystem.negate, value);
     if (folded != null) return folded;
     if (isDefinitelyInt(value, allowNull: true)) {
       return nonConstant(typeSystem.intType);
     }
     return null;
   }
 
-
   AbstractConstantValue foldBinary(BinaryOperation operation,
       AbstractConstantValue left, AbstractConstantValue right) {
     if (left.isNothing || right.isNothing) return nothing;
     if (left.isConstant && right.isConstant) {
       ConstantValue result = operation.fold(left.constant, right.constant);
       if (result != null) return constant(result);
     }
     return null;
   }
 
-  AbstractConstantValue closedOnInt(AbstractConstantValue left,
-                                    AbstractConstantValue right) {
+  AbstractConstantValue closedOnInt(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (isDefinitelyInt(left, allowNull: true) &&
         isDefinitelyInt(right, allowNull: true)) {
       return nonConstant(typeSystem.intType);
     }
     return null;
   }
 
-  AbstractConstantValue closedOnUint(AbstractConstantValue left,
-                                     AbstractConstantValue right) {
+  AbstractConstantValue closedOnUint(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (isDefinitelyUint(left, allowNull: true) &&
         isDefinitelyUint(right, allowNull: true)) {
       return nonConstant(typeSystem.uintType);
     }
     return null;
   }
 
-  AbstractConstantValue closedOnUint31(AbstractConstantValue left,
-                                       AbstractConstantValue right) {
+  AbstractConstantValue closedOnUint31(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (isDefinitelyUint31(left, allowNull: true) &&
         isDefinitelyUint31(right, allowNull: true)) {
       return nonConstant(typeSystem.uint31Type);
     }
     return null;
   }
 
-  AbstractConstantValue addSpecial(AbstractConstantValue left,
-                                   AbstractConstantValue right) {
+  AbstractConstantValue addSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded = foldBinary(constantSystem.add, left, right);
     if (folded != null) return folded;
     if (isDefinitelyNum(left, allowNull: true)) {
       if (isDefinitelyUint31(left, allowNull: true) &&
           isDefinitelyUint31(right, allowNull: true)) {
         return nonConstant(typeSystem.uint32Type);
       }
       return closedOnUint(left, right) ?? closedOnInt(left, right);
     }
     return null;
   }
 
-  AbstractConstantValue subtractSpecial(AbstractConstantValue left,
-                                        AbstractConstantValue right) {
+  AbstractConstantValue subtractSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.subtract, left, right);
     return folded ?? closedOnInt(left, right);
   }
 
-  AbstractConstantValue multiplySpecial(AbstractConstantValue left,
-                                        AbstractConstantValue right) {
+  AbstractConstantValue multiplySpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.multiply, left, right);
     return folded ?? closedOnUint(left, right) ?? closedOnInt(left, right);
   }
 
-  AbstractConstantValue divideSpecial(AbstractConstantValue left,
-                                      AbstractConstantValue right) {
+  AbstractConstantValue divideSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     return foldBinary(constantSystem.divide, left, right);
   }
 
   AbstractConstantValue truncatingDivideSpecial(
       AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.truncatingDivide, left, right);
     if (folded != null) return folded;
     if (isDefinitelyNum(left, allowNull: true)) {
       if (isDefinitelyUint32(left, allowNull: true) &&
@@ skipping 10 matching lines @@
         }
         if (isDefinitelyUint(left, allowNull: true)) {
           return nonConstant(typeSystem.uintType);
         }
       }
       return nonConstant(typeSystem.intType);
     }
     return null;
   }
 
-  AbstractConstantValue moduloSpecial(AbstractConstantValue left,
-                                      AbstractConstantValue right) {
+  AbstractConstantValue moduloSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.modulo, left, right);
     return folded ?? closedOnUint(left, right) ?? closedOnInt(left, right);
   }
 
-  AbstractConstantValue remainderSpecial(AbstractConstantValue left,
-                                         AbstractConstantValue right) {
+  AbstractConstantValue remainderSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (left.isNothing || right.isNothing) return nothing;
-    AbstractConstantValue folded = null;  // Remainder not in constant system.
+    AbstractConstantValue folded = null; // Remainder not in constant system.
     return folded ?? closedOnUint(left, right) ?? closedOnInt(left, right);
   }
 
-  AbstractConstantValue codeUnitAtSpecial(AbstractConstantValue left,
-                                          AbstractConstantValue right) {
+  AbstractConstantValue codeUnitAtSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     return foldBinary(constantSystem.codeUnitAt, left, right);
   }
 
-  AbstractConstantValue equalSpecial(AbstractConstantValue left,
-                                     AbstractConstantValue right) {
+  AbstractConstantValue equalSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.equal, left, right);
     if (folded != null) return folded;
     bool behavesLikeIdentity =
         isDefinitelyNumStringBool(left, allowNull: true) ||
-        right.isNullConstant;
-    if (behavesLikeIdentity &&
-        typeSystem.areDisjoint(left.type, right.type)) {
+            right.isNullConstant;
+    if (behavesLikeIdentity && typeSystem.areDisjoint(left.type, right.type)) {
       return constant(new FalseConstantValue());
     }
     return null;
   }
 
-  AbstractConstantValue andSpecial(AbstractConstantValue left,
-                                   AbstractConstantValue right) {
+  AbstractConstantValue andSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.bitAnd, left, right);
     if (folded != null) return folded;
     if (isDefinitelyNum(left, allowNull: true)) {
       if (isDefinitelyUint31(left, allowNull: true) ||
           isDefinitelyUint31(right, allowNull: true)) {
         // Either 31-bit argument will truncate the other.
         return nonConstant(typeSystem.uint31Type);
       }
     }
     return null;
   }
 
-  AbstractConstantValue orSpecial(AbstractConstantValue left,
-                                  AbstractConstantValue right) {
+  AbstractConstantValue orSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.bitOr, left, right);
     return folded ?? closedOnUint31(left, right);
   }
 
-  AbstractConstantValue xorSpecial(AbstractConstantValue left,
-                                   AbstractConstantValue right) {
+  AbstractConstantValue xorSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.bitXor, left, right);
     return folded ?? closedOnUint31(left, right);
   }
 
-  AbstractConstantValue shiftLeftSpecial(AbstractConstantValue left,
-                                         AbstractConstantValue right) {
+  AbstractConstantValue shiftLeftSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     return foldBinary(constantSystem.shiftLeft, left, right);
   }
 
-  AbstractConstantValue shiftRightSpecial(AbstractConstantValue left,
-                                          AbstractConstantValue right) {
+  AbstractConstantValue shiftRightSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     AbstractConstantValue folded =
         foldBinary(constantSystem.shiftRight, left, right);
     if (folded != null) return folded;
     if (isDefinitelyUint31(left, allowNull: true)) {
       return nonConstant(typeSystem.uint31Type);
     } else if (isDefinitelyUint32(left, allowNull: true)) {
       if (isDefinitelyIntInRange(right, min: 1, max: 31)) {
         // A zero will be shifted into the 'sign' bit.
         return nonConstant(typeSystem.uint31Type);
       }
       return nonConstant(typeSystem.uint32Type);
     }
     return null;
   }
 
-  AbstractConstantValue lessSpecial(AbstractConstantValue left,
-                                    AbstractConstantValue right) {
+  AbstractConstantValue lessSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (isDefinitelyUint(left) && right.isZeroOrNegativeConstant) {
       return falseValue; // "uint < 0" is false.
     } else if (left.isNegativeConstant && isDefinitelyUint(right)) {
       return trueValue; // "-1 < uint" is true.
     }
     return foldBinary(constantSystem.less, left, right);
   }
 
-  AbstractConstantValue lessEqualSpecial(AbstractConstantValue left,
-                                         AbstractConstantValue right) {
+  AbstractConstantValue lessEqualSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (isDefinitelyUint(left) && right.isNegativeConstant) {
       return falseValue; // "uint <= -1" is false.
     } else if (left.isZeroOrNegativeConstant && isDefinitelyUint(right)) {
       return trueValue; // "0 <= uint" is true.
     }
     return foldBinary(constantSystem.lessEqual, left, right);
   }
 
-  AbstractConstantValue greaterSpecial(AbstractConstantValue left,
-                                       AbstractConstantValue right) {
+  AbstractConstantValue greaterSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (left.isZeroOrNegativeConstant && isDefinitelyUint(right)) {
       return falseValue; // "0 > uint" is false
     } else if (isDefinitelyUint(left) && right.isNegativeConstant) {
       return trueValue; // "uint > -1" is true
     }
     return foldBinary(constantSystem.greater, left, right);
   }
 
-  AbstractConstantValue greaterEqualSpecial(AbstractConstantValue left,
-                                            AbstractConstantValue right) {
+  AbstractConstantValue greaterEqualSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (left.isNegativeConstant && isDefinitelyUint(right)) {
       return falseValue; // "-1 >= uint" is false
     } else if (isDefinitelyUint(left) && right.isZeroOrNegativeConstant) {
       return trueValue; // "uint >= 0" is true
     }
     return foldBinary(constantSystem.greaterEqual, left, right);
   }
 
   AbstractConstantValue intConstant(int value) {
     return constant(new IntConstantValue(value));
   }
 
   AbstractConstantValue lengthSpecial(AbstractConstantValue input) {
     if (input.isConstant) {
       ConstantValue constant = input.constant;
       if (constant is StringConstantValue) {
         return intConstant(constant.length);
       } else if (constant is ListConstantValue) {
         return intConstant(constant.length);
       }
     }
     int length = typeSystem.getContainerLength(input.type);
     if (length != null) {
       return intConstant(length);
     }
-    return null;  // The caller will use return type from type inference.
+    return null; // The caller will use return type from type inference.
   }
 
   AbstractConstantValue stringConstant(String value) {
     return constant(new StringConstantValue(new ast.DartString.literal(value)));
   }
 
-  AbstractConstantValue indexSpecial(AbstractConstantValue left,
-                                     AbstractConstantValue right) {
+  AbstractConstantValue indexSpecial(
+      AbstractConstantValue left, AbstractConstantValue right) {
     if (left.isNothing || right.isNothing) return nothing;
     if (right.isConstant) {
       ConstantValue index = right.constant;
       if (left.isConstant) {
         ConstantValue receiver = left.constant;
         if (receiver is StringConstantValue) {
           if (index is IntConstantValue) {
             String stringValue = receiver.primitiveValue.slowToString();
             int indexValue = index.primitiveValue;
             if (0 <= indexValue && indexValue < stringValue.length) {
               return stringConstant(stringValue[indexValue]);
             } else {
-              return nothing;  // Will throw.
+              return nothing; // Will throw.
             }
           }
         } else if (receiver is ListConstantValue) {
           if (index is IntConstantValue) {
             int indexValue = index.primitiveValue;
             if (0 <= indexValue && indexValue < receiver.length) {
               return constant(receiver.entries[indexValue]);
             } else {
-              return nothing;  // Will throw.
+              return nothing; // Will throw.
             }
           }
         } else if (receiver is MapConstantValue) {
           ConstantValue result = receiver.lookup(index);
           if (result != null) {
             return constant(result);
           }
           return constant(new NullConstantValue());
         }
       }
       TypeMask type = typeSystem.indexWithConstant(left.type, index);
       if (type != null) return nonConstant(type);
     }
     // TODO(asgerf): Handle case where 'left' is a List or Map constant but
     //               the index is unknown.
-    return null;  // The caller will use return type from type inference.
+    return null; // The caller will use return type from type inference.
   }
 
   AbstractConstantValue stringify(AbstractConstantValue value) {
     if (value.isNothing) return nothing;
     if (value.isNonConst) return nonConstant(typeSystem.stringType);
     ConstantValue constantValue = value.constant;
     if (constantValue is StringConstantValue) {
       return value;
     } else if (constantValue is PrimitiveConstantValue) {
       // Note: The primitiveValue for a StringConstantValue is not suitable
@@ skipping 41 matching lines @@
     if (constantValue != null) return constant(constantValue, mask);
     return nonConstant(mask);
   }
 
   AbstractConstantValue nonNullable(AbstractConstantValue value) {
     if (value.isNullConstant) return nothing;
     if (!value.isNullable) return value;
     return nonConstant(value.type.nonNullable());
   }
 
-  AbstractConstantValue intersectWithType(AbstractConstantValue value,
-        TypeMask type) {
+  AbstractConstantValue intersectWithType(
+      AbstractConstantValue value, TypeMask type) {
     if (value.isNothing || typeSystem.areDisjoint(value.type, type)) {
       return nothing;
     } else if (value.isConstant) {
       return value;
     } else {
       return nonConstant(typeSystem.intersection(value.type, type));
     }
   }
 
   /// If [value] is an integer constant, returns its value, otherwise `null`.
@@ skipping 13 matching lines @@
  *
  * Should be followed by the [ShrinkingReducer] pass.
  *
  * Implemented according to 'Constant Propagation with Conditional Branches'
  * by Wegman, Zadeck.
  */
 class TypePropagator extends Pass {
   String get passName => 'Type propagation';
 
   final CpsFunctionCompiler _functionCompiler;
-  final Map<Variable, ConstantValue> _values= <Variable, ConstantValue>{};
+  final Map<Variable, ConstantValue> _values = <Variable, ConstantValue>{};
   final ConstantPropagationLattice _lattice;
   final bool recomputeAll;
 
   TypePropagator(CpsFunctionCompiler functionCompiler,
       {this.recomputeAll: false})
       : _functionCompiler = functionCompiler,
         _lattice = new ConstantPropagationLattice(functionCompiler);
 
   dart2js.Compiler get _compiler => _functionCompiler.compiler;
   InternalErrorFunction get _internalError => _compiler.reporter.internalError;
 
   @override
   void rewrite(FunctionDefinition root) {
     // Analyze. In this phase, the entire term is analyzed for reachability
     // and the abstract value of each expression.
-    TypePropagationVisitor analyzer = new TypePropagationVisitor(
-        _lattice,
-        _values,
-        _internalError);
+    TypePropagationVisitor analyzer =
+        new TypePropagationVisitor(_lattice, _values, _internalError);
 
     analyzer.analyze(root, recomputeAll);
 
     // Transform. Uses the data acquired in the previous analysis phase to
     // replace branches with fixed targets and side-effect-free expressions
     // with constant results or existing values that are in scope.
     TransformingVisitor transformer = new TransformingVisitor(
-        _compiler,
-        _functionCompiler,
-        _lattice,
-        analyzer,
-        _internalError);
+        _compiler, _functionCompiler, _lattice, analyzer, _internalError);
     transformer.transform(root);
   }
 }
 
 final Map<String, BuiltinOperator> NumBinaryBuiltins =
-  const <String, BuiltinOperator>{
-    '+':  BuiltinOperator.NumAdd,
-    '-':  BuiltinOperator.NumSubtract,
-    '*':  BuiltinOperator.NumMultiply,
-    '/':  BuiltinOperator.NumDivide,
-    '&':  BuiltinOperator.NumAnd,
-    '|':  BuiltinOperator.NumOr,
-    '^':  BuiltinOperator.NumXor,
-    '<':  BuiltinOperator.NumLt,
-    '<=': BuiltinOperator.NumLe,
-    '>':  BuiltinOperator.NumGt,
-    '>=': BuiltinOperator.NumGe
+    const <String, BuiltinOperator>{
+  '+': BuiltinOperator.NumAdd,
+  '-': BuiltinOperator.NumSubtract,
+  '*': BuiltinOperator.NumMultiply,
+  '/': BuiltinOperator.NumDivide,
+  '&': BuiltinOperator.NumAnd,
+  '|': BuiltinOperator.NumOr,
+  '^': BuiltinOperator.NumXor,
+  '<': BuiltinOperator.NumLt,
+  '<=': BuiltinOperator.NumLe,
+  '>': BuiltinOperator.NumGt,
+  '>=': BuiltinOperator.NumGe
 };
 
 /**
  * Uses the information from a preceding analysis pass in order to perform the
  * actual transformations on the CPS graph.
  */
 class TransformingVisitor extends DeepRecursiveVisitor {
   final TypePropagationVisitor analyzer;
   final ConstantPropagationLattice lattice;
   final dart2js.Compiler compiler;
   final CpsFunctionCompiler functionCompiler;
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   TypeMaskSystem get typeSystem => lattice.typeSystem;
   types.DartTypes get dartTypes => lattice.dartTypes;
   World get classWorld => typeSystem.classWorld;
   Map<Variable, ConstantValue> get values => analyzer.values;
 
   final InternalErrorFunction internalError;
 
   final List<Node> stack = <Node>[];
 
   TypeCheckOperator checkIsNumber;
 
-  TransformingVisitor(this.compiler,
-                      this.functionCompiler,
-                      this.lattice,
-                      this.analyzer,
-                      this.internalError) {
+  TransformingVisitor(this.compiler, this.functionCompiler, this.lattice,
+      this.analyzer, this.internalError) {
     checkIsNumber = new ClassTypeCheckOperator(
-        helpers.jsNumberClass,
-        BuiltinOperator.IsNotNumber);
+        helpers.jsNumberClass, BuiltinOperator.IsNotNumber);
   }
 
   void transform(FunctionDefinition root) {
     // If one of the parameters has no value, the function is unreachable.
     // We assume all values in scope have a non-empty type (otherwise the
     // scope is unreachable), so this optimization is required.
     // TODO(asgerf): Can we avoid emitting the function is the first place?
     for (Parameter param in root.parameters) {
       if (getValue(param).isNothing) {
         // Replace with `throw "Unreachable";`
         CpsFragment cps = new CpsFragment(null);
-        Primitive message = cps.makeConstant(
-            new StringConstantValue.fromString("Unreachable"));
+        Primitive message =
+            cps.makeConstant(new StringConstantValue.fromString("Unreachable"));
         cps.put(new Throw(message));
         replaceSubtree(root.body, cps.result);
         return;
       }
     }
     push(root.body);
     while (stack.isNotEmpty) {
       visit(stack.removeLast());
     }
   }
@@ skipping 292 matching lines @@
     if (node.argumentRefs.length > 1) return null;
     if (node.callingConvention == CallingConvention.OneShotIntercepted) {
       return null;
     }
 
     bool trustPrimitives = compiler.options.trustPrimitives;
 
     /// Check that the receiver and argument satisfy the given type checks, and
     /// throw a [NoSuchMethodError] or [ArgumentError] if the check fails.
     CpsFragment makeGuard(TypeCheckOperator receiverGuard,
-                          [TypeCheckOperator argumentGuard]) {
+        [TypeCheckOperator argumentGuard]) {
       CpsFragment cps = new CpsFragment(node.sourceInformation);
 
       // Make no guards if trusting primitives.
       if (trustPrimitives) return cps;
 
       // Determine which guards are needed.
       ChecksNeeded receiverChecks =
           receiverGuard.getChecksNeeded(node.receiver, classWorld);
       bool needReceiverGuard = receiverChecks != ChecksNeeded.None;
-      bool needArgumentGuard =
-          argumentGuard != null &&
+      bool needArgumentGuard = argumentGuard != null &&
           argumentGuard.needsCheck(node.argument(0), classWorld);
 
       if (!needReceiverGuard && !needArgumentGuard) return cps;
 
       // If we only need the receiver check, emit the specialized receiver
       // check instruction. Examples:
       //
       //   if (typeof receiver !== "number") return receiver.$lt;
       //   if (typeof receiver !== "number") return receiver.$lt();
       //
       if (!needArgumentGuard) {
         Primitive condition = receiverGuard.makeCheck(cps, node.receiver);
         cps.letPrim(new ReceiverCheck(
-            node.receiver,
-            node.selector,
-            node.sourceInformation,
+            node.receiver, node.selector, node.sourceInformation,
             condition: condition,
             useSelector: true,
-            isNullCheck: receiverChecks == ChecksNeeded.Null
-        ));
+            isNullCheck: receiverChecks == ChecksNeeded.Null));
         return cps;
       }
 
       // TODO(asgerf): We should consider specialized instructions for
       //   argument checks and receiver+argument checks, to avoid breaking up
       //   basic blocks.
 
       // Emit as `H.iae(x)` if only the argument check may fail. For example:
       //
       //   if (typeof argument !== "number") return H.iae(argument);
       //
       if (!needReceiverGuard) {
-        cps.ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
-           .invokeStaticThrower(helpers.throwIllegalArgumentException,
-              [node.argument(0)]);
+        cps
+            .ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
+            .invokeStaticThrower(
+                helpers.throwIllegalArgumentException, [node.argument(0)]);
         return cps;
       }
 
       // Both receiver and argument check is needed. Emit as a combined check
       // using a one-shot interceptor to produce the exact error message in
       // the error case.  For example:
       //
       //   if (typeof receiver !== "number" || typeof argument !== "number")
       //       return J.$lt(receiver, argument);
       //
       Continuation fail = cps.letCont();
-      cps.ifTruthy(receiverGuard.makeCheck(cps, node.receiver))
-         .invokeContinuation(fail);
-      cps.ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
-         .invokeContinuation(fail);
+      cps
+          .ifTruthy(receiverGuard.makeCheck(cps, node.receiver))
+          .invokeContinuation(fail);
+      cps
+          .ifTruthy(argumentGuard.makeCheck(cps, node.argument(0)))
+          .invokeContinuation(fail);
 
       cps.insideContinuation(fail)
-         ..invokeMethod(node.receiver, node.selector, node.mask,
-             [node.argument(0)],
-             callingConvention: CallingConvention.OneShotIntercepted)
-         ..put(new Unreachable());
+        ..invokeMethod(
+            node.receiver, node.selector, node.mask, [node.argument(0)],
+            callingConvention: CallingConvention.OneShotIntercepted)
+        ..put(new Unreachable());
 
       return cps;
     }
 
     /// Replaces the call with [operator], using the receiver and first argument
     /// as operands (in that order).
     ///
     /// If [guard] is given, the receiver and argument are both checked using
     /// that operator.
     CpsFragment makeBinary(BuiltinOperator operator,
-                           {TypeCheckOperator guard: TypeCheckOperator.none}) {
+        {TypeCheckOperator guard: TypeCheckOperator.none}) {
       CpsFragment cps = makeGuard(guard, guard);
       Primitive left = guard.makeRefinement(cps, node.receiver, classWorld);
-      Primitive right =
-          guard.makeRefinement(cps, node.argument(0), classWorld);
+      Primitive right = guard.makeRefinement(cps, node.argument(0), classWorld);
       Primitive result = cps.applyBuiltin(operator, [left, right]);
       result.hint = node.hint;
       node.replaceUsesWith(result);
       return cps;
     }
 
     /// Like [makeBinary] but for unary operators with the receiver as the
     /// argument.
     CpsFragment makeUnary(BuiltinOperator operator,
-                          {TypeCheckOperator guard: TypeCheckOperator.none}) {
+        {TypeCheckOperator guard: TypeCheckOperator.none}) {
       CpsFragment cps = makeGuard(guard);
-      Primitive argument =
-          guard.makeRefinement(cps, node.receiver, classWorld);
+      Primitive argument = guard.makeRefinement(cps, node.receiver, classWorld);
       Primitive result = cps.applyBuiltin(operator, [argument]);
       result.hint = node.hint;
       node.replaceUsesWith(result);
       return cps;
     }
 
     Selector renameToOptimizedSelector(String name) {
       return new Selector.call(
           new Name(name, backend.helpers.interceptorsLibrary),
           node.selector.callStructure);
     }
 
     /// Replaces the call with a call to [name] with the same inputs.
     InvokeMethod makeRenamedInvoke(String name) {
-      return new InvokeMethod(node.receiver,
-          renameToOptimizedSelector(name),
-          node.mask,
-          node.arguments.toList(),
+      return new InvokeMethod(node.receiver, renameToOptimizedSelector(name),
+          node.mask, node.arguments.toList(),
           sourceInformation: node.sourceInformation,
           callingConvention: node.callingConvention,
           interceptor: node.interceptor);
     }
 
     TypeMask successType =
         typeSystem.receiverTypeFor(node.selector, node.receiver.type);
 
     if (node.selector.isOperator && node.argumentRefs.length == 1) {
       Primitive leftArg = node.receiver;
@@ skipping 46 matching lines @@
             return makeBinary(BuiltinOperator.NumShl, guard: checkIsNumber);
           }
           // Try to insert a shift-right operator. JavaScript's right shift is
           // consistent with Dart's only for left operands in the unsigned
           // 32-bit range.
           if (opname == '>>') {
             if (lattice.isDefinitelyUint32(left, allowNull: true) &&
                 lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
               return makeBinary(BuiltinOperator.NumShr, guard: checkIsNumber);
             } else if (lattice.isDefinitelyUint(left) &&
-                       lattice.isDefinitelyUint(right)) {
+                lattice.isDefinitelyUint(right)) {
               return makeRenamedInvoke('_shrBothPositive');
             } else if (lattice.isDefinitelyUint(left) &&
-                       lattice.isDefinitelyNum(right)) {
+                lattice.isDefinitelyNum(right)) {
               return makeRenamedInvoke('_shrReceiverPositive');
             } else if (lattice.isDefinitelyNum(left) &&
-                       lattice.isDefinitelyUint(right)) {
+                lattice.isDefinitelyUint(right)) {
               return makeRenamedInvoke('_shrOtherPositive');
             }
           }
           // Try to use remainder for '%'. Both operands must be non-negative
           // and the divisor must be non-zero.
           if (opname == '%' &&
               lattice.isDefinitelyUint(left, allowNull: true) &&
               lattice.isDefinitelyUint(right) &&
               lattice.isDefinitelyIntInRange(right, min: 1)) {
             return makeBinary(BuiltinOperator.NumRemainder,
@@ skipping 41 matching lines @@
                 guard: checkIsNumber);
           }
         }
       } else if (name == 'codeUnitAt') {
         if (node.argumentRefs.length == 1) {
           Primitive index = node.argument(0);
           if (lattice.isDefinitelyString(receiverValue) &&
               lattice.isDefinitelyInt(getValue(index))) {
             CpsFragment cps = new CpsFragment(node.sourceInformation);
             receiver = makeBoundsCheck(cps, receiver, index);
-            ApplyBuiltinOperator get =
-                cps.applyBuiltin(BuiltinOperator.CharCodeAt,
-                                 <Primitive>[receiver, index]);
+            ApplyBuiltinOperator get = cps.applyBuiltin(
+                BuiltinOperator.CharCodeAt, <Primitive>[receiver, index]);
             node.replaceUsesWith(get);
             get.hint = node.hint;
             return cps;
           }
         }
       }
     }
     return null;
   }
 
@@ skipping 19 matching lines @@
     // TODO(asgerf): Inlining native fields will make some tests pass for the
     // wrong reason, so for testing reasons avoid inlining them.
     if (backend.isNative(target) || backend.isJsInterop(target)) {
       return null;
     }
     if (node.selector.isGetter) {
       return new GetField(node.receiver, target);
     } else if (node.selector.isSetter) {
       if (target.isFinal) return null;
       assert(node.hasNoUses);
-      return new SetField(node.receiver,
-                          target,
-                          node.argument(0));
+      return new SetField(node.receiver, target, node.argument(0));
     } else if (node.selector.isCall) {
       CpsFragment cps = new CpsFragment(node.sourceInformation);
       Primitive fieldValue = cps.letPrim(new GetField(node.receiver, target));
       Primitive result = cps.invokeMethod(
           fieldValue,
           new Selector.callClosureFrom(node.selector),
           typeSystem.getFieldType(target),
           node.arguments.toList());
       node.replaceUsesWith(result);
       return cps;
     } else {
       return null;
     }
   }
 
   /// Create a check that throws if [index] is not a valid index on [list].
   ///
   /// This function assumes that [index] is an integer.
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
-  Primitive makeBoundsCheck(CpsFragment cps,
-        Primitive list,
-        Primitive index,
-        [int checkKind = BoundsCheck.BOTH_BOUNDS | BoundsCheck.INTEGER]) {
+  Primitive makeBoundsCheck(CpsFragment cps, Primitive list, Primitive index,
+      [int checkKind = BoundsCheck.BOTH_BOUNDS | BoundsCheck.INTEGER]) {
     if (compiler.options.trustPrimitives) {
       return cps.letPrim(new BoundsCheck.noCheck(list, cps.sourceInformation));
     } else {
       GetLength length = cps.letPrim(new GetLength(list));
       list = cps.refine(list, typeSystem.nonNullType);
-      BoundsCheck check = cps.letPrim(new BoundsCheck(list, index, length,
-          checkKind, cps.sourceInformation));
+      BoundsCheck check = cps.letPrim(new BoundsCheck(
+          list, index, length, checkKind, cps.sourceInformation));
       if (check.hasIntegerCheck) {
         if (typeSystem.isDefinitelyInt(index.type)) {
           check.checks &= ~BoundsCheck.INTEGER;
         } else {
           cps.refine(index, typeSystem.uint32Type);
         }
       }
       return check;
     }
   }
 
   /// Create a check that throws if the length of [list] is not equal to
   /// [originalLength].
   ///
   /// Returns a CPS fragment whose context is the branch where no error
   /// was thrown.
-  CpsFragment makeConcurrentModificationCheck(Primitive list,
-                                              Primitive originalLength,
-                                              SourceInformation sourceInfo) {
+  CpsFragment makeConcurrentModificationCheck(
+      Primitive list, Primitive originalLength, SourceInformation sourceInfo) {
     CpsFragment cps = new CpsFragment(sourceInfo);
-    Primitive lengthChanged = cps.applyBuiltin(
-        BuiltinOperator.StrictNeq,
+    Primitive lengthChanged = cps.applyBuiltin(BuiltinOperator.StrictNeq,
         <Primitive>[originalLength, cps.letPrim(new GetLength(list))]);
     cps.ifTruthy(lengthChanged).invokeStaticThrower(
-        helpers.throwConcurrentModificationError,
-        <Primitive>[list]);
+        helpers.throwConcurrentModificationError, <Primitive>[list]);
     return cps;
   }
 
   /// Tries to replace [node] with a direct `length` or index access.
   ///
   /// Returns `true` if the node was replaced.
   specializeIndexableAccess(InvokeMethod node) {
     Primitive receiver = node.receiver;
     AbstractConstantValue receiverValue = getValue(receiver);
     if (!typeSystem.isDefinitelyIndexable(receiverValue.type,
-            allowNull: true)) {
+        allowNull: true)) {
       return null;
     }
     switch (node.selector.name) {
       case 'length':
         if (node.selector.isGetter) {
           return new GetLength(receiver);
         }
         if (node.selector.isSetter) {
           if (!typeSystem.isDefinitelyExtendableArray(receiver.type,
-                allowNull: true)) {
+              allowNull: true)) {
             return null;
           }
           CpsFragment cps = new CpsFragment(node.sourceInformation);
           Primitive newLength = node.argument(0);
           if (!typeSystem.isDefinitelyUint(newLength.type)) {
             // TODO(asgerf): We could let the SetLength instruction throw for
             // negative right-hand sides (see length setter in js_array.dart).
             if (compiler.options.trustPrimitives) {
               newLength = cps.refine(newLength, typeSystem.uint32Type);
               newLength.type = typeSystem.uint32Type;
             } else {
               return null;
             }
           }
-          cps.letPrim(new ApplyBuiltinMethod(
-              BuiltinMethod.SetLength,
-              receiver,
-              [newLength],
-              node.sourceInformation));
+          cps.letPrim(new ApplyBuiltinMethod(BuiltinMethod.SetLength, receiver,
+              [newLength], node.sourceInformation));
           if (!typeSystem.isDefinitelyUint32(newLength.type)) {
             // If the setter succeeded, the length must have been a uint32.
             cps.refine(newLength, typeSystem.uint32Type);
           }
           return cps;
         }
         return null;
 
       case '[]':
         Primitive index = node.argument(0);
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         receiver = makeBoundsCheck(cps, receiver, index);
         GetIndex get = cps.letPrim(new GetIndex(receiver, index));
         node.replaceUsesWith(get);
         // TODO(asgerf): Make replaceUsesWith set the hint?
         get.hint = node.hint;
         return cps;
 
       case '[]=':
         if (!typeSystem.isDefinitelyMutableIndexable(receiverValue.type,
-                allowNull: true)) {
+            allowNull: true)) {
           return null;
         }
         Primitive index = node.argument(0);
         Primitive value = node.argument(1);
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         receiver = makeBoundsCheck(cps, receiver, index);
         cps.letPrim(new SetIndex(receiver, index, value));
         assert(node.hasNoUses);
         return cps;
 
       case 'isEmpty':
         if (!node.selector.isGetter) return null;
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         Primitive length = cps.letPrim(new GetLength(receiver));
         Constant zero = cps.makeZero();
-        ApplyBuiltinOperator op = cps.applyBuiltin(BuiltinOperator.StrictEq,
-                                                   [length, zero]);
+        ApplyBuiltinOperator op =
+            cps.applyBuiltin(BuiltinOperator.StrictEq, [length, zero]);
         node.replaceUsesWith(op);
         op.hint = node.hint;
         return cps;
 
       case 'isNotEmpty':
         if (!node.selector.isGetter) return null;
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         Primitive length = cps.letPrim(new GetLength(receiver));
         Constant zero = cps.makeZero();
-        ApplyBuiltinOperator op = cps.applyBuiltin(BuiltinOperator.StrictNeq,
-                                                   [length, zero]);
+        ApplyBuiltinOperator op =
+            cps.applyBuiltin(BuiltinOperator.StrictNeq, [length, zero]);
         node.replaceUsesWith(op);
         op.hint = node.hint;
         return cps;
 
       default:
         return null;
     }
   }
 
   /// Tries to replace [node] with one or more direct array access operations.
@@ skipping 14 matching lines @@
     switch (node.selector.name) {
       case 'add':
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return null;
         }
         if (!isExtendable) return null;
         Primitive addedItem = node.argument(0);
         CpsFragment cps = new CpsFragment(sourceInfo);
-        cps.invokeBuiltin(BuiltinMethod.Push,
-            list,
-            <Primitive>[addedItem]);
+        cps.invokeBuiltin(BuiltinMethod.Push, list, <Primitive>[addedItem]);
         if (node.hasAtLeastOneUse) {
           node.replaceUsesWith(cps.makeNull());
         }
         return cps;
 
       case 'removeLast':
-        if (!node.selector.isCall ||
-            node.selector.argumentCount != 0) {
+        if (!node.selector.isCall || node.selector.argumentCount != 0) {
           return null;
         }
         if (!isExtendable) return null;
         CpsFragment cps = new CpsFragment(sourceInfo);
-        list = makeBoundsCheck(cps, list, cps.makeMinusOne(),
-            BoundsCheck.EMPTINESS);
-        Primitive removedItem = cps.invokeBuiltin(BuiltinMethod.Pop,
-            list,
-            <Primitive>[]);
+        list = makeBoundsCheck(
+            cps, list, cps.makeMinusOne(), BoundsCheck.EMPTINESS);
+        Primitive removedItem =
+            cps.invokeBuiltin(BuiltinMethod.Pop, list, <Primitive>[]);
         removedItem.hint = node.hint;
         node.replaceUsesWith(removedItem);
         return cps;
 
       case 'addAll':
-        if (!node.selector.isCall ||
-            node.selector.argumentCount != 1) {
+        if (!node.selector.isCall || node.selector.argumentCount != 1) {
           return null;
         }
         if (!isExtendable) return null;
         Primitive addedList = node.argument(0);
         // Rewrite addAll([x1, ..., xN]) to push(x1), ..., push(xN).
         // Ensure that the list is not mutated between creation and use.
         // We aim for the common case where this is the only use of the list,
         // which also guarantees that this list is not mutated before use.
         if (addedList is! LiteralList || !addedList.hasExactlyOneUse) {
           return null;
         }
         LiteralList addedLiteral = addedList;
         CpsFragment cps = new CpsFragment(sourceInfo);
         for (Reference value in addedLiteral.valueRefs) {
-          cps.invokeBuiltin(BuiltinMethod.Push,
-              list,
-              <Primitive>[value.definition]);
+          cps.invokeBuiltin(
+              BuiltinMethod.Push, list, <Primitive>[value.definition]);
         }
         if (node.hasAtLeastOneUse) {
           node.replaceUsesWith(cps.makeNull());
         }
         return cps;
 
       case 'elementAt':
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return null;
         }
         if (listValue.isNullable) return null;
         Primitive index = node.argument(0);
         if (!lattice.isDefinitelyInt(getValue(index))) return null;
         CpsFragment cps = new CpsFragment(node.sourceInformation);
         list = makeBoundsCheck(cps, list, index);
         GetIndex get = cps.letPrim(new GetIndex(list, index));
         get.hint = node.hint;
         node.replaceUsesWith(get);
         return cps;
 
       case 'forEach':
         Element element =
             compiler.world.locateSingleElement(node.selector, listValue.type);
-        if (element == null ||
-            !element.isFunction ||
-            !node.selector.isCall) return null;
+        if (element == null || !element.isFunction || !node.selector.isCall)
+          return null;
         assert(node.selector.positionalArgumentCount == 1);
         assert(node.selector.namedArgumentCount == 0);
         FunctionDefinition target = functionCompiler.compileToCpsIr(element);
 
         CpsFragment cps = new CpsFragment(node.sourceInformation);
-        Primitive result = cps.inlineFunction(target,
-            node.receiver,
-            node.arguments.toList(),
-            interceptor: node.interceptor,
-            hint: node.hint);
+        Primitive result = cps.inlineFunction(
+            target, node.receiver, node.arguments.toList(),
+            interceptor: node.interceptor, hint: node.hint);
         node.replaceUsesWith(result);
         return cps;
 
       case 'iterator':
         // TODO(asgerf): This should be done differently.
         //               The types are recomputed in a very error-prone manner.
         if (!node.selector.isGetter) return null;
         Primitive iterator = node;
         LetPrim iteratorBinding = node.parent;
 
@@ skipping 21 matching lines @@
           InvokeMethod use = ref.parent;
           if (use.selector == Selectors.current) {
             // Rewrite iterator.current to a use of the 'current' variable.
             if (use.hint != null) {
               // If 'current' was originally moved into a named variable, use
               // that variable name for the mutable variable.
               current.hint = use.hint;
             }
             use.replaceWith(new GetMutable(current));
           } else {
-            assert (use.selector == Selectors.moveNext);
+            assert(use.selector == Selectors.moveNext);
             // Rewrite iterator.moveNext() to:
             //
             //   if (index < list.length) {
             //     current = null;
             //     continuation(false);
             //   } else {
             //     current = list[index];
             //     index = index + 1;
             //     continuation(true);
             //   }
@@ skipping 32 matching lines @@
             // The check before the loop can often be eliminated because it
             // follows immediately after the 'iterator' call.
             InteriorNode parent = getEffectiveParent(use.parent);
             if (!isFixedLength) {
               if (parent is Continuation && parent.isRecursive) {
                 // Check for concurrent modification before every invocation
                 // of the continuation.
                 // TODO(asgerf): Do this in a continuation so multiple
                 //               continues can share the same code.
                 for (Reference ref = parent.firstRef;
-                     ref != null;
-                     ref = ref.next) {
+                    ref != null;
+                    ref = ref.next) {
                   Expression invocationCaller = ref.parent;
                   if (getEffectiveParent(invocationCaller) == iteratorBinding) {
                     // No need to check for concurrent modification immediately
                     // after the call to 'iterator'.
                     continue;
                   }
                   CpsFragment check = makeConcurrentModificationCheck(
                       list, originalLength, sourceInfo);
                   insertBefore(invocationCaller, check);
                 }
               } else {
                 cps.append(makeConcurrentModificationCheck(
                     list, originalLength, sourceInfo));
               }
             }
 
             // Check if there are more elements.
-            Primitive hasMore = cps.applyBuiltin(
-                BuiltinOperator.NumLt,
+            Primitive hasMore = cps.applyBuiltin(BuiltinOperator.NumLt,
                 [cps.getMutable(index), cps.letPrim(new GetLength(list))]);
 
             // Return false if there are no more.
             CpsFragment falseBranch = cps.ifFalsy(hasMore);
             falseBranch
               ..setMutable(current, falseBranch.makeNull())
               ..invokeContinuation(moveNextCont, [falseBranch.makeFalse()]);
 
             // Return true if there are more element.
             current.type = typeSystem.elementTypeOfIndexable(listValue.type);
             cps.setMutable(current,
                 cps.letPrim(new GetIndex(list, cps.getMutable(index))));
-            cps.setMutable(index, cps.applyBuiltin(
-                BuiltinOperator.NumAdd,
-                [cps.getMutable(index), cps.makeOne()]));
+            cps.setMutable(
+                index,
+                cps.applyBuiltin(BuiltinOperator.NumAdd,
+                    [cps.getMutable(index), cps.makeOne()]));
             cps.invokeContinuation(moveNextCont, [cps.makeTrue()]);
 
             reanalyzeFragment(cps);
 
             // Replace the moveNext() call. It will be visited later.
             LetPrim let = use.parent;
             cps.context = moveNextCont;
             cps.insertBelow(let);
             let.remove();
-            use..replaceUsesWith(result)..destroy();
+            use
+              ..replaceUsesWith(result)
+              ..destroy();
           }
         }
 
         // All effective uses have been rewritten.
         destroyRefinementsOfDeadPrimitive(iterator);
 
         // Rewrite the iterator call to initializers for 'index' and 'current'.
         CpsFragment cps = new CpsFragment();
         cps.letMutable(index, cps.makeZero());
         cps.letMutable(current, cps.makeNull());
@@ skipping 43 matching lines @@
 
       // If the selector does not apply, don't bother (will throw at runtime).
       if (!call.signatureApplies(target)) return null;
 
       // If some optional arguments are missing, give up.
       // TODO(asgerf): Improve optimization by inserting default arguments.
       if (call.argumentCount != signature.parameterCount) return null;
 
       // Replace with InvokeStatic.
       // The tear-off will be cleaned up by shrinking reductions.
-      return new InvokeStatic(target,
-          new Selector.fromElement(target),
-          node.arguments.toList(),
-          node.sourceInformation);
+      return new InvokeStatic(target, new Selector.fromElement(target),
+          node.arguments.toList(), node.sourceInformation);
     }
     if (tearOff is InvokeMethod && tearOff.selector.isGetter) {
       Selector getter = tearOff.selector;
 
       // TODO(asgerf): Support torn-off intercepted methods.
       if (isInterceptedSelector(getter)) return null;
 
       LetPrim tearOffBinding = tearOff.parent;
 
       Primitive object = tearOff.receiver;
@@ skipping 21 matching lines @@
       // therefore risk duplicating its side effects.
       if (!isPure && tearOff.hasMultipleRefinedUses) return null;
 
       // If the getter call is impure, we risk reordering side effects,
       // unless it is immediately prior to the closure call.
       if (!isPure && getEffectiveParent(node.parent) != tearOffBinding) {
         return null;
       }
 
       InvokeMethod invoke = new InvokeMethod(
-        object,
-        new Selector.call(getter.memberName, call.callStructure),
-        type,
-        node.arguments.toList(),
-        sourceInformation: node.sourceInformation);
-      node.receiverRef.changeTo(new Parameter(null)); // Remove the tear off use.
+          object,
+          new Selector.call(getter.memberName, call.callStructure),
+          type,
+          node.arguments.toList(),
+          sourceInformation: node.sourceInformation);
+      node.receiverRef
+          .changeTo(new Parameter(null)); // Remove the tear off use.
 
       if (tearOff.hasNoRefinedUses) {
         // Eliminate the getter call if it has no more uses.
         // This cannot be delegated to other optimizations because we need to
         // avoid duplication of side effects.
         destroyRefinementsOfDeadPrimitive(tearOff);
         tearOff.destroy();
         tearOffBinding.remove();
       } else {
         // There are more uses, so we cannot eliminate the getter call. This
@@ skipping 10 matching lines @@
   /// Inlines a single-use closure if it leaves the closure object with only
   /// field accesses.  This is optimized later by [ScalarReplacer].
   CpsFragment specializeSingleUseClosureCall(InvokeMethod node) {
     Selector call = node.selector;
     if (!call.isClosureCall) return null;
 
     assert(!isInterceptedSelector(call));
     assert(call.argumentCount == node.argumentRefs.length);
 
     Primitive receiver = node.receiver;
-    if (receiver is !CreateInstance) return null;
+    if (receiver is! CreateInstance) return null;
     CreateInstance createInstance = receiver;
     if (!createInstance.hasExactlyOneUse) return null;
 
     // Inline only closures. This avoids inlining the 'call' method of a class
     // that has many allocation sites.
-    if (createInstance.classElement is !ClosureClassElement) return null;
+    if (createInstance.classElement is! ClosureClassElement) return null;
 
     ClosureClassElement closureClassElement = createInstance.classElement;
     Element element = closureClassElement.localLookup(Identifiers.call);
 
     if (element == null || !element.isFunction) return null;
     FunctionElement functionElement = element;
     if (functionElement.asyncMarker != AsyncMarker.SYNC) return null;
 
     if (!call.signatureApplies(functionElement)) return null;
     // Inline only for exact match.
     // TODO(sra): Handle call with defaulted arguments.
     Selector targetSelector = new Selector.fromElement(functionElement);
     if (call.callStructure != targetSelector.callStructure) return null;
 
     // Don't inline if [target] contains try-catch or try-finally. JavaScript
     // engines typically do poor optimization of the entire function containing
     // the 'try'.
     if (functionElement.resolvedAst.elements.containsTryStatement) return null;
 
     FunctionDefinition target =
         functionCompiler.compileToCpsIr(functionElement);
 
     // Accesses to closed-over values are field access primitives.  We we don't
     // inline if there are other uses of 'this' since that could be an escape or
     // a recursive call.
     for (Reference ref = target.receiverParameter.firstRef;
-         ref != null;
-         ref = ref.next) {
+        ref != null;
+        ref = ref.next) {
       Node use = ref.parent;
       if (use is GetField) continue;
       // Closures do not currently have writable fields, but closure conversion
       // could esily be changed to allocate some cells in a closure object.
       if (use is SetField && ref == use.objectRef) continue;
       return null;
     }
 
     CpsFragment cps = new CpsFragment(node.sourceInformation);
-    Primitive returnValue = cps.inlineFunction(target,
-        node.receiver,
-        node.arguments.toList(),
+    Primitive returnValue = cps.inlineFunction(
+        target, node.receiver, node.arguments.toList(),
         hint: node.hint);
     node.replaceUsesWith(returnValue);
     return cps;
   }
 
   visitInterceptor(Interceptor node) {
     // Replace the interceptor with its input if the value is not intercepted.
     // If the input might be null, we cannot do this since the interceptor
     // might have to return JSNull.  That case is handled by visitInvokeMethod
     // and visitInvokeMethodDirectly which can sometimes tolerate that null
     // is used instead of JSNull.
     Primitive input = node.input;
     if (!input.type.isNullable &&
         typeSystem.areDisjoint(input.type, typeSystem.interceptorType)) {
       node.replaceUsesWith(input);
     }
   }
 
   visitInvokeConstructor(InvokeConstructor node) {
     node.effects =
         Effects.from(compiler.world.getSideEffectsOfElement(node.target));
   }
 
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     Element target = node.target;
     if (target is ConstructorBodyElement) {
       ConstructorBodyElement constructorBody = target;
       target = constructorBody.constructor;
     }
-    node.effects =
-        Effects.from(compiler.world.getSideEffectsOfElement(target));
+    node.effects = Effects.from(compiler.world.getSideEffectsOfElement(target));
     TypeMask receiverType = node.receiver.type;
     if (node.callingConvention == CallingConvention.Intercepted &&
         typeSystem.areDisjoint(receiverType, typeSystem.interceptorType)) {
       // Some direct calls take an interceptor because the target class is
       // mixed into a native class.  If it is known at the call site that the
       // receiver is non-intercepted, get rid of the interceptor.
       node.interceptorRef.changeTo(node.receiver);
     }
   }
 
   visitInvokeMethod(InvokeMethod node) {
-    var specialized =
-        specializeOperatorCall(node) ??
+    var specialized = specializeOperatorCall(node) ??
         specializeFieldAccess(node) ??
         specializeIndexableAccess(node) ??
         specializeArrayAccess(node) ??
         specializeSingleUseClosureCall(node) ??
         specializeClosureCall(node);
     if (specialized != null) return specialized;
 
     TypeMask receiverType = node.receiver.type;
     node.mask = typeSystem.intersection(node.mask, receiverType);
 
     node.effects = Effects.from(
         compiler.world.getSideEffectsOfSelector(node.selector, node.mask));
 
     bool canBeNonThrowingCallOnNull =
-        selectorsOnNull.contains(node.selector) &&
-        receiverType.isNullable;
+        selectorsOnNull.contains(node.selector) && receiverType.isNullable;
 
     if (node.callingConvention == CallingConvention.Intercepted &&
         !canBeNonThrowingCallOnNull &&
         typeSystem.areDisjoint(receiverType, typeSystem.interceptorType)) {
       // Use the Dart receiver as the JS receiver. This changes the wording of
       // the error message when the receiver is null, but we accept this.
       node.interceptorRef.changeTo(node.receiver);
 
       // Replace the extra receiver argument with a dummy value if the
       // target definitely does not use it.
-      if (typeSystem.targetIgnoresReceiverArgument(receiverType,
-            node.selector)) {
+      if (typeSystem.targetIgnoresReceiverArgument(
+          receiverType, node.selector)) {
         node.makeDummyIntercepted();
       }
     }
   }
 
   CpsFragment visitTypeCast(TypeCast node) {
     AbstractConstantValue value = getValue(node.value);
     switch (lattice.isSubtypeOf(value, node.dartType, allowNull: true)) {
       case AbstractBool.Maybe:
       case AbstractBool.Nothing:
@@ skipping 13 matching lines @@
 
   /// Specialize calls to internal static methods.
   specializeInternalMethodCall(InvokeStatic node) {
     if (node.target == backend.helpers.stringInterpolationHelper) {
       Primitive argument = node.argument(0);
       AbstractConstantValue value = getValue(argument);
       if (lattice.isDefinitelyString(value)) {
         node.replaceUsesWith(argument);
         return new CpsFragment();
       } else if (typeSystem.isDefinitelySelfInterceptor(value.type)) {
-        TypeMask toStringReturn = typeSystem.getInvokeReturnType(
-            Selectors.toString_, value.type);
+        TypeMask toStringReturn =
+            typeSystem.getInvokeReturnType(Selectors.toString_, value.type);
         if (typeSystem.isDefinitelyString(toStringReturn)) {
           CpsFragment cps = new CpsFragment(node.sourceInformation);
           Primitive invoke = cps.invokeMethod(
-              argument,
-              Selectors.toString_,
-              value.type,
-              [],
+              argument, Selectors.toString_, value.type, [],
               callingConvention: CallingConvention.DummyIntercepted);
           node.replaceUsesWith(invoke);
           return cps;
         }
       }
     } else if (node.target == compiler.identicalFunction) {
       if (node.argumentRefs.length == 2) {
         return new ApplyBuiltinOperator(BuiltinOperator.Identical,
-            [node.argument(0), node.argument(1)],
-            node.sourceInformation);
+            [node.argument(0), node.argument(1)], node.sourceInformation);
       }
     }
     return null;
   }
 
   visitInvokeStatic(InvokeStatic node) {
-    node.effects = Effects.from(
-        compiler.world.getSideEffectsOfElement(node.target));
+    node.effects =
+        Effects.from(compiler.world.getSideEffectsOfElement(node.target));
     return specializeInternalMethodCall(node);
   }
 
   AbstractConstantValue getValue(Variable node) {
     assert(node.type != null);
     ConstantValue constant = values[node];
     if (constant != null) {
       return new AbstractConstantValue.constantValue(constant, node.type);
     }
     return new AbstractConstantValue.nonConstant(node.type);
   }
 
-
   /*************************** PRIMITIVES **************************/
   //
   // The visit method for a primitive may return one of the following:
   // - Primitive:
   //     The visited primitive will be replaced by the returned primitive.
   //     The type of the primitive will be recomputed.
   // - CpsFragment:
   //     The primitive binding will be destroyed and replaced by the given
   //     code fragment.  All types in the fragment will be recomputed.
   // - Null:
@@ skipping 10 matching lines @@
         // Concatenate consecutive constants.
         bool argumentsWereRemoved = false;
         int i = 0;
         while (i < node.argumentRefs.length - 1) {
           int startOfSequence = i;
           AbstractConstantValue firstValue = getValue(node.argument(i++));
           if (!firstValue.isConstant) continue;
           AbstractConstantValue secondValue = getValue(node.argument(i++));
           if (!secondValue.isConstant) continue;
 
-          ast.DartString string =
-              new ast.ConsDartString(getString(firstValue),
-                                     getString(secondValue));
+          ast.DartString string = new ast.ConsDartString(
+              getString(firstValue), getString(secondValue));
 
           // We found a sequence of at least two constants.
           // Look for the end of the sequence.
           while (i < node.argumentRefs.length) {
             AbstractConstantValue value = getValue(node.argument(i));
             if (!value.isConstant) break;
             string = new ast.ConsDartString(string, getString(value));
             ++i;
           }
           Constant prim =
@@ skipping 27 matching lines @@
         BuiltinOperator newOperator;
         if (left.isNullConstant || right.isNullConstant) {
           // Use `==` for comparing against null, so JS undefined and JS null
           // are considered equal.
           newOperator = BuiltinOperator.LooseEq;
         } else if (!left.isNullable || !right.isNullable) {
           // If at most one operand can be Dart null, we can use `===`.
           // This is not safe when we might compare JS null and JS undefined.
           newOperator = BuiltinOperator.StrictEq;
         } else if (lattice.isDefinitelyNum(left, allowNull: true) &&
-                   lattice.isDefinitelyNum(right, allowNull: true)) {
+            lattice.isDefinitelyNum(right, allowNull: true)) {
           // If both operands can be null, but otherwise are of the same type,
           // we can use `==` for comparison.
           // This is not safe e.g. for comparing strings against numbers.
           newOperator = BuiltinOperator.LooseEq;
         } else if (lattice.isDefinitelyString(left, allowNull: true) &&
-                   lattice.isDefinitelyString(right, allowNull: true)) {
+            lattice.isDefinitelyString(right, allowNull: true)) {
           newOperator = BuiltinOperator.LooseEq;
         } else if (lattice.isDefinitelyBool(left, allowNull: true) &&
-                   lattice.isDefinitelyBool(right, allowNull: true)) {
+            lattice.isDefinitelyBool(right, allowNull: true)) {
           newOperator = BuiltinOperator.LooseEq;
         }
         if (newOperator != null) {
-          return new ApplyBuiltinOperator(newOperator,
-              node.arguments.toList(),
-              node.sourceInformation);
+          return new ApplyBuiltinOperator(
+              newOperator, node.arguments.toList(), node.sourceInformation);
         }
         break;
 
       case BuiltinOperator.StrictEq:
       case BuiltinOperator.LooseEq:
       case BuiltinOperator.StrictNeq:
       case BuiltinOperator.LooseNeq:
-        bool negated =
-            node.operator == BuiltinOperator.StrictNeq ||
+        bool negated = node.operator == BuiltinOperator.StrictNeq ||
             node.operator == BuiltinOperator.LooseNeq;
         for (int firstIndex in [0, 1]) {
           int secondIndex = 1 - firstIndex;
           Primitive firstArg = node.argument(firstIndex);
           Primitive secondArg = node.argument(secondIndex);
           AbstractConstantValue first = getValue(firstArg);
           if (!lattice.isDefinitelyBool(first)) continue;
           AbstractConstantValue second = getValue(secondArg);
           if (!second.isConstant || !second.constant.isBool) continue;
           bool isTrueConstant = second.constant.isTrue;
           if (isTrueConstant == !negated) {
             // (x === true) ==> x
             // (x !== false) ==> x
             node.replaceUsesWith(firstArg);
             return null;
           } else {
             // (x === false) ==> !x
             // (x !== true) ==> !x
             return new ApplyBuiltinOperator(
-                BuiltinOperator.IsFalsy,
-                [firstArg],
-                node.sourceInformation);
+                BuiltinOperator.IsFalsy, [firstArg], node.sourceInformation);
           }
         }
         break;
 
       default:
     }
     return null;
   }
 
-  void visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
-  }
+  void visitApplyBuiltinMethod(ApplyBuiltinMethod node) {}
 
   visitTypeTest(TypeTest node) {
     Primitive prim = node.value;
 
     Primitive unaryBuiltinOperator(BuiltinOperator operator) =>
         new ApplyBuiltinOperator(
             operator, <Primitive>[prim], node.sourceInformation);
 
     AbstractConstantValue value = getValue(prim);
     types.DartType dartType = node.dartType;
 
     if (!(dartType.isInterfaceType && dartType.isRaw)) {
       // TODO(23685): Efficient function arity check.
       // TODO(sra): Pass interceptor to runtime subtype functions.
       return null;
     }
 
     if (dartType == dartTypes.coreTypes.intType) {
       // Compile as typeof x === 'number' && Math.floor(x) === x
       if (lattice.isDefinitelyNum(value, allowNull: true)) {
         // If value is null or a number, we can skip the typeof test.
-        return new ApplyBuiltinOperator(
-            BuiltinOperator.IsFloor,
-            <Primitive>[prim, prim],
-            node.sourceInformation);
+        return new ApplyBuiltinOperator(BuiltinOperator.IsFloor,
+            <Primitive>[prim, prim], node.sourceInformation);
       }
       if (lattice.isDefinitelyNotNonIntegerDouble(value)) {
         // If the value cannot be a non-integer double, but might not be a
         // number at all, we can skip the Math.floor test.
         return unaryBuiltinOperator(BuiltinOperator.IsNumber);
       }
-      return new ApplyBuiltinOperator(
-          BuiltinOperator.IsInteger,
-          <Primitive>[prim, prim, prim],
-          node.sourceInformation);
+      return new ApplyBuiltinOperator(BuiltinOperator.IsInteger,
+          <Primitive>[prim, prim, prim], node.sourceInformation);
     }
     if (node.dartType == dartTypes.coreTypes.numType ||
         node.dartType == dartTypes.coreTypes.doubleType) {
       return new ApplyBuiltinOperator(
-          BuiltinOperator.IsNumber,
-          <Primitive>[prim],
-          node.sourceInformation);
+          BuiltinOperator.IsNumber, <Primitive>[prim], node.sourceInformation);
     }
 
     AbstractBool isNullableSubtype =
         lattice.isSubtypeOf(value, node.dartType, allowNull: true);
     AbstractBool isNullPassingTest =
         lattice.isSubtypeOf(lattice.nullValue, node.dartType, allowNull: false);
     if (isNullableSubtype == AbstractBool.True &&
         isNullPassingTest == AbstractBool.False) {
       // Null is the only value not satisfying the type test.
       // Replace the type test with a null-check.
       // This has lower priority than the 'typeof'-based tests because
       // 'typeof' expressions might give the VM some more useful information.
       Primitive nullConst = makeConstantPrimitive(new NullConstantValue());
       new LetPrim(nullConst).insertAbove(node.parent);
-      return new ApplyBuiltinOperator(
-          BuiltinOperator.LooseNeq,
-          <Primitive>[prim, nullConst],
-          node.sourceInformation);
+      return new ApplyBuiltinOperator(BuiltinOperator.LooseNeq,
+          <Primitive>[prim, nullConst], node.sourceInformation);
     }
 
     if (dartType.element == functionCompiler.glue.jsFixedArrayClass) {
       // TODO(sra): Check input is restricted to JSArray.
       return unaryBuiltinOperator(BuiltinOperator.IsFixedLengthJSArray);
     }
 
     if (dartType.element == functionCompiler.glue.jsExtendableArrayClass) {
       // TODO(sra): Check input is restricted to JSArray.
       return unaryBuiltinOperator(BuiltinOperator.IsExtendableJSArray);
@@ skipping 30 matching lines @@
     return null;
   }
 
   visitBoundsCheck(BoundsCheck node) {
     // Eliminate bounds checks using constant folding.
     // The [BoundsChecker] pass does not try to eliminate checks that could be
     // eliminated by constant folding.
     if (node.hasNoChecks) return;
     Primitive indexPrim = node.index;
     int index = lattice.intValue(getValue(indexPrim));
-    int length = node.lengthRef == null
-        ? null
-        : lattice.intValue(getValue(node.length));
+    int length =
+        node.lengthRef == null ? null : lattice.intValue(getValue(node.length));
     if (index != null && length != null && index < length) {
       node.checks &= ~BoundsCheck.UPPER_BOUND;
     }
     if (index != null && index >= 0) {
       node.checks &= ~BoundsCheck.LOWER_BOUND;
     }
     if (length != null && length > 0) {
       node.checks &= ~BoundsCheck.EMPTINESS;
     }
     if (typeSystem.isDefinitelyInt(indexPrim.type)) {
       node.checks &= ~BoundsCheck.INTEGER;
     }
     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.
       // TODO(asgerf): Since this was eliminated by constant folding, it should
       //     be safe to remove because any path-sensitive information we relied
       //     upon to do this are expressed by other refinement nodes that also
       //     restrict code motion.  However, if we want to run this pass after
       //     [BoundsChecker] that would not be safe any more, so for now we
       //     keep the node for forward compatibilty.
-      node..indexRef.unlink()..indexRef = null;
+      node
+        ..indexRef.unlink()
+        ..indexRef = null;
     }
   }
 
   visitReceiverCheck(ReceiverCheck node) {
     Primitive input = node.value;
     if (!input.type.isNullable &&
         (node.isNullCheck ||
-         !input.type.needsNoSuchMethodHandling(node.selector, classWorld))) {
+            !input.type.needsNoSuchMethodHandling(node.selector, classWorld))) {
       node.replaceUsesWith(input);
       return new CpsFragment();
     }
     return null;
   }
 
   visitGetLength(GetLength node) {
-    node.isFinal = typeSystem.isDefinitelyFixedLengthIndexable(
-        node.object.type, allowNull: true);
+    node.isFinal = typeSystem.isDefinitelyFixedLengthIndexable(node.object.type,
+        allowNull: true);
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     // Pattern match on
     //
     //    ReadTypeVariable(var, CreateInstance(..., TypeExpression(arguments)))
     //
     // and extract the argument that corresponds to the type variable. This is a
     // shrinking reduction.
     //
@@ skipping 26 matching lines @@
     }
     return null;
   }
 
   bool isNullConstant(Primitive prim) => prim is Constant && prim.value.isNull;
 
   visitCreateInstance(CreateInstance node) {
     Primitive typeInformation = node.typeInformation;
     if (typeInformation is TypeExpression &&
         typeInformation.arguments.every(isNullConstant)) {
-      node..typeInformationRef.unlink()..typeInformationRef = null;
+      node
+        ..typeInformationRef.unlink()
+        ..typeInformationRef = null;
     }
   }
 }
 
 /**
  * Runs an analysis pass on the given function definition in order to detect
  * const-ness as well as reachability, both of which are used in the subsequent
  * transformation pass.
  */
 class TypePropagationVisitor implements Visitor {
@@ skipping 31 matching lines @@
   }
 
   AbstractConstantValue constantValue(ConstantValue constant, [TypeMask type]) {
     return lattice.constant(constant, type);
   }
 
   // Stores the current lattice value for primitives and mutable variables.
   // Access through [getValue] and [setValue].
   final Map<Variable, ConstantValue> values;
 
-  TypePropagationVisitor(this.lattice,
-                         this.values,
-                         this.internalError);
+  TypePropagationVisitor(this.lattice, this.values, this.internalError);
 
   void analyze(FunctionDefinition root, bool recomputeAll) {
     reachableContinuations.clear();
     if (recomputeAll) {
       new ResetAnalysisInfo(reachableContinuations, values).visit(root);
     }
 
     // Initially, only the root node is reachable.
     push(root);
 
@@ skipping 16 matching lines @@
         // Process all usages of a changed definition.
         Definition def = defWorklist.removeLast();
 
         // Visit all uses of this definition. This might add new entries to
         // [nodeWorklist], for example by visiting a newly-constant usage within
         // a branch node.
         for (Reference ref = def.firstRef; ref != null; ref = ref.next) {
           visit(ref.parent);
         }
       } else {
-        break;  // Both worklists empty.
+        break; // Both worklists empty.
       }
     }
   }
 
   /// Adds [node] to the worklist.
   void push(Node node) {
     nodeWorklist.add(node);
   }
 
   /// If the passed node is not yet reachable, mark it reachable and add it
@@ skipping 33 matching lines @@
     assert(newValue.kind >= oldValue.kind);
 
     values[node] = newValue.isConstant ? newValue.constant : null;
     defWorklist.add(node);
   }
 
   /// Sets the type of the given primitive.
   ///
   /// If [updateValue] is a constant and [canReplace] is true, the primitive
   /// is also marked as safe for elimination, so it can be constant-folded.
-  void setResult(UnsafePrimitive prim,
-                 AbstractConstantValue updateValue,
-                 {bool canReplace: false}) {
+  void setResult(UnsafePrimitive prim, AbstractConstantValue updateValue,
+      {bool canReplace: false}) {
     // TODO(asgerf): Separate constant folding from side effect analysis.
     setValue(prim, updateValue);
     prim.isSafeForElimination = canReplace && updateValue.isConstant;
   }
 
   bool isInterceptedSelector(Selector selector) {
     return backend.isInterceptedSelector(selector);
   }
 
   // -------------------------- Visitor overrides ------------------------------
-  void visit(Node node) { node.accept(this); }
+  void visit(Node node) {
+    node.accept(this);
+  }
 
   void visitFunctionDefinition(FunctionDefinition node) {
     if (node.interceptorParameter != null) {
       setValue(node.interceptorParameter, nonConstant(typeSystem.nonNullType));
     }
     // If the abstract value of the function parameters is Nothing, use the
     // inferred parameter type.  Otherwise (e.g., when inlining) do not
     // change the abstract value.
     if (node.receiverParameter != null &&
         getValue(node.receiverParameter).isNothing) {
       setValue(node.receiverParameter,
           nonConstant(typeSystem.getReceiverType(node.element)));
     }
     bool hasParameterWithoutValue = false;
     for (Parameter param in node.parameters) {
       if (getValue(param).isNothing) {
         TypeMask type = param.hint is ParameterElement
             ? typeSystem.getParameterType(param.hint)
             : typeSystem.dynamicType;
         setValue(param, lattice.fromMask(type));
         if (type.isEmpty) hasParameterWithoutValue = true;
       }
     }
-    if (!hasParameterWithoutValue) { // Don't analyze unreachable code.
+    if (!hasParameterWithoutValue) {
+      // Don't analyze unreachable code.
       push(node.body);
     }
   }
 
   void visitLetPrim(LetPrim node) {
     visit(node.primitive); // No reason to delay visits to primitives.
     push(node.body);
   }
 
   void visitLetCont(LetCont node) {
@@ skipping 106 matching lines @@
       AbstractConstantValue right = getValue(node.argument(0));
       BinaryOperator operator = BinaryOperator.parse(opname);
       AbstractConstantValue result =
           lattice.binaryOp(operator, receiver, right);
       return finish(result, canReplace: !receiver.isNullable);
     }
     return finish(null);
   }
 
   void visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
-
     void unaryOp(
         AbstractConstantValue operation(AbstractConstantValue argument),
         TypeMask defaultType) {
       AbstractConstantValue value = getValue(node.argument(0));
       setValue(node, operation(value) ?? nonConstant(defaultType));
     }
 
     void binaryOp(
-        AbstractConstantValue operation(AbstractConstantValue left,
-                                        AbstractConstantValue right),
+        AbstractConstantValue operation(
+            AbstractConstantValue left, AbstractConstantValue right),
         TypeMask defaultType) {
       AbstractConstantValue left = getValue(node.argument(0));
       AbstractConstantValue right = getValue(node.argument(1));
       setValue(node, operation(left, right) ?? nonConstant(defaultType));
     }
 
     void binaryNumOp(
-        AbstractConstantValue operation(AbstractConstantValue left,
-                                        AbstractConstantValue right)) {
+        AbstractConstantValue operation(
+            AbstractConstantValue left, AbstractConstantValue right)) {
       binaryOp(operation, typeSystem.numType);
     }
 
     void binaryUint32Op(
-        AbstractConstantValue operation(AbstractConstantValue left,
-                                        AbstractConstantValue right)) {
+        AbstractConstantValue operation(
+            AbstractConstantValue left, AbstractConstantValue right)) {
       binaryOp(operation, typeSystem.uint32Type);
     }
 
     void binaryBoolOp(
-        AbstractConstantValue operation(AbstractConstantValue left,
-                                        AbstractConstantValue right)) {
+        AbstractConstantValue operation(
+            AbstractConstantValue left, AbstractConstantValue right)) {
       binaryOp(operation, typeSystem.boolType);
     }
 
     switch (node.operator) {
       case BuiltinOperator.StringConcatenate:
         ast.DartString stringValue = const ast.LiteralDartString('');
         for (Reference<Primitive> arg in node.argumentRefs) {
           AbstractConstantValue value = getValue(arg.definition);
           if (value.isNothing) {
             setValue(node, lattice.nothing);
             return; // And come back later
           } else if (value.isConstant &&
-                     value.constant.isString &&
-                     stringValue != null) {
+              value.constant.isString &&
+              stringValue != null) {
             StringConstantValue constant = value.constant;
             stringValue =
                 new ast.ConsDartString(stringValue, constant.primitiveValue);
           } else {
             stringValue = null;
             break;
           }
         }
         if (stringValue == null) {
           setValue(node, nonConstant(typeSystem.stringType));
         } else {
           setValue(node, constantValue(new StringConstantValue(stringValue)));
         }
         break;
 
       case BuiltinOperator.CharCodeAt:
         binaryOp(lattice.codeUnitAtSpecial, typeSystem.uint31Type);
         break;
 
       case BuiltinOperator.Identical:
       case BuiltinOperator.StrictEq:
       case BuiltinOperator.StrictNeq:
       case BuiltinOperator.LooseEq:
       case BuiltinOperator.LooseNeq:
-        bool negated =
-            node.operator == BuiltinOperator.StrictNeq ||
+        bool negated = node.operator == BuiltinOperator.StrictNeq ||
             node.operator == BuiltinOperator.LooseNeq;
         AbstractConstantValue left = getValue(node.argument(0));
         AbstractConstantValue right = getValue(node.argument(1));
         if (left.isNothing || right.isNothing) {
           setValue(node, lattice.nothing);
           return;
         }
         if (left.isConstant && right.isConstant) {
-          ConstantValue equal = lattice.constantSystem.identity.fold(
-              left.constant, right.constant);
+          ConstantValue equal = lattice.constantSystem.identity
+              .fold(left.constant, right.constant);
           if (equal != null && equal.isBool) {
             ConstantValue result =
                 new BoolConstantValue(equal.isTrue == !negated);
             setValue(node, constantValue(result, typeSystem.boolType));
             return;
           }
         }
         if (typeSystem.areDisjoint(left.type, right.type)) {
           ConstantValue result = new BoolConstantValue(negated);
           setValue(node, constantValue(result, typeSystem.boolType));
@@ skipping 88 matching lines @@
       case BuiltinOperator.IsUnmodifiableJSArray:
       case BuiltinOperator.IsModifiableJSArray:
         setValue(node, nonConstant(typeSystem.boolType));
         break;
     }
   }
 
   void visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     AbstractConstantValue receiver = getValue(node.receiver);
     if (node.method == BuiltinMethod.Pop) {
-      setValue(node, nonConstant(
-          typeSystem.elementTypeOfIndexable(receiver.type)));
+      setValue(
+          node, nonConstant(typeSystem.elementTypeOfIndexable(receiver.type)));
     } else {
       setValue(node, nonConstant());
     }
   }
 
   void visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (node.isConstructorBodyCall) {
       setResult(node, lattice.nullValue);
     } else if (node.isTearOff) {
       setResult(node, nonConstant(typeSystem.functionType));
     } else {
       setResult(node, nonConstant(typeSystem.getReturnType(node.target)));
     }
   }
 
   void visitInvokeConstructor(InvokeConstructor node) {
     if (node.allocationSiteType != null) {
       setResult(node, nonConstant(node.allocationSiteType));
     } else {
       setResult(node, nonConstant(typeSystem.getReturnType(node.target)));
     }
   }
 
-  void visitThrow(Throw node) {
-  }
+  void visitThrow(Throw node) {}
 
-  void visitRethrow(Rethrow node) {
-  }
+  void visitRethrow(Rethrow node) {}
 
-  void visitUnreachable(Unreachable node) {
-  }
+  void visitUnreachable(Unreachable node) {}
 
   void visitBranch(Branch node) {
     AbstractConstantValue conditionCell = getValue(node.condition);
     AbstractBool boolifiedValue = node.isStrictCheck
         ? lattice.strictBoolify(conditionCell)
         : lattice.boolify(conditionCell);
     switch (boolifiedValue) {
       case AbstractBool.Nothing:
         break;
       case AbstractBool.True:
@@ skipping 17 matching lines @@
     // TODO(sra): We could see if we can find the value in the interceptor
     // expression. It would probably have no benefit - we only see
     // TypeTestViaFlag after rewriting TypeTest and the rewrite of TypeTest
     // would already have done the interesting optimizations.
     setValue(node, nonConstant(typeSystem.boolType));
   }
 
   void handleTypeTest(
       Primitive node, AbstractConstantValue input, types.DartType dartType) {
     TypeMask boolType = typeSystem.boolType;
-    switch(lattice.isSubtypeOf(input, dartType, allowNull: false)) {
+    switch (lattice.isSubtypeOf(input, dartType, allowNull: false)) {
       case AbstractBool.Nothing:
         break; // And come back later.
 
       case AbstractBool.True:
         setValue(node, constantValue(new TrueConstantValue(), boolType));
         break;
 
       case AbstractBool.False:
         setValue(node, constantValue(new FalseConstantValue(), boolType));
         break;
@@ skipping 15 matching lines @@
         setValue(node, input);
         break;
 
       case AbstractBool.False:
         setValue(node, lattice.nothing); // Cast fails.
         break;
 
       case AbstractBool.Maybe:
         // Narrow type of output to those that survive the cast.
         TypeMask type = input.type.intersection(
-            typeSystem.subtypesOf(node.dartType).nullable(),
-            classWorld);
+            typeSystem.subtypesOf(node.dartType).nullable(), classWorld);
         setValue(node, nonConstant(type));
         break;
     }
   }
 
   void visitSetMutable(SetMutable node) {
     setValue(node.variable, getValue(node.value));
   }
 
   void visitLiteralList(LiteralList node) {
@@ skipping 11 matching lines @@
       setValue(node, nonConstant(typeSystem.getTypeOf(value)));
     } else {
       setValue(node, constantValue(value, typeSystem.getTypeOf(value)));
     }
   }
 
   void visitGetMutable(GetMutable node) {
     setValue(node, getValue(node.variable));
   }
 
-  void visitMutableVariable(MutableVariable node) {
-  }
+  void visitMutableVariable(MutableVariable node) {}
 
-  void visitParameter(Parameter node) {
-  }
+  void visitParameter(Parameter node) {}
 
   void visitContinuation(Continuation node) {
     node.parameters.forEach(visit);
 
     if (node.body != null) {
       push(node.body);
     }
   }
 
   void visitGetStatic(GetStatic node) {
@@ skipping 75 matching lines @@
 
   void visitCreateInvocationMirror(CreateInvocationMirror node) {
     // TODO(asgerf): Expose [Invocation] type.
     setValue(node, nonConstant(typeSystem.nonNullType));
   }
 
   @override
   void visitForeignCode(ForeignCode node) {
     bool firstArgumentIsNullable = false;
     if (node.argumentRefs.length > 0) {
-      AbstractConstantValue first = getValue(node.argumentRefs.first.definition);
+      AbstractConstantValue first =
+          getValue(node.argumentRefs.first.definition);
       if (first.isNothing) {
         setValue(node, nothing);
         return;
       }
       firstArgumentIsNullable = first.isNullable;
     }
     setValue(node, nonConstant(node.storedType));
     node.isSafeForElimination =
         !node.nativeBehavior.sideEffects.hasSideEffects() &&
-        (!node.nativeBehavior.throwBehavior.canThrow ||
-         (!firstArgumentIsNullable &&
-          node.nativeBehavior.throwBehavior.isOnlyNullNSMGuard));
+            (!node.nativeBehavior.throwBehavior.canThrow ||
+                (!firstArgumentIsNullable &&
+                    node.nativeBehavior.throwBehavior.isOnlyNullNSMGuard));
   }
 
   @override
   void visitGetLength(GetLength node) {
     AbstractConstantValue input = getValue(node.object);
     node.objectIsNotNull = input.isDefinitelyNotNull;
     AbstractConstantValue length = lattice.lengthSpecial(input);
     if (length != null) {
       // TODO(asgerf): Constant-folding the length might degrade the VM's
       // own bounds-check elimination?
       setValue(node, length);
     } else {
       setValue(node, nonConstant(typeSystem.uint32Type));
     }
   }
 
   @override
   void visitGetIndex(GetIndex node) {
     AbstractConstantValue object = getValue(node.object);
     if (object.isNothing || object.isNullConstant) {
       setValue(node, nothing);
     } else {
       node.objectIsNotNull = object.isDefinitelyNotNull;
-      setValue(node, nonConstant(typeSystem.elementTypeOfIndexable(object.type)));
+      setValue(
+          node, nonConstant(typeSystem.elementTypeOfIndexable(object.type)));
     }
   }
 
   @override
   void visitSetIndex(SetIndex node) {}
 
   @override
   void visitAwait(Await node) {
     setResult(node, nonConstant());
   }
 
   @override
   visitYield(Yield node) {
     setValue(node, nonConstant());
   }
 
   @override
   void visitRefinement(Refinement node) {
-    setValue(node, lattice.intersectWithType(
-        getValue(node.value.definition),
-        node.refineType));
+    setValue(
+        node,
+        lattice.intersectWithType(
+            getValue(node.value.definition), node.refineType));
   }
 
   @override
   void visitBoundsCheck(BoundsCheck node) {
     setValue(node, getValue(node.object));
   }
 
   @override
   void visitReceiverCheck(ReceiverCheck node) {
     AbstractConstantValue value = getValue(node.value);
@@ skipping 14 matching lines @@
 /// Represents the abstract value of a primitive value at some point in the
 /// program. Abstract values of all kinds have a type [T].
 ///
 /// The different kinds of abstract values represents the knowledge about the
 /// constness of the value:
 ///   NOTHING:  cannot have any value
 ///   CONSTANT: is a constant. The value is stored in the [constant] field,
 ///             and the type of the constant is in the [type] field.
 ///   NONCONST: not a constant, but [type] may hold some information.
 class AbstractConstantValue {
-  static const int NOTHING  = 0;
+  static const int NOTHING = 0;
   static const int CONSTANT = 1;
   static const int NONCONST = 2;
 
   final int kind;
   final ConstantValue constant;
   final TypeMask type;
 
   AbstractConstantValue._internal(this.kind, this.constant, this.type) {
     assert(kind != CONSTANT || constant != null);
     assert(constant is! SyntheticConstantValue);
   }
 
   AbstractConstantValue.nothing()
       : this._internal(NOTHING, null, new TypeMask.nonNullEmpty());
 
   AbstractConstantValue.constantValue(ConstantValue constant, TypeMask type)
       : this._internal(CONSTANT, constant, type);
 
   factory AbstractConstantValue.nonConstant(TypeMask type) {
     if (type.isEmpty) {
       return new AbstractConstantValue.nothing();
     } else if (type.isNull) {
       return new AbstractConstantValue.constantValue(
           new NullConstantValue(), type);
     } else {
       return new AbstractConstantValue._internal(NONCONST, null, type);
     }
   }
 
-  bool get isNothing  => (kind == NOTHING);
+  bool get isNothing => (kind == NOTHING);
   bool get isConstant => (kind == CONSTANT);
   bool get isNonConst => (kind == NONCONST);
   bool get isNullConstant => kind == CONSTANT && constant.isNull;
   bool get isTrueConstant => kind == CONSTANT && constant.isTrue;
   bool get isFalseConstant => kind == CONSTANT && constant.isFalse;
   bool get isZeroConstant => kind == CONSTANT && constant.isZero;
   bool get isZeroOrNegativeConstant {
     if (kind != CONSTANT || !constant.isNum) return false;
     PrimitiveConstantValue value = constant;
     return value.primitiveValue <= 0;
   }
+
   bool get isNegativeConstant {
     if (kind != CONSTANT || !constant.isNum) return false;
     PrimitiveConstantValue value = constant;
     return value.primitiveValue < 0;
   }
 
   bool get isNullable => kind != NOTHING && type.isNullable;
   bool get isDefinitelyNotNull => kind == NOTHING || !type.isNullable;
 
   int get hashCode {
     int hash = kind * 31 + constant.hashCode * 59 + type.hashCode * 67;
     return hash & 0x3fffffff;
   }
 
   bool operator ==(AbstractConstantValue that) {
     return that.kind == this.kind &&
-           that.constant == this.constant &&
-           that.type == this.type;
+        that.constant == this.constant &&
+        that.type == this.type;
   }
 
   String toString() {
     switch (kind) {
-      case NOTHING: return "Nothing";
-      case CONSTANT: return "Constant: ${constant.unparse()}: $type";
-      case NONCONST: return "Non-constant: $type";
-      default: assert(false);
+      case NOTHING:
+        return "Nothing";
+      case CONSTANT:
+        return "Constant: ${constant.unparse()}: $type";
+      case NONCONST:
+        return "Non-constant: $type";
+      default:
+        assert(false);
     }
     return null;
   }
 }
 
 /// Suggested name for a synthesized loop index.
 class LoopIndexEntity extends Entity {
   String get name => 'i';
 }
 
@@ skipping 116 matching lines @@
   }
 
   Primitive makeCheck(CpsFragment cps, Primitive value) {
     return cps.applyBuiltin(negatedOperator, [value]);
   }
 
   Primitive makeRefinement(CpsFragment cps, Primitive value, World world) {
     return cps.refine(value, new TypeMask.nonNullSubclass(classElement, world));
   }
 }