dartfmt pkg/compiler

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, 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.
 
-import '../common/codegen.dart' show
-    CodegenRegistry,
-    CodegenWorkItem;
-import '../common/tasks.dart' show
-    CompilerTask;
-import '../compiler.dart' show
-    Compiler;
+import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
+import '../common/tasks.dart' show CompilerTask;
+import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show
-    CoreClasses;
+import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js/js.dart' as js;
-import '../js_backend/backend_helpers.dart' show
-    BackendHelpers;
+import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../native/native.dart' as native;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
-import '../universe/selector.dart' show
-    Selector;
-import '../universe/side_effects.dart' show
-    SideEffects;
+import '../universe/selector.dart' show Selector;
+import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
-import '../world.dart' show
-    ClassWorld,
-    World;
+import '../world.dart' show ClassWorld, World;
 
 import 'nodes.dart';
 import 'types_propagation.dart';
 import 'types.dart';
 import 'value_range_analyzer.dart';
 import 'value_set.dart';
 import 'interceptor_simplifier.dart';
 
 abstract class OptimizationPhase {
   String get name;
@@ skipping 14 matching lines @@
       measureSubtask(phase.name, () => phase.visitGraph(graph));
       compiler.tracer.traceGraph(phase.name, graph);
       assert(graph.isValid());
     }
 
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     bool trustPrimitives = compiler.options.trustPrimitives;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
-          // Run trivial instruction simplification first to optimize
-          // some patterns useful for type conversion.
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
-          new SsaTypeConversionInserter(compiler),
-          new SsaRedundantPhiEliminator(),
-          new SsaDeadPhiEliminator(),
-          new SsaTypePropagator(compiler),
-          // After type propagation, more instructions can be
-          // simplified.
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
-          new SsaCheckInserter(
-              trustPrimitives, backend, work, context.boundsChecked),
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
-          new SsaCheckInserter(
-              trustPrimitives, backend, work, context.boundsChecked),
-          new SsaTypePropagator(compiler),
-          // Run a dead code eliminator before LICM because dead
-          // interceptors are often in the way of LICM'able instructions.
-          new SsaDeadCodeEliminator(compiler, this),
-          new SsaGlobalValueNumberer(compiler),
-          // After GVN, some instructions might need their type to be
-          // updated because they now have different inputs.
-          new SsaTypePropagator(compiler),
-          new SsaCodeMotion(),
-          new SsaLoadElimination(compiler),
-          new SsaRedundantPhiEliminator(),
-          new SsaDeadPhiEliminator(),
-          new SsaTypePropagator(compiler),
-          new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
-          // Previous optimizations may have generated new
-          // opportunities for instruction simplification.
-          new SsaInstructionSimplifier(constantSystem, backend, this, work),
-          new SsaCheckInserter(
-              trustPrimitives, backend, work, context.boundsChecked),
+        // Run trivial instruction simplification first to optimize
+        // some patterns useful for type conversion.
+        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaTypeConversionInserter(compiler),
+        new SsaRedundantPhiEliminator(),
+        new SsaDeadPhiEliminator(),
+        new SsaTypePropagator(compiler),
+        // After type propagation, more instructions can be
+        // simplified.
+        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaCheckInserter(
+            trustPrimitives, backend, work, context.boundsChecked),
+        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaCheckInserter(
+            trustPrimitives, backend, work, context.boundsChecked),
+        new SsaTypePropagator(compiler),
+        // Run a dead code eliminator before LICM because dead
+        // interceptors are often in the way of LICM'able instructions.
+        new SsaDeadCodeEliminator(compiler, this),
+        new SsaGlobalValueNumberer(compiler),
+        // After GVN, some instructions might need their type to be
+        // updated because they now have different inputs.
+        new SsaTypePropagator(compiler),
+        new SsaCodeMotion(),
+        new SsaLoadElimination(compiler),
+        new SsaRedundantPhiEliminator(),
+        new SsaDeadPhiEliminator(),
+        new SsaTypePropagator(compiler),
+        new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
+        // Previous optimizations may have generated new
+        // opportunities for instruction simplification.
+        new SsaInstructionSimplifier(constantSystem, backend, this, work),
+        new SsaCheckInserter(
+            trustPrimitives, backend, work, context.boundsChecked),
       ];
       phases.forEach(runPhase);
 
       // Simplifying interceptors is not strictly just an optimization, it is
       // required for implementation correctness because the code generator
       // assumes it is always performed.
       runPhase(new SsaSimplifyInterceptors(compiler, constantSystem, work));
 
       SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(compiler, this);
       runPhase(dce);
       if (dce.eliminatedSideEffects) {
         phases = <OptimizationPhase>[
-            new SsaTypePropagator(compiler),
-            new SsaGlobalValueNumberer(compiler),
-            new SsaCodeMotion(),
-            new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
-            new SsaInstructionSimplifier(constantSystem, backend, this, work),
-            new SsaCheckInserter(
-                trustPrimitives, backend, work, context.boundsChecked),
-            new SsaSimplifyInterceptors(compiler, constantSystem, work),
-            new SsaDeadCodeEliminator(compiler, this),
+          new SsaTypePropagator(compiler),
+          new SsaGlobalValueNumberer(compiler),
+          new SsaCodeMotion(),
+          new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
+          new SsaCheckInserter(
+              trustPrimitives, backend, work, context.boundsChecked),
+          new SsaSimplifyInterceptors(compiler, constantSystem, work),
+          new SsaDeadCodeEliminator(compiler, this),
         ];
       } else {
         phases = <OptimizationPhase>[
-            new SsaTypePropagator(compiler),
-            // Run the simplifier to remove unneeded type checks inserted by
-            // type propagation.
-            new SsaInstructionSimplifier(constantSystem, backend, this, work),
+          new SsaTypePropagator(compiler),
+          // Run the simplifier to remove unneeded type checks inserted by
+          // type propagation.
+          new SsaInstructionSimplifier(constantSystem, backend, this, work),
         ];
       }
       phases.forEach(runPhase);
     });
   }
 }
 
 /// Returns `true` if [mask] represents only types that have a length that
 /// cannot change.  The current implementation is conservative for the purpose
 /// of identifying gvn-able lengths and mis-identifies some unions of fixed
@@ skipping 14 matching lines @@
   }
   return false;
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaInstructionSimplifier extends HBaseVisitor
     implements OptimizationPhase {
-
   // We don't produce constant-folded strings longer than this unless they have
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
   final JavaScriptBackend backend;
   final CodegenWorkItem work;
   final ConstantSystem constantSystem;
   HGraph graph;
   Compiler get compiler => backend.compiler;
   final SsaOptimizerTask optimizer;
 
-  SsaInstructionSimplifier(this.constantSystem,
-                           this.backend,
-                           this.optimizer,
-                           this.work);
+  SsaInstructionSimplifier(
+      this.constantSystem, this.backend, this.optimizer, this.work);
 
   CoreClasses get coreClasses => compiler.coreClasses;
 
   BackendHelpers get helpers => backend.helpers;
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       HInstruction replacement = instruction.accept(this);
       if (replacement != instruction) {
         block.rewrite(instruction, replacement);
 
         // The intersection of double and int return conflicting, and
         // because of our number implementation for JavaScript, it
         // might be that an operation thought to return double, can be
         // simplified to an int. For example:
         // `2.5 * 10`.
-        if (!(replacement.isNumberOrNull(compiler)
-              && instruction.isNumberOrNull(compiler))) {
+        if (!(replacement.isNumberOrNull(compiler) &&
+            instruction.isNumberOrNull(compiler))) {
           // If we can replace [instruction] with [replacement], then
           // [replacement]'s type can be narrowed.
-          TypeMask newType = replacement.instructionType.intersection(
-              instruction.instructionType, compiler.world);
+          TypeMask newType = replacement.instructionType
+              .intersection(instruction.instructionType, compiler.world);
           replacement.instructionType = newType;
         }
 
         // If the replacement instruction does not know its
         // source element, use the source element of the
         // instruction.
         if (replacement.sourceElement == null) {
           replacement.sourceElement = instruction.sourceElement;
         }
         if (replacement.sourceInformation == null) {
@@ skipping 38 matching lines @@
         user.changeUse(node, constant);
       }
     }
   }
 
   HInstruction visitParameterValue(HParameterValue node) {
     // It is possible for the parameter value to be assigned to in the function
     // body. If that happens then we should not forward the constant value to
     // its uses since since the uses reachable from the assignment may have
     // values in addition to the constant passed to the function.
-    if (node.usedBy.any((user) =>
-            user is HLocalSet && identical(user.local, node))) {
+    if (node.usedBy
+        .any((user) => user is HLocalSet && identical(user.local, node))) {
       return node;
     }
     propagateConstantValueToUses(node);
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
@@ skipping 54 matching lines @@
         ListConstantValue constant = constantInput.constant;
         return graph.addConstantInt(constant.length, compiler);
       }
       Element element = helpers.jsIndexableLength;
       bool isFixed = isFixedLength(actualReceiver.instructionType, compiler);
       TypeMask actualType = node.instructionType;
       ClassWorld classWorld = compiler.world;
       TypeMask resultType = backend.positiveIntType;
       // If we already have computed a more specific type, keep that type.
       if (HInstruction.isInstanceOf(
-              actualType, helpers.jsUInt31Class, classWorld)) {
+          actualType, helpers.jsUInt31Class, classWorld)) {
         resultType = backend.uint31Type;
       } else if (HInstruction.isInstanceOf(
-              actualType, helpers.jsUInt32Class, classWorld)) {
+          actualType, helpers.jsUInt32Class, classWorld)) {
         resultType = backend.uint32Type;
       }
-      HFieldGet result = new HFieldGet(
-          element, actualReceiver, resultType,
+      HFieldGet result = new HFieldGet(element, actualReceiver, resultType,
           isAssignable: !isFixed);
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstantValue constant = constantInput.constant;
       return graph.addConstantInt(constant.length, compiler);
     }
     return null;
   }
 
@@ skipping 13 matching lines @@
     if (instruction != null) return instruction;
 
     Selector selector = node.selector;
     TypeMask mask = node.mask;
     HInstruction input = node.inputs[1];
 
     World world = compiler.world;
 
     bool applies(Element element) {
       return selector.applies(element, world) &&
-             (mask == null || mask.canHit(element, selector, world));
+          (mask == null || mask.canHit(element, selector, world));
     }
 
     if (selector.isCall || selector.isOperator) {
       Element target;
       if (input.isExtendableArray(compiler)) {
         if (applies(helpers.jsArrayRemoveLast)) {
           target = helpers.jsArrayRemoveLast;
         } else if (applies(helpers.jsArrayAdd)) {
           // The codegen special cases array calls, but does not
           // inline argument type checks.
           if (!compiler.options.enableTypeAssertions) {
             target = helpers.jsArrayAdd;
           }
         }
       } else if (input.isStringOrNull(compiler)) {
         if (applies(helpers.jsStringSplit)) {
           HInstruction argument = node.inputs[2];
           if (argument.isString(compiler)) {
             target = helpers.jsStringSplit;
           }
         } else if (applies(helpers.jsStringOperatorAdd)) {
           // `operator+` is turned into a JavaScript '+' so we need to
           // make sure the receiver and the argument are not null.
           // TODO(sra): Do this via [node.specializer].
           HInstruction argument = node.inputs[2];
-          if (argument.isString(compiler)
-              && !input.canBeNull()) {
+          if (argument.isString(compiler) && !input.canBeNull()) {
             return new HStringConcat(input, argument, node.instructionType);
           }
-        } else if (applies(helpers.jsStringToString)
-                   && !input.canBeNull()) {
+        } else if (applies(helpers.jsStringToString) && !input.canBeNull()) {
           return input;
         }
       }
       if (target != null) {
         // TODO(ngeoffray): There is a strong dependency between codegen
         // and this optimization that the dynamic invoke does not need an
         // interceptor. We currently need to keep a
         // HInvokeDynamicMethod and not create a HForeign because
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
-        HInvokeDynamicMethod result = new HInvokeDynamicMethod(
-            node.selector, node.mask,
-            node.inputs.sublist(1), node.instructionType);
+        HInvokeDynamicMethod result = new HInvokeDynamicMethod(node.selector,
+            node.mask, node.inputs.sublist(1), node.instructionType);
         result.element = target;
         return result;
       }
     } else if (selector.isGetter) {
       if (selector.applies(helpers.jsIndexableLength, world)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     TypeMask receiverType = node.getDartReceiver(compiler).instructionType;
     Element element =
         compiler.world.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
-    if (element != null
-        && element.isFunction
+    if (element != null &&
+        element.isFunction
         // If we found out that the only target is a [:noSuchMethod:],
         // we just ignore it.
-        && element.name == node.selector.name) {
+        &&
+        element.name == node.selector.name) {
       FunctionElement method = element;
 
       if (backend.isNative(method)) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
         FunctionSignature parameters = method.functionSignature;
         if (parameters.optionalParameterCount == 0 ||
-            parameters.parameterCount ==
-                node.selector.argumentCount) {
+            parameters.parameterCount == node.selector.argumentCount) {
           node.element = element;
         }
       }
     }
     return node;
   }
 
-  HInstruction tryInlineNativeMethod(HInvokeDynamicMethod node,
-                                     FunctionElement method) {
+  HInstruction tryInlineNativeMethod(
+      HInvokeDynamicMethod node, FunctionElement method) {
     // Enable direct calls to a native method only if we don't run in checked
     // mode, where the Dart version may have type annotations on parameters and
     // return type that it should check.
     // Also check that the parameters are not functions: it's the callee that
     // will translate them to JS functions.
     //
     // TODO(ngeoffray): There are some cases where we could still inline in
     // checked mode if we know the arguments have the right type. And we could
     // do the closure conversion as well as the return type annotation check.
 
     if (!node.isInterceptedCall) return null;
 
     // TODO(sra): Check for legacy methods with bodies in the native strings.
     //   foo() native 'return something';
     // They should not be used.
 
     FunctionSignature signature = method.functionSignature;
     if (signature.optionalParametersAreNamed) return null;
 
     // Return types on native methods don't need to be checked, since the
     // declaration has to be truthful.
 
     // The call site might omit optional arguments. The inlined code must
     // preserve the number of arguments, so check only the actual arguments.
 
     List<HInstruction> inputs = node.inputs.sublist(1);
-    int inputPosition = 1;  // Skip receiver.
+    int inputPosition = 1; // Skip receiver.
     bool canInline = true;
     signature.forEachParameter((ParameterElement element) {
       if (inputPosition++ < inputs.length && canInline) {
         DartType type = element.type.unaliased;
         if (type is FunctionType) {
           canInline = false;
         }
         if (compiler.options.enableTypeAssertions) {
           // TODO(sra): Check if [input] is guaranteed to pass the parameter
           // type check.  Consider using a strengthened type check to avoid
@@ skipping 25 matching lines @@
       HConstant constantInstruction = index;
       assert(!constantInstruction.constant.isInt);
       if (!constantSystem.isInt(constantInstruction.constant)) {
         // -0.0 is a double but will pass the runtime integer check.
         node.staticChecks = HBoundsCheck.ALWAYS_FALSE;
       }
     }
     return node;
   }
 
-  HInstruction foldBinary(BinaryOperation operation,
-                          HInstruction left,
-                          HInstruction right) {
+  HInstruction foldBinary(
+      BinaryOperation operation, HInstruction left, HInstruction right) {
     if (left is HConstant && right is HConstant) {
       HConstant op1 = left;
       HConstant op2 = right;
       ConstantValue folded = operation.fold(op1.constant, op2.constant);
       if (folded != null) return graph.addConstant(folded, compiler);
     }
     return null;
   }
 
   HInstruction visitAdd(HAdd node) {
@@ skipping 76 matching lines @@
     }
 
     if (left.isConstantBoolean() && right.isBoolean(compiler)) {
       return compareConstant(left, right);
     }
 
     if (right.isConstantBoolean() && left.isBoolean(compiler)) {
       return compareConstant(right, left);
     }
 
-
     if (identical(left.nonCheck(), right.nonCheck())) {
       // Avoid constant-folding `identical(x, x)` when `x` might be double.  The
       // dart2js runtime has not always been consistent with the Dart
       // specification (section 16.0.1), which makes distinctions on NaNs and
       // -0.0 that are hard to implement efficiently.
       if (left.isIntegerOrNull(compiler)) return makeTrue();
       if (!left.canBePrimitiveNumber(compiler)) return makeTrue();
     }
 
     return null;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction == null ? super.visitIdentity(node) : newInstruction;
   }
 
-  void simplifyCondition(HBasicBlock block,
-                         HInstruction condition,
-                         bool value) {
+  void simplifyCondition(
+      HBasicBlock block, HInstruction condition, bool value) {
     condition.dominatedUsers(block.first).forEach((user) {
       HInstruction newCondition = graph.addConstantBool(value, compiler);
       user.changeUse(condition, newCondition);
     });
   }
 
   HInstruction visitIf(HIf node) {
     HInstruction condition = node.condition;
     if (condition.isConstant()) return node;
     bool isNegated = condition is HNot;
 
     if (isNegated) {
       condition = condition.inputs[0];
     } else {
       // It is possible for LICM to move a negated version of the
       // condition out of the loop where it used. We still want to
       // simplify the nested use of the condition in that case, so
       // we look for all dominating negated conditions and replace
       // nested uses of them with true or false.
-      Iterable<HInstruction> dominating = condition.usedBy.where((user) =>
-          user is HNot && user.dominates(node));
+      Iterable<HInstruction> dominating = condition.usedBy
+          .where((user) => user is HNot && user.dominates(node));
       dominating.forEach((hoisted) {
         simplifyCondition(node.thenBlock, hoisted, false);
         simplifyCondition(node.elseBlock, hoisted, true);
       });
     }
     simplifyCondition(node.thenBlock, condition, !isNegated);
     simplifyCondition(node.elseBlock, condition, isNegated);
     return node;
   }
 
@@ skipping 41 matching lines @@
         return graph.addConstantBool(false, compiler);
       }
     } else if (expression.isNumber(compiler)) {
       if (element == coreClasses.numClass) {
         return graph.addConstantBool(true, compiler);
       } else {
         // We cannot just return false, because the expression may be of
         // type int or double.
       }
     } else if (expression.canBePrimitiveNumber(compiler) &&
-               element == coreClasses.intClass) {
+        element == coreClasses.intClass) {
       // We let the JS semantics decide for that check.
       return node;
-    // We need the [:hasTypeArguments:] check because we don't have
-    // the notion of generics in the backend. For example, [:this:] in
-    // a class [:A<T>:], is currently always considered to have the
-    // raw type.
+      // We need the [:hasTypeArguments:] check because we don't have
+      // the notion of generics in the backend. For example, [:this:] in
+      // a class [:A<T>:], is currently always considered to have the
+      // raw type.
     } else if (!RuntimeTypes.hasTypeArguments(type)) {
       TypeMask expressionMask = expression.instructionType;
       assert(TypeMask.assertIsNormalized(expressionMask, classWorld));
       TypeMask typeMask = (element == coreClasses.nullClass)
           ? new TypeMask.subtype(element, classWorld)
           : new TypeMask.nonNullSubtype(element, classWorld);
       if (expressionMask.union(typeMask, classWorld) == typeMask) {
         return graph.addConstantBool(true, compiler);
       } else if (expressionMask.isDisjoint(typeMask, compiler.world)) {
         return graph.addConstantBool(false, compiler);
@@ skipping 26 matching lines @@
   }
 
   HInstruction removeIfCheckAlwaysSucceeds(HCheck node, TypeMask checkedType) {
     ClassWorld classWorld = compiler.world;
     if (checkedType.containsAll(classWorld)) return node;
     HInstruction input = node.checkedInput;
     TypeMask inputType = input.instructionType;
     return inputType.isInMask(checkedType, classWorld) ? input : node;
   }
 
-  VariableElement findConcreteFieldForDynamicAccess(HInstruction receiver,
-                                                    Selector selector) {
+  VariableElement findConcreteFieldForDynamicAccess(
+      HInstruction receiver, Selector selector) {
     TypeMask receiverType = receiver.instructionType;
     return compiler.world.locateSingleField(selector, receiverType);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) return node;
     var receiver = node.receiver;
     if (node.element == helpers.jsIndexableLength) {
       JavaScriptItemCompilationContext context = work.compilationContext;
       if (context.allocatedFixedLists.contains(receiver)) {
@@ skipping 54 matching lines @@
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
     HInstruction receiver = node.getDartReceiver(compiler);
-    Element field = findConcreteFieldForDynamicAccess(
-        receiver, node.selector);
+    Element field = findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null) return node;
     return directFieldGet(receiver, field);
   }
 
   HInstruction directFieldGet(HInstruction receiver, Element field) {
     bool isAssignable = !compiler.world.fieldNeverChanges(field);
 
     TypeMask type;
     if (backend.isNative(field.enclosingClass)) {
       type = TypeMaskFactory.fromNativeBehavior(
-          native.NativeBehavior.ofFieldLoad(field, compiler),
-          compiler);
+          native.NativeBehavior.ofFieldLoad(field, compiler), compiler);
     } else {
       type = TypeMaskFactory.inferredTypeForElement(field, compiler);
     }
 
-    return new HFieldGet(
-        field, receiver, type, isAssignable: isAssignable);
+    return new HFieldGet(field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     HInstruction receiver = node.getDartReceiver(compiler);
     VariableElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null || !field.isAssignable) return node;
     // Use [:node.inputs.last:] in case the call follows the
     // interceptor calling convention, but is not a call on an
     // interceptor.
     HInstruction value = node.inputs.last;
     if (compiler.options.enableTypeAssertions) {
       DartType type = field.type;
       if (!type.treatAsRaw || type.isTypeVariable) {
         // We cannot generate the correct type representation here, so don't
         // inline this access.
         return node;
       }
-      HInstruction other = value.convertType(
-          compiler,
-          type,
-          HTypeConversion.CHECKED_MODE_CHECK);
+      HInstruction other =
+          value.convertType(compiler, type, HTypeConversion.CHECKED_MODE_CHECK);
       if (other != value) {
         node.block.addBefore(node, other);
         value = other;
       }
     }
     return new HFieldSet(field, receiver, value);
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     propagateConstantValueToUses(node);
@@ skipping 64 matching lines @@
       if (!constant.constant.isPrimitive) return node;
       if (constant.constant.isInt) {
         // Only constant-fold int.toString() when Dart and JS results the same.
         // TODO(18103): We should be able to remove this work-around when issue
         // 18103 is resolved by providing the correct string.
         IntConstantValue intConstant = constant.constant;
         // Very conservative range.
         if (!intConstant.isUInt32()) return node;
       }
       PrimitiveConstantValue primitive = constant.constant;
-      return graph.addConstant(constantSystem.createString(
-          primitive.toDartString()), compiler);
+      return graph.addConstant(
+          constantSystem.createString(primitive.toDartString()), compiler);
     }
     return node;
   }
 
   HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
     return handleInterceptedCall(node);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final Set<HInstruction> boundsChecked;
   final CodegenWorkItem work;
   final bool trustPrimitives;
   final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
-  SsaCheckInserter(this.trustPrimitives,
-                   this.backend,
-                   this.work,
-                   this.boundsChecked);
+  SsaCheckInserter(
+      this.trustPrimitives, this.backend, this.work, this.boundsChecked);
 
   BackendHelpers get helpers => backend.helpers;
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
 
     // In --trust-primitives mode we don't add bounds checks.  This is better
     // than trying to remove them later as the limit expression would become
     // dead and require DCE.
     if (trustPrimitives) return;
 
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
-  HBoundsCheck insertBoundsCheck(HInstruction indexNode,
-                                 HInstruction array,
-                                 HInstruction indexArgument) {
+  HBoundsCheck insertBoundsCheck(
+      HInstruction indexNode, HInstruction array, HInstruction indexArgument) {
     Compiler compiler = backend.compiler;
     HFieldGet length = new HFieldGet(
         helpers.jsIndexableLength, array, backend.positiveIntType,
         isAssignable: !isFixedLength(array.instructionType, compiler));
     indexNode.block.addBefore(indexNode, length);
 
     TypeMask type = indexArgument.isPositiveInteger(compiler)
         ? indexArgument.instructionType
         : backend.positiveIntType;
-    HBoundsCheck check = new HBoundsCheck(
-        indexArgument, length, array, type);
+    HBoundsCheck check = new HBoundsCheck(indexArgument, length, array, type);
     indexNode.block.addBefore(indexNode, check);
     // If the index input to the bounds check was not known to be an integer
     // then we replace its uses with the bounds check, which is known to be an
     // integer.  However, if the input was already an integer we don't do this
     // because putting in a check instruction might obscure the real nature of
     // the index eg. if it is a constant.  The range information from the
     // BoundsCheck instruction is attached to the input directly by
     // visitBoundsCheck in the SsaValueRangeAnalyzer.
     if (!indexArgument.isInteger(compiler)) {
       indexArgument.replaceAllUsersDominatedBy(indexNode, check);
@@ skipping 38 matching lines @@
   Map<HInstruction, bool> trivialDeadStoreReceivers =
       new Maplet<HInstruction, bool>();
   bool eliminatedSideEffects = false;
 
   SsaDeadCodeEliminator(this.compiler, this.optimizer);
 
   HInstruction zapInstructionCache;
   HInstruction get zapInstruction {
     if (zapInstructionCache == null) {
       // A constant with no type does not pollute types at phi nodes.
-      ConstantValue constant =
-          new SyntheticConstantValue(
-              SyntheticConstantKind.EMPTY_VALUE,
-              const TypeMask.nonNullEmpty());
+      ConstantValue constant = new SyntheticConstantValue(
+          SyntheticConstantKind.EMPTY_VALUE, const TypeMask.nonNullEmpty());
       zapInstructionCache = analyzer.graph.addConstant(constant, compiler);
     }
     return zapInstructionCache;
   }
 
   /// Returns true of [foreign] will throw an noSuchMethod error if
   /// receiver is `null` before having any other side-effects.
   bool templateThrowsNSMonNull(HForeignCode foreign, HInstruction receiver) {
     if (foreign.inputs.length < 1) return false;
     if (foreign.inputs.first != receiver) return false;
@@ skipping 26 matching lines @@
     return false;
   }
 
   /// Returns whether the next throwing instruction that may have side
   /// effects after [instruction], throws [NoSuchMethodError] on the
   /// same receiver of [instruction].
   bool hasFollowingThrowingNSM(HInstruction instruction) {
     HInstruction receiver = instruction.getDartReceiver(compiler);
     HInstruction current = instruction.next;
     do {
-      if ((current.getDartReceiver(compiler) == receiver)
-          && current.canThrow()) {
+      if ((current.getDartReceiver(compiler) == receiver) &&
+          current.canThrow()) {
         return true;
       }
       if (current is HForeignCode &&
           templateThrowsNSMonNull(current, receiver)) {
         return true;
       }
       if (current.canThrow() || current.sideEffects.hasSideEffects()) {
         return false;
       }
       HInstruction next = current.next;
@@ skipping 29 matching lines @@
       if (use is HFieldSet) {
         // The use must be the receiver.  Even if the use is also the argument,
         // i.e.  a.x = a, the store is still dead if all other uses are dead.
         if (use.getDartReceiver(compiler) == instruction) return true;
       } else if (use is HFieldGet) {
         assert(use.getDartReceiver(compiler) == instruction);
         if (isDeadCode(use)) return true;
       }
       return false;
     }
-    return instruction.isAllocation
-        && instruction.isPure()
-        && trivialDeadStoreReceivers.putIfAbsent(instruction,
-            () => instruction.usedBy.every(isDeadUse));
+    return instruction.isAllocation &&
+        instruction.isPure() &&
+        trivialDeadStoreReceivers.putIfAbsent(
+            instruction, () => instruction.usedBy.every(isDeadUse));
   }
 
   bool isTrivialDeadStore(HInstruction instruction) {
-    return instruction is HFieldSet
-        && isTrivialDeadStoreReceiver(instruction.getDartReceiver(compiler));
+    return instruction is HFieldSet &&
+        isTrivialDeadStoreReceiver(instruction.getDartReceiver(compiler));
   }
 
   bool isDeadCode(HInstruction instruction) {
     if (!instruction.usedBy.isEmpty) return false;
     if (isTrivialDeadStore(instruction)) return true;
     if (instruction.sideEffects.hasSideEffects()) return false;
     if (instruction.canThrow() &&
         instruction.onlyThrowsNSM() &&
         hasFollowingThrowingNSM(instruction)) {
       return true;
     }
-    return !instruction.canThrow()
-        && instruction is !HParameterValue
-        && instruction is !HLocalSet;
+    return !instruction.canThrow() &&
+        instruction is! HParameterValue &&
+        instruction is! HLocalSet;
   }
 
   void visitGraph(HGraph graph) {
     analyzer = new SsaLiveBlockAnalyzer(graph, compiler, optimizer);
     analyzer.analyze();
     visitPostDominatorTree(graph);
     cleanPhis(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     bool isDeadBlock = analyzer.isDeadBlock(block);
     block.isLive = !isDeadBlock;
     // Start from the last non-control flow instruction in the block.
     HInstruction instruction = block.last.previous;
     while (instruction != null) {
       var previous = instruction.previous;
       if (isDeadBlock) {
-        eliminatedSideEffects = eliminatedSideEffects ||
-            instruction.sideEffects.hasSideEffects();
+        eliminatedSideEffects =
+            eliminatedSideEffects || instruction.sideEffects.hasSideEffects();
         removeUsers(instruction);
         block.remove(instruction);
       } else if (isDeadCode(instruction)) {
         block.remove(instruction);
       }
       instruction = previous;
     }
   }
 
   void cleanPhis(HGraph graph) {
@@ skipping 12 matching lines @@
       int indexOfLive = -1;
       for (int i = 0; i < predecessors.length; i++) {
         if (predecessors[i].isLive) {
           if (indexOfLive >= 0) continue L;
           indexOfLive = i;
         }
       }
       // Run through the phis of the block and replace them with their input
       // that comes from the only live predecessor if that dominates the phi.
       block.forEachPhi((HPhi phi) {
-        HInstruction replacement = (indexOfLive >= 0)
-            ? phi.inputs[indexOfLive] : zapInstruction;
+        HInstruction replacement =
+            (indexOfLive >= 0) ? phi.inputs[indexOfLive] : zapInstruction;
         if (replacement.dominates(phi)) {
           block.rewrite(phi, replacement);
           block.removePhi(phi);
         }
       });
     }
   }
 
   void replaceInput(int i, HInstruction from, HInstruction by) {
     from.inputs[i].usedBy.remove(from);
@@ skipping 73 matching lines @@
         IntValue lowerValue = switchRange.lower;
         IntValue upperValue = switchRange.upper;
         int lower = lowerValue.value;
         int upper = upperValue.value;
         Set<int> liveLabels = new Set<int>();
         for (int pos = 1; pos < node.inputs.length; pos++) {
           HConstant input = node.inputs[pos];
           if (!input.isConstantInteger()) continue;
           IntConstantValue constant = input.constant;
           int label = constant.primitiveValue;
-          if (!liveLabels.contains(label) &&
-              label <= upper &&
-              label >= lower) {
+          if (!liveLabels.contains(label) && label <= upper && label >= lower) {
             markBlockLive(node.block.successors[pos - 1]);
             liveLabels.add(label);
           }
         }
         if (liveLabels.length != upper - lower + 1) {
           markBlockLive(node.defaultTarget);
         }
         return;
       }
     }
     visitControlFlow(node);
   }
 }
 
 class SsaDeadPhiEliminator implements OptimizationPhase {
   final String name = "SsaDeadPhiEliminator";
 
   void visitGraph(HGraph graph) {
     final List<HPhi> worklist = <HPhi>[];
     // A set to keep track of the live phis that we found.
     final Set<HPhi> livePhis = new Set<HPhi>();
 
     // Add to the worklist all live phis: phis referenced by non-phi
     // instructions.
     for (final block in graph.blocks) {
       block.forEachPhi((HPhi phi) {
         for (final user in phi.usedBy) {
-          if (user is !HPhi) {
+          if (user is! HPhi) {
             worklist.add(phi);
             livePhis.add(phi);
             break;
           }
         }
       });
     }
 
     // Process the worklist by propagating liveness to phi inputs.
     while (!worklist.isEmpty) {
@@ skipping 13 matching lines @@
     // create any.
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = blocks.length - 1; i >= 0; i--) {
       HBasicBlock block = blocks[i];
       HPhi current = block.phis.first;
       HPhi next = null;
       while (current != null) {
         next = current.next;
         if (!livePhis.contains(current)
             // TODO(ahe): Not sure the following is correct.
-            && current.usedBy.isEmpty) {
+            &&
+            current.usedBy.isEmpty) {
           block.removePhi(current);
         }
         current = next;
       }
     }
   }
 }
 
 class SsaRedundantPhiEliminator implements OptimizationPhase {
   final String name = "SsaRedundantPhiEliminator";
@@ skipping 54 matching lines @@
   final Set<int> visited;
 
   List<int> blockChangesFlags;
   List<int> loopChangesFlags;
 
   SsaGlobalValueNumberer(this.compiler) : visited = new Set<int>();
 
   void visitGraph(HGraph graph) {
     computeChangesFlags(graph);
     moveLoopInvariantCode(graph);
-    List<GvnWorkItem> workQueue =
-        <GvnWorkItem>[new GvnWorkItem(graph.entry, new ValueSet())];
+    List<GvnWorkItem> workQueue = <GvnWorkItem>[
+      new GvnWorkItem(graph.entry, new ValueSet())
+    ];
     do {
       GvnWorkItem item = workQueue.removeLast();
       visitBasicBlock(item.block, item.valueSet, workQueue);
     } while (!workQueue.isEmpty);
   }
 
   void moveLoopInvariantCode(HGraph graph) {
     for (int i = graph.blocks.length - 1; i >= 0; i--) {
       HBasicBlock block = graph.blocks[i];
       if (block.isLoopHeader()) {
         int changesFlags = loopChangesFlags[block.id];
         HLoopInformation info = block.loopInformation;
         // Iterate over all blocks of this loop. Note that blocks in
         // inner loops are not visited here, but we know they
         // were visited before because we are iterating in post-order.
         // So instructions that are GVN'ed in an inner loop are in their
         // loop entry, and [info.blocks] contains this loop entry.
         moveLoopInvariantCodeFromBlock(block, block, changesFlags);
         for (HBasicBlock other in info.blocks) {
           moveLoopInvariantCodeFromBlock(other, block, changesFlags);
         }
       }
     }
   }
 
-  void moveLoopInvariantCodeFromBlock(HBasicBlock block,
-                                      HBasicBlock loopHeader,
-                                      int changesFlags) {
+  void moveLoopInvariantCodeFromBlock(
+      HBasicBlock block, HBasicBlock loopHeader, int changesFlags) {
     assert(block.parentLoopHeader == loopHeader || block == loopHeader);
     HBasicBlock preheader = loopHeader.predecessors[0];
     int dependsFlags = SideEffects.computeDependsOnFlags(changesFlags);
     HInstruction instruction = block.first;
     bool isLoopAlwaysTaken() {
       HInstruction instruction = loopHeader.last;
       assert(instruction is HGoto || instruction is HLoopBranch);
-      return instruction is HGoto
-          || instruction.inputs[0].isConstantTrue();
+      return instruction is HGoto || instruction.inputs[0].isConstantTrue();
     }
     bool firstInstructionInLoop = block == loopHeader
         // Compensate for lack of code motion.
-        || (blockChangesFlags[loopHeader.id] == 0
-            && isLoopAlwaysTaken()
-            && loopHeader.successors[0] == block);
+        ||
+        (blockChangesFlags[loopHeader.id] == 0 &&
+            isLoopAlwaysTaken() &&
+            loopHeader.successors[0] == block);
     while (instruction != null) {
       HInstruction next = instruction.next;
-      if (instruction.useGvn() && instruction.isMovable
-          && (!instruction.canThrow() || firstInstructionInLoop)
-          && !instruction.sideEffects.dependsOn(dependsFlags)) {
+      if (instruction.useGvn() &&
+          instruction.isMovable &&
+          (!instruction.canThrow() || firstInstructionInLoop) &&
+          !instruction.sideEffects.dependsOn(dependsFlags)) {
         bool loopInvariantInputs = true;
         List<HInstruction> inputs = instruction.inputs;
         for (int i = 0, length = inputs.length; i < length; i++) {
           if (isInputDefinedAfterDominator(inputs[i], preheader)) {
             loopInvariantInputs = false;
             break;
           }
         }
 
         // If the inputs are loop invariant, we can move the
         // instruction from the current block to the pre-header block.
         if (loopInvariantInputs) {
           block.detach(instruction);
           preheader.moveAtExit(instruction);
         } else {
           firstInstructionInLoop = false;
         }
       }
       int oldChangesFlags = changesFlags;
       changesFlags |= instruction.sideEffects.getChangesFlags();
       if (oldChangesFlags != changesFlags) {
         dependsFlags = SideEffects.computeDependsOnFlags(changesFlags);
       }
       instruction = next;
     }
   }
 
-  bool isInputDefinedAfterDominator(HInstruction input,
-                                    HBasicBlock dominator) {
+  bool isInputDefinedAfterDominator(HInstruction input, HBasicBlock dominator) {
     return input.block.id > dominator.id;
   }
 
   void visitBasicBlock(
       HBasicBlock block, ValueSet values, List<GvnWorkItem> workQueue) {
     HInstruction instruction = block.first;
     if (block.isLoopHeader()) {
       int flags = loopChangesFlags[block.id];
       values.kill(flags);
     }
@@ skipping 68 matching lines @@
 
       // Loop headers are part of their loop, so update the loop
       // changes flags accordingly.
       if (block.isLoopHeader()) {
         loopChangesFlags[id] |= changesFlags;
       }
 
       // Propagate loop changes flags upwards.
       HBasicBlock parentLoopHeader = block.parentLoopHeader;
       if (parentLoopHeader != null) {
-        loopChangesFlags[parentLoopHeader.id] |= (block.isLoopHeader())
-            ? loopChangesFlags[id]
-            : changesFlags;
+        loopChangesFlags[parentLoopHeader.id] |=
+            (block.isLoopHeader()) ? loopChangesFlags[id] : changesFlags;
       }
     }
   }
 
   int getChangesFlagsForDominatedBlock(HBasicBlock dominator,
-                                       HBasicBlock dominated,
-                                       List<HBasicBlock> workQueue) {
+      HBasicBlock dominated, List<HBasicBlock> workQueue) {
     int changesFlags = 0;
     List<HBasicBlock> predecessors = dominated.predecessors;
     for (int i = 0, length = predecessors.length; i < length; i++) {
       HBasicBlock block = predecessors[i];
       int id = block.id;
       // If the current predecessor block is on the path from the
       // dominator to the dominated, it must have an id that is in the
       // range from the dominator to the dominated.
       if (dominator.id < id && id < dominated.id && !visited.contains(id)) {
         visited.add(id);
@@ skipping 114 matching lines @@
   SsaTypeConversionInserter(this.compiler);
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   // Update users of [input] that are dominated by [:dominator.first:]
   // to use [TypeKnown] of [input] instead. As the type information depends
   // on the control flow, we mark the inserted [HTypeKnown] nodes as
   // non-movable.
-  void insertTypePropagationForDominatedUsers(HBasicBlock dominator,
-                                              HInstruction input,
-                                              TypeMask convertedType) {
+  void insertTypePropagationForDominatedUsers(
+      HBasicBlock dominator, HInstruction input, TypeMask convertedType) {
     Setlet<HInstruction> dominatedUsers = input.dominatedUsers(dominator.first);
     if (dominatedUsers.isEmpty) return;
 
     HTypeKnown newInput = new HTypeKnown.pinned(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
     dominatedUsers.forEach((HInstruction user) {
       user.changeUse(input, newInput);
     });
   }
 
@@ skipping 11 matching lines @@
 
     collectIfUsers(instruction, ifUsers, notIfUsers);
 
     if (ifUsers.isEmpty && notIfUsers.isEmpty) return;
 
     TypeMask convertedType =
         new TypeMask.nonNullSubtype(element, compiler.world);
     HInstruction input = instruction.expression;
 
     for (HIf ifUser in ifUsers) {
-      insertTypePropagationForDominatedUsers(ifUser.thenBlock, input,
-                                             convertedType);
+      insertTypePropagationForDominatedUsers(
+          ifUser.thenBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the else block on a type
       // that knows it is not of a specific type.
     }
     for (HIf ifUser in notIfUsers) {
-      insertTypePropagationForDominatedUsers(ifUser.elseBlock, input,
-                                             convertedType);
+      insertTypePropagationForDominatedUsers(
+          ifUser.elseBlock, input, convertedType);
       // TODO(ngeoffray): Also change uses for the then block on a type
       // that knows it is not of a specific type.
     }
   }
 
   void visitIdentity(HIdentity instruction) {
     // At HIf(HIdentity(x, null)) strengthens x to non-null on else branch.
     HInstruction left = instruction.left;
     HInstruction right = instruction.right;
     HInstruction input;
@@ skipping 11 matching lines @@
     List<HInstruction> ifUsers = <HInstruction>[];
     List<HInstruction> notIfUsers = <HInstruction>[];
 
     collectIfUsers(instruction, ifUsers, notIfUsers);
 
     if (ifUsers.isEmpty && notIfUsers.isEmpty) return;
 
     TypeMask nonNullType = input.instructionType.nonNullable();
 
     for (HIf ifUser in ifUsers) {
-      insertTypePropagationForDominatedUsers(ifUser.elseBlock, input,
-                                             nonNullType);
+      insertTypePropagationForDominatedUsers(
+          ifUser.elseBlock, input, nonNullType);
       // Uses in thenBlock are `null`, but probably not common.
     }
     for (HIf ifUser in notIfUsers) {
-      insertTypePropagationForDominatedUsers(ifUser.thenBlock, input,
-                                             nonNullType);
+      insertTypePropagationForDominatedUsers(
+          ifUser.thenBlock, input, nonNullType);
       // Uses in elseBlock are `null`, but probably not common.
     }
   }
 
-  collectIfUsers(HInstruction instruction,
-                 List<HInstruction> ifUsers,
-                 List<HInstruction> notIfUsers) {
+  collectIfUsers(HInstruction instruction, List<HInstruction> ifUsers,
+      List<HInstruction> notIfUsers) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HIf) {
         ifUsers.add(user);
       } else if (user is HNot) {
         collectIfUsers(user, notIfUsers, ifUsers);
       }
     }
   }
 }
 
@@ skipping 24 matching lines @@
           visitBasicBlock(blocks[j]);
         }
       }
     }
   }
 
   void visitBasicBlock(HBasicBlock block) {
     if (block.predecessors.length == 0) {
       // Entry block.
       memorySet = new MemorySet(compiler);
-    } else if (block.predecessors.length == 1
-               && block.predecessors[0].successors.length == 1) {
+    } else if (block.predecessors.length == 1 &&
+        block.predecessors[0].successors.length == 1) {
       // No need to clone, there is no other successor for
       // `block.predecessors[0]`, and this block has only one
       // predecessor. Since we are not going to visit
       // `block.predecessors[0]` again, we can just re-use its
       // [memorySet].
       memorySet = memories[block.predecessors[0].id];
     } else if (block.predecessors.length == 1) {
       // Clone the memorySet of the predecessor, because it is also used
       // by other successors of it.
       memorySet = memories[block.predecessors[0].id].clone();
     } else {
       // Compute the intersection of all predecessors.
       memorySet = memories[block.predecessors[0].id];
       for (int i = 1; i < block.predecessors.length; i++) {
         memorySet = memorySet.intersectionFor(
-          memories[block.predecessors[i].id], block, i);
+            memories[block.predecessors[i].id], block, i);
       }
     }
 
     memories[block.id] = memorySet;
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction.accept(this);
       instruction = next;
     }
   }
 
   void visitFieldGet(HFieldGet instruction) {
     if (instruction.isNullCheck) return;
     Element element = instruction.element;
-    HInstruction receiver =
-        instruction.getDartReceiver(compiler).nonCheck();
+    HInstruction receiver = instruction.getDartReceiver(compiler).nonCheck();
     HInstruction existing = memorySet.lookupFieldValue(element, receiver);
     if (existing != null) {
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
       memorySet.registerFieldValue(element, receiver, instruction);
     }
   }
 
   void visitFieldSet(HFieldSet instruction) {
-    HInstruction receiver =
-        instruction.getDartReceiver(compiler).nonCheck();
+    HInstruction receiver = instruction.getDartReceiver(compiler).nonCheck();
     memorySet.registerFieldValueUpdate(
         instruction.element, receiver, instruction.inputs.last);
   }
 
   void visitForeignNew(HForeignNew instruction) {
     memorySet.registerAllocation(instruction);
     if (shouldTrackInitialValues(instruction)) {
       int argumentIndex = 0;
       instruction.element.forEachInstanceField((_, Element member) {
         if (compiler.elementHasCompileTimeError(member)) return;
@@ skipping 101 matching lines @@
 /**
  * Holds values of memory places.
  */
 class MemorySet {
   final Compiler compiler;
 
   /**
    * Maps a field to a map of receiver to value.
    */
   final Map<Element, Map<HInstruction, HInstruction>> fieldValues =
-      <Element, Map<HInstruction, HInstruction>> {};
+      <Element, Map<HInstruction, HInstruction>>{};
 
   /**
    * Maps a receiver to a map of keys to value.
    */
   final Map<HInstruction, Map<HInstruction, HInstruction>> keyedValues =
-      <HInstruction, Map<HInstruction, HInstruction>> {};
+      <HInstruction, Map<HInstruction, HInstruction>>{};
 
   /**
    * Set of objects that we know don't escape the current function.
    */
   final Setlet<HInstruction> nonEscapingReceivers = new Setlet<HInstruction>();
 
   MemorySet(this.compiler);
 
   JavaScriptBackend get backend => compiler.backend;
 
   /**
    * Returns whether [first] and [second] always alias to the same object.
    */
   bool mustAlias(HInstruction first, HInstruction second) {
     return first == second;
   }
 
   /**
    * Returns whether [first] and [second] may alias to the same object.
    */
   bool mayAlias(HInstruction first, HInstruction second) {
     if (mustAlias(first, second)) return true;
     if (isConcrete(first) && isConcrete(second)) return false;
     if (nonEscapingReceivers.contains(first)) return false;
     if (nonEscapingReceivers.contains(second)) return false;
     // Typed arrays of different types might have a shared buffer.
     if (couldBeTypedArray(first) && couldBeTypedArray(second)) return true;
-    return !first.instructionType.isDisjoint(
-        second.instructionType, compiler.world);
+    return !first.instructionType
+        .isDisjoint(second.instructionType, compiler.world);
   }
 
   bool isFinal(Element element) {
     return compiler.world.fieldNeverChanges(element);
   }
 
   bool isConcrete(HInstruction instruction) {
-    return instruction is HForeignNew
-        || instruction is HConstant
-        || instruction is HLiteralList;
+    return instruction is HForeignNew ||
+        instruction is HConstant ||
+        instruction is HLiteralList;
   }
 
   bool couldBeTypedArray(HInstruction receiver) {
     JavaScriptBackend backend = compiler.backend;
     return backend.couldBeTypedArray(receiver.instructionType);
   }
 
   /**
    * Returns whether [receiver] escapes the current function.
    */
   bool escapes(HInstruction receiver) {
     return !nonEscapingReceivers.contains(receiver);
   }
 
   void registerAllocation(HInstruction instruction) {
     nonEscapingReceivers.add(instruction);
   }
 
   /**
    * Sets `receiver.element` to contain [value]. Kills all potential
    * places that may be affected by this update.
    */
-  void registerFieldValueUpdate(Element element,
-                                HInstruction receiver,
-                                HInstruction value) {
+  void registerFieldValueUpdate(
+      Element element, HInstruction receiver, HInstruction value) {
     if (backend.isNative(element)) {
       return; // TODO(14955): Remove this restriction?
     }
     // [value] is being set in some place in memory, we remove it from
     // the non-escaping set.
     nonEscapingReceivers.remove(value);
-    Map<HInstruction, HInstruction> map = fieldValues.putIfAbsent(
-        element, () => <HInstruction, HInstruction> {});
+    Map<HInstruction, HInstruction> map =
+        fieldValues.putIfAbsent(element, () => <HInstruction, HInstruction>{});
     map.forEach((key, value) {
       if (mayAlias(receiver, key)) map[key] = null;
     });
     map[receiver] = value;
   }
 
   /**
    * Registers that `receiver.element` is now [value].
    */
-  void registerFieldValue(Element element,
-                          HInstruction receiver,
-                          HInstruction value) {
+  void registerFieldValue(
+      Element element, HInstruction receiver, HInstruction value) {
     if (backend.isNative(element)) {
       return; // TODO(14955): Remove this restriction?
     }
-    Map<HInstruction, HInstruction> map = fieldValues.putIfAbsent(
-        element, () => <HInstruction, HInstruction> {});
+    Map<HInstruction, HInstruction> map =
+        fieldValues.putIfAbsent(element, () => <HInstruction, HInstruction>{});
     map[receiver] = value;
   }
 
   /**
    * Returns the value stored in `receiver.element`. Returns null if
    * we don't know.
    */
   HInstruction lookupFieldValue(Element element, HInstruction receiver) {
     Map<HInstruction, HInstruction> map = fieldValues[element];
     return (map == null) ? null : map[receiver];
   }
 
   /**
    * Kill all places that may be affected by this [instruction]. Also
    * update the set of non-escaping objects in case [instruction] has
    * non-escaping objects in its inputs.
    */
   void killAffectedBy(HInstruction instruction) {
     // Even if [instruction] does not have side effects, it may use
     // non-escaping objects and store them in a new object, which
     // make these objects escaping.
     // TODO(ngeoffray): We need a new side effect flag to know whether
     // an instruction allocates an object.
     instruction.inputs.forEach((input) {
       nonEscapingReceivers.remove(input);
     });
 
-    if (instruction.sideEffects.changesInstanceProperty()
-        || instruction.sideEffects.changesStaticProperty()) {
+    if (instruction.sideEffects.changesInstanceProperty() ||
+        instruction.sideEffects.changesStaticProperty()) {
       fieldValues.forEach((element, map) {
         if (isFinal(element)) return;
         map.forEach((receiver, value) {
           if (escapes(receiver)) {
             map[receiver] = null;
           }
         });
       });
     }
 
@@ skipping 13 matching lines @@
    * we don't know.
    */
   HInstruction lookupKeyedValue(HInstruction receiver, HInstruction index) {
     Map<HInstruction, HInstruction> map = keyedValues[receiver];
     return (map == null) ? null : map[index];
   }
 
   /**
    * Registers that `receiver[index]` is now [value].
    */
-  void registerKeyedValue(HInstruction receiver,
-                          HInstruction index,
-                          HInstruction value) {
-    Map<HInstruction, HInstruction> map = keyedValues.putIfAbsent(
-        receiver, () => <HInstruction, HInstruction> {});
+  void registerKeyedValue(
+      HInstruction receiver, HInstruction index, HInstruction value) {
+    Map<HInstruction, HInstruction> map =
+        keyedValues.putIfAbsent(receiver, () => <HInstruction, HInstruction>{});
     map[index] = value;
   }
 
   /**
    * Sets `receiver[index]` to contain [value]. Kills all potential
    * places that may be affected by this update.
    */
-  void registerKeyedValueUpdate(HInstruction receiver,
-                                HInstruction index,
-                                HInstruction value) {
+  void registerKeyedValueUpdate(
+      HInstruction receiver, HInstruction index, HInstruction value) {
     nonEscapingReceivers.remove(value);
     keyedValues.forEach((key, values) {
       if (mayAlias(receiver, key)) {
         // Typed arrays that are views of the same buffer may have different
         // offsets or element sizes, unless they are the same typed array.
         bool weakIndex = couldBeTypedArray(key) && !mustAlias(receiver, key);
         values.forEach((otherIndex, otherValue) {
           if (weakIndex || mayAlias(index, otherIndex)) {
             values[otherIndex] = null;
           }
         });
       }
     });
 
     // Typed arrays may narrow incoming values.
     if (couldBeTypedArray(receiver)) return;
 
-    Map<HInstruction, HInstruction> map = keyedValues.putIfAbsent(
-        receiver, () => <HInstruction, HInstruction> {});
+    Map<HInstruction, HInstruction> map =
+        keyedValues.putIfAbsent(receiver, () => <HInstruction, HInstruction>{});
     map[index] = value;
   }
 
   /**
    * Returns null if either [first] or [second] is null. Otherwise
    * returns [first] if [first] and [second] are equal. Otherwise
    * creates or re-uses a phi in [block] that holds [first] and [second].
    */
-  HInstruction findCommonInstruction(HInstruction first,
-                                     HInstruction second,
-                                     HBasicBlock block,
-                                     int predecessorIndex) {
+  HInstruction findCommonInstruction(HInstruction first, HInstruction second,
+      HBasicBlock block, int predecessorIndex) {
     if (first == null || second == null) return null;
     if (first == second) return first;
-    TypeMask phiType = second.instructionType.union(
-          first.instructionType, compiler.world);
+    TypeMask phiType =
+        second.instructionType.union(first.instructionType, compiler.world);
     if (first is HPhi && first.block == block) {
       HPhi phi = first;
       phi.addInput(second);
       phi.instructionType = phiType;
       return phi;
     } else {
       HPhi phi = new HPhi.noInputs(null, phiType);
       block.addPhi(phi);
       // Previous predecessors had the same input. A phi must have
       // the same number of inputs as its block has predecessors.
       for (int i = 0; i < predecessorIndex; i++) {
         phi.addInput(first);
       }
       phi.addInput(second);
       return phi;
     }
   }
 
   /**
    * Returns the intersection between [this] and [other].
    */
-  MemorySet intersectionFor(MemorySet other,
-                            HBasicBlock block,
-                            int predecessorIndex) {
+  MemorySet intersectionFor(
+      MemorySet other, HBasicBlock block, int predecessorIndex) {
     MemorySet result = new MemorySet(compiler);
     if (other == null) return result;
 
     fieldValues.forEach((element, values) {
       var otherValues = other.fieldValues[element];
       if (otherValues == null) return;
       values.forEach((receiver, value) {
         HInstruction instruction = findCommonInstruction(
             value, otherValues[receiver], block, predecessorIndex);
         if (instruction != null) {
@@ skipping 35 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }