dartfmt pkg/compiler

pkg/compiler/lib/src/ssa/builder.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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
-import '../common/codegen.dart' show
-    CodegenRegistry,
-    CodegenWorkItem;
-import '../common/names.dart' show
-    Identifiers,
-    Selectors;
-import '../common/tasks.dart' show
-    CompilerTask;
-import '../compiler.dart' show
-    Compiler;
+import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
+import '../common/names.dart' show Identifiers, Selectors;
+import '../common/tasks.dart' show CompilerTask;
+import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show
-    CoreClasses;
+import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
-import '../diagnostics/messages.dart' show
-    Message,
-    MessageTemplate;
+import '../diagnostics/messages.dart' show Message, MessageTemplate;
 import '../elements/elements.dart';
-import '../elements/modelx.dart' show
-    ConstructorBodyElementX,
-    ElementX,
-    VariableElementX;
+import '../elements/modelx.dart'
+    show ConstructorBodyElementX, ElementX, VariableElementX;
 import '../io/source_information.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 '../js_emitter/js_emitter.dart' show
-    CodeEmitterTask,
-    NativeEmitter;
+import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
 import '../native/native.dart' as native;
 import '../resolution/operators.dart';
 import '../resolution/semantic_visitor.dart';
-import '../resolution/tree_elements.dart' show
-    TreeElements;
+import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
-import '../universe/side_effects.dart' show
-    SideEffects;
-import '../universe/use.dart' show
-    DynamicUse,
-    StaticUse,
-    TypeUse;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector;
+import '../universe/side_effects.dart' show SideEffects;
+import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../util/util.dart';
-import '../world.dart' show
-    ClassWorld,
-    World;
+import '../world.dart' show ClassWorld, World;
 import '../dump_info.dart' show InfoReporter;
 
 import 'nodes.dart';
 import 'codegen.dart';
 import 'optimize.dart';
 import 'types.dart';
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
   final JavaScriptBackend backend;
 
   SsaFunctionCompiler(JavaScriptBackend backend,
-                      SourceInformationStrategy sourceInformationFactory)
+      SourceInformationStrategy sourceInformationFactory)
       : generator = new SsaCodeGeneratorTask(backend, sourceInformationFactory),
         builder = new SsaBuilderTask(backend, sourceInformationFactory),
         optimizer = new SsaOptimizerTask(backend),
         backend = backend;
 
   /// Generates JavaScript code for `work.element`.
   /// Using the ssa builder, optimizer and codegenerator.
   js.Fun compile(CodegenWorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
@@ skipping 24 matching lines @@
 }
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
-    : emitter = backend.emitter,
-      backend = backend,
-      super(backend.compiler);
+      : emitter = backend.emitter,
+        backend = backend,
+        super(backend.compiler);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
-        SsaBuilder builder =
-            new SsaBuilder(work.element.implementation,
-                work.resolutionTree, work.compilationContext, work.registry,
-                backend, emitter.nativeEmitter,
-                sourceInformationFactory);
+        SsaBuilder builder = new SsaBuilder(
+            work.element.implementation,
+            work.resolutionTree,
+            work.compilationContext,
+            work.registry,
+            backend,
+            emitter.nativeEmitter,
+            sourceInformationFactory);
         HGraph graph = builder.build();
 
         // Default arguments are handled elsewhere, but we must ensure
         // that the default values are computed during codegen.
         if (!identical(element.kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((ParameterElement parameter) {
             // This ensures the default value will be computed.
             ConstantValue constant =
                 backend.constants.getConstantValueForVariable(parameter);
             work.registry.registerCompileTimeConstant(constant);
           });
         }
         if (compiler.tracer.isEnabled) {
           String name;
           if (element.isClassMember) {
             String className = element.enclosingClass.name;
             String memberName = element.name;
             name = "$className.$memberName";
             if (element.isGenerativeConstructorBody) {
               name = "$name (body)";
             }
           } else {
             name = "${element.name}";
           }
-          compiler.tracer.traceCompilation(
-              name, work.compilationContext);
+          compiler.tracer.traceCompilation(name, work.compilationContext);
           compiler.tracer.traceGraph('builder', graph);
         }
         return graph;
       });
     });
   }
-
 }
 
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
   /**
    * The values of locals that can be directly accessed (without redirections
    * to boxes or closure-fields).
    *
    * [directLocals] is iterated, so it is "insertion ordered" to make the
    * iteration order a function only of insertions and not a function of
    * e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
    * don't have source locations for [Elements.compareByPosition].
    */
-  Map<Local, HInstruction> directLocals =
-      new Map<Local, HInstruction>();
+  Map<Local, HInstruction> directLocals = new Map<Local, HInstruction>();
   Map<Local, CapturedVariable> redirectionMapping =
       new Map<Local, CapturedVariable>();
   SsaBuilder builder;
   ClosureClassMap closureData;
   Map<TypeVariableType, TypeVariableLocal> typeVariableLocals =
       new Map<TypeVariableType, TypeVariableLocal>();
   final ExecutableElement executableContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
@@ skipping 14 matching lines @@
   ///
   /// [instanceType] is not used if it contains type variables, since these
   /// might not be in scope or from the current instance.
   ///
   final InterfaceType instanceType;
 
   SourceInformationBuilder get sourceInformationBuilder {
     return builder.sourceInformationBuilder;
   }
 
-  LocalsHandler(this.builder, this.executableContext,
-                InterfaceType instanceType)
-      : this.instanceType =
-          instanceType == null || instanceType.containsTypeVariables
-              ? null : instanceType;
+  LocalsHandler(
+      this.builder, this.executableContext, InterfaceType instanceType)
+      : this.instanceType = instanceType == null ||
+            instanceType.containsTypeVariables ? null : instanceType;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
       if (typeContext != null) {
-        type = type.substByContext(
-            contextClass.asInstanceOf(typeContext));
+        type = type.substByContext(contextClass.asInstanceOf(typeContext));
       }
     }
     if (instanceType != null) {
       type = type.substByContext(instanceType);
     }
     return type;
   }
 
   get typesTask => builder.compiler.typesTask;
 
@@ skipping 18 matching lines @@
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
     JavaScriptBackend backend = builder.backend;
     HInstruction box = new HForeignCode(
-        js.js.parseForeignJS('{}'),
-        backend.nonNullType,
-        <HInstruction>[],
+        js.js.parseForeignJS('{}'), backend.nonNullType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(ast.Node node, Element element) {
@@ skipping 33 matching lines @@
       } else {
         redirectElement(from, to);
       }
     });
   }
 
   /**
    * Replaces the current box with a new box and copies over the given list
    * of elements from the old box into the new box.
    */
-  void updateCaptureBox(BoxLocal boxElement,
-                        List<LocalVariableElement> toBeCopiedElements) {
+  void updateCaptureBox(
+      BoxLocal boxElement, List<LocalVariableElement> toBeCopiedElements) {
     // Create a new box and copy over the values from the old box into the
     // new one.
     HInstruction oldBox = readLocal(boxElement);
     HInstruction newBox = createBox();
     for (LocalVariableElement boxedVariable in toBeCopiedElements) {
       // [readLocal] uses the [boxElement] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(Element element, ast.Node node) {
     assert(invariant(element, element.isImplementation));
     Compiler compiler = builder.compiler;
-    closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
-            element, node, builder.elements);
+    closureData = compiler.closureToClassMapper
+        .computeClosureToClassMapping(element, node, builder.elements);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
       ClosureScope scopeData = closureData.capturingScopes[node];
       params.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
-        HInstruction parameter = builder.addParameter(
-            parameterElement,
+        HInstruction parameter = builder.addParameter(parameterElement,
             TypeMaskFactory.inferredTypeForElement(parameterElement, compiler));
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
       });
     }
 
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.forEachFreeVariable((Local from, CapturedVariable to) {
       redirectElement(from, to);
     });
     JavaScriptBackend backend = compiler.backend;
     if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
-      HThis thisInstruction = new HThis(closureData.thisLocal,
-                                        backend.nonNullType);
+      HThis thisInstruction =
+          new HThis(closureData.thisLocal, backend.nonNullType);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
-      HThis thisInstruction = new HThis(
-          closureData.thisLocal, builder.getTypeOfThis());
+      HThis thisInstruction =
+          new HThis(closureData.thisLocal, builder.getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisLocal] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
     ClassElement cls = element.enclosingClass;
 
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
-    bool isNativeUpgradeFactory = element.isGenerativeConstructor
-        && backend.isNativeOrExtendsNative(cls);
+    bool isNativeUpgradeFactory =
+        element.isGenerativeConstructor && backend.isNativeOrExtendsNative(cls);
     if (backend.isInterceptedMethod(element)) {
       bool isInterceptorClass = backend.isInterceptorClass(cls.declaration);
       String name = isInterceptorClass ? 'receiver' : '_';
       SyntheticLocal parameter = new SyntheticLocal(name, executableContext);
       HParameterValue value =
           new HParameterValue(parameter, builder.getTypeOfThis());
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAfter(directLocals[closureData.thisLocal], value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
@@ skipping 15 matching lines @@
       builder.graph.entry.addAtEntry(value);
     }
   }
 
   /**
    * Returns true if the local can be accessed directly. Boxed variables or
    * captured variables that are stored in the closure-field return [:false:].
    */
   bool isAccessedDirectly(Local local) {
     assert(local != null);
-    return !redirectionMapping.containsKey(local)
-        && !closureData.variablesUsedInTryOrGenerator.contains(local);
+    return !redirectionMapping.containsKey(local) &&
+        !closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   bool isStoredInClosureField(Local local) {
     assert(local != null);
     if (isAccessedDirectly(local)) return false;
     CapturedVariable redirectTarget = redirectionMapping[local];
     if (redirectTarget == null) return false;
     return redirectTarget is ClosureFieldElement;
   }
 
   bool isBoxed(Local local) {
     if (isAccessedDirectly(local)) return false;
     if (isStoredInClosureField(local)) return false;
     return redirectionMapping.containsKey(local);
   }
 
   bool isUsedInTryOrGenerator(Local local) {
     return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
-  HInstruction readLocal(Local local,
-                         {SourceInformation sourceInformation}) {
+  HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
           builder.reporter.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
-          builder.reporter.internalError(local,
-              "Cannot find value $local.");
+          builder.reporter.internalError(local, "Cannot find value $local.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
@@ skipping 27 matching lines @@
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisLocal);
     if (res.instructionType == null) {
       res.instructionType = builder.getTypeOfThis();
     }
     return res;
   }
 
-  HLocalValue getLocal(Local local,
-                       {SourceInformation sourceInformation}) {
+  HLocalValue getLocal(Local local, {SourceInformation sourceInformation}) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
     if (local is ParameterElement) return builder.parameters[local];
 
     return builder.activationVariables.putIfAbsent(local, () {
       JavaScriptBackend backend = builder.backend;
       HLocalValue localValue = new HLocalValue(local, backend.nonNullType)
-          ..sourceInformation = sourceInformation;
+        ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
   Local getTypeVariableAsLocal(TypeVariableType type) {
     return typeVariableLocals.putIfAbsent(type, () {
       return new TypeVariableLocal(type, executableContext);
     });
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
   void updateLocal(Local local, HInstruction value,
-                   {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     if (value is HRef) {
       HRef ref = value;
       value = ref.value;
     }
     assert(!isStoredInClosureField(local));
     if (isAccessedDirectly(local)) {
       directLocals[local] = value;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       HInstruction box = readLocal(redirect.box);
       builder.add(new HFieldSet(redirect, box, value)
-          ..sourceInformation = sourceInformation);
+        ..sourceInformation = sourceInformation);
     } else {
       assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       builder.add(new HLocalSet(local, localValue, value)
-          ..sourceInformation = sourceInformation);
+        ..sourceInformation = sourceInformation);
     }
   }
 
   /**
    * This function, startLoop, must be called before visiting any children of
    * the loop. In particular it needs to be called before executing the
    * initializers.
    *
    * The [LocalsHandler] will make the boxes and updates at the right moment.
    * The builder just needs to call [enterLoopBody] and [enterLoopUpdates]
@@ skipping 52 matching lines @@
    * Create phis at the loop entry for local variables (ready for the values
    * from the back edge).  Populate the phis with the current values.
    */
   void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
     Map<Local, HInstruction> savedDirectLocals =
         new Map<Local, HInstruction>.from(directLocals);
 
     JavaScriptBackend backend = builder.backend;
     // Create phis for all elements in the definitions environment.
-    savedDirectLocals.forEach((Local local,
-                               HInstruction instruction) {
+    savedDirectLocals.forEach((Local local, HInstruction instruction) {
       if (isAccessedDirectly(local)) {
         // We know 'this' cannot be modified.
         if (local != closureData.thisLocal) {
-          HPhi phi = new HPhi.singleInput(
-              local, instruction, backend.dynamicType);
+          HPhi phi =
+              new HPhi.singleInput(local, instruction, backend.dynamicType);
           loopEntry.addPhi(phi);
           directLocals[local] = phi;
         } else {
           directLocals[local] = instruction;
         }
       }
     });
   }
 
   void enterLoopBody(ast.Node node) {
@@ skipping 39 matching lines @@
    * there is a conflict.
    * If a phi node is necessary, it will use this handler's instruction as the
    * first input, and the otherLocals instruction as the second.
    */
   void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) {
     // If an element is in one map but not the other we can safely
     // ignore it. It means that a variable was declared in the
     // block. Since variable declarations are scoped the declared
     // variable cannot be alive outside the block. Note: this is only
     // true for nodes where we do joins.
-    Map<Local, HInstruction> joinedLocals =
-        new Map<Local, HInstruction>();
+    Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
     JavaScriptBackend backend = builder.backend;
-    otherLocals.directLocals.forEach((Local local,
-                                      HInstruction instruction) {
+    otherLocals.directLocals.forEach((Local local, HInstruction instruction) {
       // We know 'this' cannot be modified.
       if (local == closureData.thisLocal) {
         assert(directLocals[local] == instruction);
         joinedLocals[local] = instruction;
       } else {
         HInstruction mine = directLocals[local];
         if (mine == null) return;
         if (identical(instruction, mine)) {
           joinedLocals[local] = instruction;
         } else {
           HInstruction phi = new HPhi.manyInputs(
               local, <HInstruction>[mine, instruction], backend.dynamicType);
           joinBlock.addPhi(phi);
           joinedLocals[local] = phi;
         }
       }
     });
     directLocals = joinedLocals;
   }
 
   /**
    * When control flow merges, this method can be used to merge several
    * localsHandlers into a new one using phis.  The new localsHandler is
    * returned.  Unless it is also in the list, the current localsHandler is not
    * used for its values, only for its declared variables. This is a way to
    * exclude local values from the result when they are no longer in scope.
    */
-  LocalsHandler mergeMultiple(List<LocalsHandler> localsHandlers,
-                              HBasicBlock joinBlock) {
+  LocalsHandler mergeMultiple(
+      List<LocalsHandler> localsHandlers, HBasicBlock joinBlock) {
     assert(localsHandlers.length > 0);
     if (localsHandlers.length == 1) return localsHandlers[0];
-    Map<Local, HInstruction> joinedLocals =
-        new Map<Local, HInstruction>();
+    Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
     HInstruction thisValue = null;
     JavaScriptBackend backend = builder.backend;
     directLocals.forEach((Local local, HInstruction instruction) {
       if (local != closureData.thisLocal) {
         HPhi phi = new HPhi.noInputs(local, backend.dynamicType);
         joinedLocals[local] = phi;
         joinBlock.addPhi(phi);
       } else {
         // We know that "this" never changes, if it's there.
         // Save it for later. While merging, there is no phi for "this",
         // so we don't have to special case it in the merge loop.
         thisValue = instruction;
       }
     });
     for (LocalsHandler handler in localsHandlers) {
-      handler.directLocals.forEach((Local local,
-                                    HInstruction instruction) {
+      handler.directLocals.forEach((Local local, HInstruction instruction) {
         HPhi phi = joinedLocals[local];
         if (phi != null) {
           phi.addInput(instruction);
         }
       });
     }
     if (thisValue != null) {
       // If there was a "this" for the scope, add it to the new locals.
       joinedLocals[closureData.thisLocal] = thisValue;
     }
 
     // Remove locals that are not in all handlers.
     directLocals = new Map<Local, HInstruction>();
-    joinedLocals.forEach((Local local,
-                          HInstruction instruction) {
-      if (local != closureData.thisLocal
-          && instruction.inputs.length != localsHandlers.length) {
+    joinedLocals.forEach((Local local, HInstruction instruction) {
+      if (local != closureData.thisLocal &&
+          instruction.inputs.length != localsHandlers.length) {
         joinBlock.removePhi(instruction);
       } else {
         directLocals[local] = instruction;
       }
     });
     return this;
   }
 }
 
-
 // Represents a single break/continue instruction.
 class JumpHandlerEntry {
   final HJump jumpInstruction;
   final LocalsHandler locals;
   bool isBreak() => jumpInstruction is HBreak;
   bool isContinue() => jumpInstruction is HContinue;
   JumpHandlerEntry(this.jumpInstruction, this.locals);
 }
 
-
 abstract class JumpHandler {
   factory JumpHandler(SsaBuilder builder, JumpTarget target) {
     return new TargetJumpHandler(builder, target);
   }
   void generateBreak([LabelDefinition label]);
   void generateContinue([LabelDefinition label]);
   void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
-  void forEachContinue(void action(HContinue instruction,
-                                   LocalsHandler locals));
+  void forEachContinue(
+      void action(HContinue instruction, LocalsHandler locals));
   bool hasAnyContinue();
   bool hasAnyBreak();
   void close();
   final JumpTarget target;
   List<LabelDefinition> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   final DiagnosticReporter reporter;
 
   NullJumpHandler(this.reporter);
 
   void generateBreak([LabelDefinition label]) {
     reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'NullJumpHandler.generateBreak should not be called.');
   }
 
   void generateContinue([LabelDefinition label]) {
     reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'NullJumpHandler.generateContinue should not be called.');
   }
 
-  void forEachBreak(Function ignored) { }
-  void forEachContinue(Function ignored) { }
-  void close() { }
+  void forEachBreak(Function ignored) {}
+  void forEachContinue(Function ignored) {}
+  void close() {}
   bool hasAnyContinue() => false;
   bool hasAnyBreak() => false;
 
   List<LabelDefinition> labels() => const <LabelDefinition>[];
   JumpTarget get target => null;
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
 // Continues in loops are implemented as breaks of the body.
@@ skipping 78 matching lines @@
   }
 }
 
 /// Special [JumpHandler] implementation used to handle continue statements
 /// targeting switch cases.
 class SwitchCaseJumpHandler extends TargetJumpHandler {
   /// Map from switch case targets to indices used to encode the flow of the
   /// switch case loop.
   final Map<JumpTarget, int> targetIndexMap = new Map<JumpTarget, int>();
 
-  SwitchCaseJumpHandler(SsaBuilder builder,
-                        JumpTarget target,
-                        ast.SwitchStatement node)
+  SwitchCaseJumpHandler(
+      SsaBuilder builder, JumpTarget target, ast.SwitchStatement node)
       : super(builder, target) {
     // The switch case indices must match those computed in
     // [SsaFromAstMixin.buildSwitchCaseConstants].
     // Switch indices are 1-based so we can bypass the synthetic loop when no
     // cases match simply by branching on the index (which defaults to null).
     int switchIndex = 1;
     for (ast.SwitchCase switchCase in node.cases) {
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         ast.Node label = labelOrCase.asLabel();
         if (label != null) {
@@ skipping 31 matching lines @@
     return label != null && targetIndexMap.containsKey(label.target);
   }
 
   void generateContinue([LabelDefinition label]) {
     if (isContinueToSwitchCase(label)) {
       // Creates the special instructions 'label = i; continue l;' used in
       // switch statements with continue statements. See
       // [SsaFromAstMixin.buildComplexSwitchStatement] for detail.
 
       assert(label != null);
-      HInstruction value = builder.graph.addConstantInt(
-          targetIndexMap[label.target],
-          builder.compiler);
+      HInstruction value = builder.graph
+          .addConstantInt(targetIndexMap[label.target], builder.compiler);
       builder.localsHandler.updateLocal(target, value);
 
       assert(label.target.labels.contains(label));
       HInstruction continueInstruction = new HContinue(target);
       LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
       builder.close(continueInstruction);
       jumps.add(new JumpHandlerEntry(continueInstruction, locals));
     } else {
       super.generateContinue(label);
     }
   }
 
   void close() {
     // The mapping from TargetElement to JumpHandler is no longer needed.
     for (JumpTarget target in targetIndexMap.keys) {
       builder.jumpTargets.remove(target);
     }
     super.close();
   }
 }
 
 /**
  * This class builds SSA nodes for functions represented in AST.
  */
 class SsaBuilder extends ast.Visitor
-    with BaseImplementationOfCompoundsMixin,
-         BaseImplementationOfSetIfNullsMixin,
-         BaseImplementationOfSuperIndexSetIfNullMixin,
-         SemanticSendResolvedMixin,
-         NewBulkMixin,
-         ErrorBulkMixin
+    with
+        BaseImplementationOfCompoundsMixin,
+        BaseImplementationOfSetIfNullsMixin,
+        BaseImplementationOfSuperIndexSetIfNullMixin,
+        SemanticSendResolvedMixin,
+        NewBulkMixin,
+        ErrorBulkMixin
     implements SemanticSendVisitor {
-
   /// The element for which this SSA builder is being used.
   final Element target;
 
   /// Reference to resolved elements in [target]'s AST.
   TreeElements elements;
 
   /// Used to report information about inlining (which occurs while building the
   /// SSA graph), when dump-info is enabled.
   final InfoReporter infoReporter;
 
@@ skipping 83 matching lines @@
   Map<ParameterElement, HInstruction> parameters =
       <ParameterElement, HInstruction>{};
 
   Map<JumpTarget, JumpHandler> jumpTargets = <JumpTarget, JumpHandler>{};
 
   /**
    * Variables stored in the current activation. These variables are
    * being updated in try/catch blocks, and should be
    * accessed indirectly through [HLocalGet] and [HLocalSet].
    */
-  Map<Local, HLocalValue> activationVariables =
-      <Local, HLocalValue>{};
+  Map<Local, HLocalValue> activationVariables = <Local, HLocalValue>{};
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack = <HInstruction>[];
 
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
-            element.asyncMarker == AsyncMarker.ASYNC);
+        element.asyncMarker == AsyncMarker.ASYNC);
   }
 
   // TODO(sigmund): make most args optional
-  SsaBuilder(this.target, this.elements, this.context, this.registry,
-      JavaScriptBackend backend, this.nativeEmitter,
+  SsaBuilder(
+      this.target,
+      this.elements,
+      this.context,
+      this.registry,
+      JavaScriptBackend backend,
+      this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
-    : this.compiler = backend.compiler,
-      this.infoReporter = backend.compiler.dumpInfoTask,
-      this.backend = backend,
-      this.constantSystem = backend.constantSystem,
-      this.rti = backend.rti {
+      : this.compiler = backend.compiler,
+        this.infoReporter = backend.compiler.dumpInfoTask,
+        this.backend = backend,
+        this.constantSystem = backend.constantSystem,
+        this.rti = backend.rti {
     assert(target.isImplementation);
     graph.element = target;
     localsHandler = new LocalsHandler(this, target, null);
     sourceElementStack.add(target);
-    sourceInformationBuilder = sourceInformationFactory.createBuilderForContext(
-            target);
+    sourceInformationBuilder =
+        sourceInformationFactory.createBuilderForContext(target);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
@@ skipping 12 matching lines @@
     node.accept(this);
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   Element get sourceElement => sourceElementStack.last;
 
-  bool get _checkOrTrustTypes => compiler.options.enableTypeAssertions ||
+  bool get _checkOrTrustTypes =>
+      compiler.options.enableTypeAssertions ||
       compiler.options.trustTypeAnnotations;
 
   /// Build the graph for [target].
   HGraph build() {
     assert(invariant(target, target.isImplementation));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
       result = buildFactory(target);
     } else if (target.isGenerativeConstructorBody ||
-               target.isFactoryConstructor ||
-               target.isFunction ||
-               target.isGetter ||
-               target.isSetter) {
+        target.isFactoryConstructor ||
+        target.isFunction ||
+        target.isGetter ||
+        target.isSetter) {
       result = buildMethod(target);
     } else if (target.isField) {
       if (target.isInstanceMember) {
         assert(compiler.options.enableTypeAssertions);
         result = buildCheckedSetter(target);
       } else {
         result = buildLazyInitializer(target);
       }
     } else {
       reporter.internalError(target, 'Unexpected element kind $target.');
     }
     assert(result.isValid());
     return result;
   }
 
-
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     // If adding a new block during building of an expression, it is due to
     // conditional expressions or short-circuit logical operators.
     return block;
   }
 
   void open(HBasicBlock block) {
     block.open();
     current = block;
@@ skipping 50 matching lines @@
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
 
     bool isInstanceMember = function.isInstanceMember;
     // For static calls, [providedArguments] is complete, default arguments
     // have been included if necessary, see [makeStaticArgumentList].
-    if (!isInstanceMember
-        || currentNode == null // In erroneous code, currentNode can be null.
-        || providedArgumentsKnownToBeComplete(currentNode)
-        || function.isGenerativeConstructorBody
-        || selector.isGetter) {
+    if (!isInstanceMember ||
+        currentNode == null // In erroneous code, currentNode can be null.
+        ||
+        providedArgumentsKnownToBeComplete(currentNode) ||
+        function.isGenerativeConstructorBody ||
+        selector.isGetter) {
       // For these cases, the provided argument list is known to be complete.
       return providedArguments;
     } else {
       return completeDynamicSendArgumentsList(
           selector, function, providedArguments);
     }
   }
 
   /**
    * Returns a complete argument list for a dynamic call of [function]. The
    * initial argument list [providedArguments], created by
    * [addDynamicSendArgumentsToList], does not include values for default
    * arguments used in the call. The reason is that the target function (which
    * defines the defaults) is not known.
    *
    * However, inlining can only be performed when the target function can be
    * resolved statically. The defaults can therefore be included at this point.
    *
    * The [providedArguments] list contains first all positional arguments, then
    * the provided named arguments (the named arguments that are defined in the
    * [selector]) in a specific order (see [addDynamicSendArgumentsToList]).
    */
-  List<HInstruction> completeDynamicSendArgumentsList(
-      Selector selector,
-      FunctionElement function,
-      List<HInstruction> providedArguments) {
+  List<HInstruction> completeDynamicSendArgumentsList(Selector selector,
+      FunctionElement function, List<HInstruction> providedArguments) {
     assert(selector.applies(function, compiler.world));
     FunctionSignature signature = function.functionSignature;
     List<HInstruction> compiledArguments = new List<HInstruction>(
         signature.parameterCount + 1); // Plus one for receiver.
 
     compiledArguments[0] = providedArguments[0]; // Receiver.
     int index = 1;
     for (; index <= signature.requiredParameterCount; index++) {
       compiledArguments[index] = providedArguments[index];
     }
@@ skipping 36 matching lines @@
         index++;
       });
     }
     return compiledArguments;
   }
 
   /**
    * Try to inline [element] within the currect context of the builder. The
    * insertion point is the state of the builder.
    */
-  bool tryInlineMethod(Element element,
-                       Selector selector,
-                       TypeMask mask,
-                       List<HInstruction> providedArguments,
-                       ast.Node currentNode,
-                       {InterfaceType instanceType}) {
+  bool tryInlineMethod(Element element, Selector selector, TypeMask mask,
+      List<HInstruction> providedArguments, ast.Node currentNode,
+      {InterfaceType instanceType}) {
     // TODO(johnniwinther): Register this on the [registry]. Currently the
     // [CodegenRegistry] calls the enqueuer, but [element] should _not_ be
     // enqueued.
     backend.registerStaticUse(element, compiler.enqueuer.codegen);
 
     if (backend.isJsInterop(element) && !element.isFactoryConstructor) {
       // We only inline factory JavaScript interop constructors.
       return false;
     }
 
@@ skipping 10 matching lines @@
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (compiler.options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : element,
           selector != null ||
-          Elements.isStaticOrTopLevel(element) ||
-          element.isGenerativeConstructorBody,
+              Elements.isStaticOrTopLevel(element) ||
+              element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
       if (selector != null) {
         if (!selector.applies(function, compiler.world)) return false;
         if (mask != null && !mask.canHit(function, selector, compiler.world)) {
           return false;
         }
       }
 
       if (backend.isJsInterop(element)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
-        if (element.enclosingClass != coreClasses.objectClass
-            && providedArguments[1].canBeNull()) {
+        if (element.enclosingClass != coreClasses.objectClass &&
+            providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
-      if (element.isGenerativeConstructor
-          && backend.isNativeOrExtendsNative(element.enclosingClass)) {
+      if (element.isGenerativeConstructor &&
+          backend.isNativeOrExtendsNative(element.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
       if (!element.isGenerativeConstructorBody) {
         // Don't inline if the return type was inferred to be non-null empty.
         // This means that the function always throws an exception.
         TypeMask returnType =
             compiler.typesTask.getGuaranteedReturnTypeOfElement(element);
@@ skipping 48 matching lines @@
 
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
 
       if (cachedCanBeInlined == true) {
         // We may have forced the inlining of some methods. Therefore check
         // if we can inline this method regardless of size.
         assert(InlineWeeder.canBeInlined(function, -1, false,
-                allowLoops: true,
-                enableUserAssertions: compiler.options.enableUserAssertions));
+            allowLoops: true,
+            enableUserAssertions: compiler.options.enableUserAssertions));
         return true;
       }
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       bool useMaxInliningNodes = true;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
@@ skipping 21 matching lines @@
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
       if (element.isInstanceMember &&
           !element.isGenerativeConstructorBody &&
           (mask == null || mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
-                          isAssignable: false),
+                isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
-      enterInlinedMethod(
-          function, currentNode, compiledArguments, instanceType: instanceType);
+      enterInlinedMethod(function, currentNode, compiledArguments,
+          instanceType: instanceType);
       inlinedFrom(function, () {
         if (!isReachable) {
           emitReturn(graph.addConstantNull(compiler), null);
         } else {
           doInline(function);
         }
       });
       leaveInlinedMethod();
     }
 
@@ skipping 134 matching lines @@
     graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
     ast.FunctionExpression function = functionElement.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (backend.isJsInterop(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
-      closeAndGotoExit(new HReturn(value,
-          sourceInformationBuilder.buildReturn(functionElement.node)));
+      closeAndGotoExit(new HReturn(
+          value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
     assert(invariant(functionElement, !function.modifiers.isExternal));
 
     // If [functionElement] is `operator==` we explicitely add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
-        handleIf(
-            function,
-            visitCondition: () {
-              HParameterValue parameter = parameters.values.first;
-              push(new HIdentity(
-                  parameter, graph.addConstantNull(compiler), null,
-                  backend.boolType));
-            },
-            visitThen: () {
-              closeAndGotoExit(new HReturn(
-                  graph.addConstantBool(false, compiler),
-                  sourceInformationBuilder
-                      .buildImplicitReturn(functionElement)));
-            },
+        handleIf(function, visitCondition: () {
+          HParameterValue parameter = parameters.values.first;
+          push(new HIdentity(parameter, graph.addConstantNull(compiler), null,
+              backend.boolType));
+        }, visitThen: () {
+          closeAndGotoExit(new HReturn(graph.addConstantBool(false, compiler),
+              sourceInformationBuilder.buildImplicitReturn(functionElement)));
+        },
             visitElse: null,
             sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
     }
     if (const bool.fromEnvironment('unreachable-throw') == true) {
-      var emptyParameters = parameters.values
-          .where((p) => p.instructionType.isEmpty);
+      var emptyParameters =
+          parameters.values.where((p) => p.instructionType.isEmpty);
       if (emptyParameters.length > 0) {
         addComment('${emptyParameters} inferred as [empty]');
         pushInvokeStatic(function.body, helpers.assertUnreachableMethod, []);
         pop();
         return closeFunction();
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   /// Adds a JavaScript comment to the output. The comment will be omitted in
   /// minified mode.  Each line in [text] is preceded with `//` and indented.
   /// Use sparingly. In order for the comment to be retained it is modeled as
   /// having side effects which will inhibit code motion.
   // TODO(sra): Figure out how to keep comment anchored without effects.
   void addComment(String text) {
-    add(new HForeignCode(
-        js.js.statementTemplateYielding(new js.Comment(text)),
-        backend.dynamicType,
-        <HInstruction>[],
+    add(new HForeignCode(js.js.statementTemplateYielding(new js.Comment(text)),
+        backend.dynamicType, <HInstruction>[],
         isStatement: true));
   }
 
   HGraph buildCheckedSetter(VariableElement field) {
     openFunction(field, field.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
     // narrowed to the type annotation.
     HInstruction parameter = new HParameterValue(field, backend.dynamicType);
     // Add the parameter as the last instruction of the entry block.
@@ skipping 77 matching lines @@
 
   /**
    * This method sets up the local state of the builder for inlining [function].
    * The arguments of the function are inserted into the [localsHandler].
    *
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
-  void setupStateForInlining(FunctionElement function,
-                             List<HInstruction> compiledArguments,
-                             {InterfaceType instanceType}) {
+  void setupStateForInlining(
+      FunctionElement function, List<HInstruction> compiledArguments,
+      {InterfaceType instanceType}) {
     localsHandler = new LocalsHandler(this, function, instanceType);
-    localsHandler.closureData =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            function, function.node, elements);
+    localsHandler.closureData = compiler.closureToClassMapper
+        .computeClosureToClassMapping(function, function.node, elements);
     returnLocal = new SyntheticLocal("result", function);
-    localsHandler.updateLocal(returnLocal,
-        graph.addConstantNull(compiler));
+    localsHandler.updateLocal(returnLocal, graph.addConstantNull(compiler));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
     ClassElement enclosing = function.enclosingClass;
-    if ((function.isConstructor || function.isGenerativeConstructorBody)
-        && backend.classNeedsRti(enclosing)) {
+    if ((function.isConstructor || function.isGenerativeConstructorBody) &&
+        backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = compiledArguments[argumentIndex++];
         localsHandler.updateLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable), argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
     elements = function.resolvedAst.elements;
     assert(elements != null);
@@ skipping 21 matching lines @@
     potentiallyCheckInlinedParameterTypes(function);
 
     if (function.isGenerativeConstructor) {
       buildFactory(function);
     } else {
       ast.FunctionExpression functionNode = function.node;
       functionNode.body.accept(this);
     }
   }
 
-
   addInlinedInstantiation(DartType type) {
     if (type != null) {
       currentInlinedInstantiations.add(type);
     }
   }
 
   removeInlinedInstantiation(DartType type) {
     if (type != null) {
       currentInlinedInstantiations.removeLast();
     }
@@ skipping 21 matching lines @@
       HInstruction argument = localsHandler.readLocal(parameter);
       potentiallyCheckOrTrustType(argument, parameter.type);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
-  void inlineSuperOrRedirect(ConstructorElement callee,
-                             List<HInstruction> compiledArguments,
-                             List<FunctionElement> constructors,
-                             Map<Element, HInstruction> fieldValues,
-                             FunctionElement caller) {
+  void inlineSuperOrRedirect(
+      ConstructorElement callee,
+      List<HInstruction> compiledArguments,
+      List<FunctionElement> constructors,
+      Map<Element, HInstruction> fieldValues,
+      FunctionElement caller) {
     callee = callee.implementation;
     reporter.withCurrentElement(callee, () {
       constructors.add(callee);
       ClassElement enclosingClass = callee.enclosingClass;
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
@@ skipping 21 matching lines @@
                 localsHandler.getTypeVariableAsLocal(variable),
                 graph.addConstantNull(compiler));
           }
         }
       }
 
       // For redirecting constructors, the fields will be initialized later
       // by the effective target.
       if (!callee.isRedirectingGenerative) {
         inlinedFrom(callee, () {
-          buildFieldInitializers(callee.enclosingClass.implementation,
-                               fieldValues);
+          buildFieldInitializers(
+              callee.enclosingClass.implementation, fieldValues);
         });
       }
 
       int index = 0;
       FunctionSignature params = callee.functionSignature;
       params.orderedForEachParameter((ParameterElement parameter) {
         HInstruction argument = compiledArguments[index++];
         // Because we are inlining the initializer, we must update
         // what was given as parameter. This will be used in case
         // there is a parameter check expression in the initializer.
         parameters[parameter] = argument;
         localsHandler.updateLocal(parameter, argument);
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       TreeElements oldElements = elements;
       ResolvedAst resolvedAst = callee.resolvedAst;
       elements = resolvedAst.elements;
       ClosureClassMap oldClosureData = localsHandler.closureData;
       ast.Node node = resolvedAst.node;
-      ClosureClassMap newClosureData =
-          compiler.closureToClassMapper.computeClosureToClassMapping(
-              callee, node, elements);
+      ClosureClassMap newClosureData = compiler.closureToClassMapper
+          .computeClosureToClassMapping(callee, node, elements);
       localsHandler.closureData = newClosureData;
       localsHandler.enterScope(node, callee);
       buildInitializers(callee, constructors, fieldValues);
       localsHandler.closureData = oldClosureData;
       elements = oldElements;
     });
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
    * implementation elements.
    */
-  void buildInitializers(ConstructorElement constructor,
-                         List<FunctionElement> constructors,
-                         Map<Element, HInstruction> fieldValues) {
+  void buildInitializers(
+      ConstructorElement constructor,
+      List<FunctionElement> constructors,
+      Map<Element, HInstruction> fieldValues) {
     assert(invariant(constructor, constructor.isImplementation));
     if (constructor.isSynthesized) {
       List<HInstruction> arguments = <HInstruction>[];
       HInstruction compileArgument(ParameterElement parameter) {
         return localsHandler.readLocal(parameter);
       }
 
       Element target = constructor.definingConstructor.implementation;
       bool match = !target.isMalformed &&
           CallStructure.addForwardingElementArgumentsToList(
               constructor,
               arguments,
               target,
               compileArgument,
               handleConstantForOptionalParameter);
       if (!match) {
         if (compiler.elementHasCompileTimeError(constructor)) {
           return;
         }
         // If this fails, the selector we constructed for the call to a
         // forwarding constructor in a mixin application did not match the
         // constructor (which, for example, may happen when the libraries are
         // not compatible for private names, see issue 20394).
-        reporter.internalError(constructor,
-                               'forwarding constructor call does not match');
+        reporter.internalError(
+            constructor, 'forwarding constructor call does not match');
       }
       inlineSuperOrRedirect(
-          target,
-          arguments,
-          constructors,
-          fieldValues,
-          constructor);
+          target, arguments, constructors, fieldValues, constructor);
       return;
     }
     ast.FunctionExpression functionNode = constructor.node;
 
     bool foundSuperOrRedirect = false;
     if (functionNode.initializers != null) {
       Link<ast.Node> initializers = functionNode.initializers.nodes;
-      for (Link<ast.Node> link = initializers; !link.isEmpty; link = link.tail) {
+      for (Link<ast.Node> link = initializers;
+          !link.isEmpty;
+          link = link.tail) {
         assert(link.head is ast.Send);
-        if (link.head is !ast.SendSet) {
+        if (link.head is! ast.SendSet) {
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
-                 ast.Initializers.isConstructorRedirect(call));
+              ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
           CallStructure callStructure =
               elements.getSelector(call).callStructure;
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
           inlinedFrom(constructor, () {
             compiledArguments =
                 makeStaticArgumentList(callStructure, arguments, target);
           });
-          inlineSuperOrRedirect(target,
-                                compiledArguments,
-                                constructors,
-                                fieldValues,
-                                constructor);
+          inlineSuperOrRedirect(target, compiledArguments, constructors,
+              fieldValues, constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(constructor, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject) {
         assert(superClass != null);
         assert(superClass.isResolved);
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupDefaultConstructor();
         if (target == null) {
-          reporter.internalError(superClass,
-              "No default constructor available.");
+          reporter.internalError(
+              superClass, "No default constructor available.");
         }
-        List<HInstruction> arguments =
-            CallStructure.NO_ARGS.makeArgumentsList(
-                const Link<ast.Node>(),
-                target.implementation,
-                null,
-                handleConstantForOptionalParameter);
-        inlineSuperOrRedirect(target,
-                              arguments,
-                              constructors,
-                              fieldValues,
-                              constructor);
+        List<HInstruction> arguments = CallStructure.NO_ARGS.makeArgumentsList(
+            const Link<ast.Node>(),
+            target.implementation,
+            null,
+            handleConstantForOptionalParameter);
+        inlineSuperOrRedirect(
+            target, arguments, constructors, fieldValues, constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
-  void buildFieldInitializers(ClassElement classElement,
-                              Map<Element, HInstruction> fieldValues) {
+  void buildFieldInitializers(
+      ClassElement classElement, Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
-          if (compiler.elementHasCompileTimeError(member)) return;
-          reporter.withCurrentElement(member, () {
-            TreeElements definitions = member.treeElements;
-            ast.Node node = member.node;
-            ast.Expression initializer = member.initializer;
-            if (initializer == null) {
-              // Unassigned fields of native classes are not initialized to
-              // prevent overwriting pre-initialized native properties.
-              if (!backend.isNativeOrExtendsNative(classElement)) {
-                fieldValues[member] = graph.addConstantNull(compiler);
-              }
-            } else {
-              ast.Node right = initializer;
-              TreeElements savedElements = elements;
-              elements = definitions;
-              // In case the field initializer uses closures, run the
-              // closure to class mapper.
-              compiler.closureToClassMapper.computeClosureToClassMapping(
-                  member, node, elements);
-              inlinedFrom(member, () => right.accept(this));
-              elements = savedElements;
-              fieldValues[member] = pop();
-            }
-          });
-        });
+      if (compiler.elementHasCompileTimeError(member)) return;
+      reporter.withCurrentElement(member, () {
+        TreeElements definitions = member.treeElements;
+        ast.Node node = member.node;
+        ast.Expression initializer = member.initializer;
+        if (initializer == null) {
+          // Unassigned fields of native classes are not initialized to
+          // prevent overwriting pre-initialized native properties.
+          if (!backend.isNativeOrExtendsNative(classElement)) {
+            fieldValues[member] = graph.addConstantNull(compiler);
+          }
+        } else {
+          ast.Node right = initializer;
+          TreeElements savedElements = elements;
+          elements = definitions;
+          // In case the field initializer uses closures, run the
+          // closure to class mapper.
+          compiler.closureToClassMapper
+              .computeClosureToClassMapping(member, node, elements);
+          inlinedFrom(member, () => right.accept(this));
+          elements = savedElements;
+          fieldValues[member] = pop();
+        }
+      });
+    });
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
    */
   HGraph buildFactory(ConstructorElement functionElement) {
     functionElement = functionElement.implementation;
-    ClassElement classElement =
-        functionElement.enclosingClass.implementation;
+    ClassElement classElement = functionElement.enclosingClass.implementation;
     bool isNativeUpgradeFactory =
-        backend.isNativeOrExtendsNative(classElement)
-            && !backend.isJsInterop(classElement);
+        backend.isNativeOrExtendsNative(classElement) &&
+            !backend.isJsInterop(classElement);
     ast.FunctionExpression function = functionElement.node;
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
       // The initializer list could contain closures.
       openFunction(functionElement, function);
     }
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
 
     // Compile the possible initialization code for local fields and
     // super fields, unless this is a redirecting constructor, in which case
     // the effective target will initialize these.
     if (!functionElement.isRedirectingGenerative) {
       buildFieldInitializers(classElement, fieldValues);
     }
 
     // Compile field-parameters such as [:this.x:].
     FunctionSignature params = functionElement.functionSignature;
     params.orderedForEachParameter((ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         // If the [element] is a field-parameter then
         // initialize the field element with its value.
         InitializingFormalElement fieldParameter = parameter;
-        HInstruction parameterValue =
-            localsHandler.readLocal(fieldParameter);
+        HInstruction parameterValue = localsHandler.readLocal(fieldParameter);
         fieldValues[fieldParameter.fieldElement] = parameterValue;
       }
     });
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     List<Element> fields = <Element>[];
 
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
-          HInstruction value = fieldValues[member];
-          if (value == null) {
-            // Uninitialized native fields are pre-initialized by the native
-            // implementation.
-            assert(invariant(
-                member, isNativeUpgradeFactory || compiler.compilationFailed));
-          } else {
-            fields.add(member);
-            DartType type = localsHandler.substInContext(member.type);
-            constructorArguments.add(potentiallyCheckOrTrustType(value, type));
-          }
-        },
-        includeSuperAndInjectedMembers: true);
+      HInstruction value = fieldValues[member];
+      if (value == null) {
+        // Uninitialized native fields are pre-initialized by the native
+        // implementation.
+        assert(invariant(
+            member, isNativeUpgradeFactory || compiler.compilationFailed));
+      } else {
+        fields.add(member);
+        DartType type = localsHandler.substInContext(member.type);
+        constructorArguments.add(potentiallyCheckOrTrustType(value, type));
+      }
+    }, includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
     TypeMask ssaType =
         new TypeMask.nonNullExact(classElement.declaration, compiler.world);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
-      newObject = new HForeignNew(classElement,
-          ssaType,
-          constructorArguments,
-          instantiatedTypes);
+      newObject = new HForeignNew(
+          classElement, ssaType, constructorArguments, instantiatedTypes);
       if (function != null) {
         // TODO(johnniwinther): Provide source information for creation
         // through synthetic constructors.
         newObject.sourceInformation =
             sourceInformationBuilder.buildCreate(function);
       }
       add(newObject);
     } else {
       // Bulk assign to the initialized fields.
       newObject = graph.explicitReceiverParameter;
       // Null guard ensures an error if we are being called from an explicit
       // 'new' of the constructor instead of via an upgrade. It is optimized out
       // if there are field initializers.
-      add(new HFieldGet(
-          null, newObject, backend.dynamicType, isAssignable: false));
+      add(new HFieldGet(null, newObject, backend.dynamicType,
+          isAssignable: false));
       for (int i = 0; i < fields.length; i++) {
         add(new HFieldSet(fields[i], newObject, constructorArguments[i]));
       }
     }
     removeInlinedInstantiation(type);
     // Create the runtime type information, if needed.
     if (backend.classNeedsRti(classElement)) {
       // Read the values of the type arguments and create a list to set on the
       // newly create object.  We can identify the case where the new list
       // would be of the form:
       //  [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)]
       // and k is the number of type arguments of this.  If this is the case,
       // we can simply copy the list from this.
 
       // These locals are modified by [isIndexedTypeArgumentGet].
-      HThis source;  // The source of the type arguments.
+      HThis source; // The source of the type arguments.
       bool allIndexed = true;
       int expectedIndex = 0;
-      ClassElement contextClass;  // The class of `this`.
-      int remainingTypeVariables;  // The number of 'remaining type variables'
-                                   // of `this`.
+      ClassElement contextClass; // The class of `this`.
+      int remainingTypeVariables; // The number of 'remaining type variables'
+      // of `this`.
 
       /// Helper to identify instructions that read a type variable without
       /// substitution (that is, directly use the index). These instructions
       /// are of the form:
       ///   HInvokeStatic(getTypeArgumentByIndex, this, index)
       ///
       /// Return `true` if [instruction] is of that form and the index is the
       /// next index in the sequence (held in [expectedIndex]).
       bool isIndexedTypeArgumentGet(HInstruction instruction) {
         if (instruction is! HInvokeStatic) return false;
@@ skipping 21 matching lines @@
         // a copy.  Otherwise remove one argument.
         if (remainingTypeVariables == 0) return false;
         remainingTypeVariables--;
         // Check that the index is the one we expect.
         IntConstantValue constant = index.constant;
         return constant.primitiveValue == expectedIndex++;
       }
 
       List<HInstruction> typeArguments = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
-        HInstruction argument = localsHandler.readLocal(
-            localsHandler.getTypeVariableAsLocal(typeVariable));
+        HInstruction argument = localsHandler
+            .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
         if (allIndexed && !isIndexedTypeArgumentGet(argument)) {
           allIndexed = false;
         }
         typeArguments.add(argument);
       });
 
       if (source != null && allIndexed && remainingTypeVariables == 0) {
         copyRuntimeTypeInfo(source, newObject);
       } else {
         newObject =
@@ skipping 43 matching lines @@
       }
 
       // Type variables arguments must come after the box (if there is one).
       ClassElement currentClass = constructor.enclosingClass;
       if (backend.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((TypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
           // `localsHandler.substInContext(argument)`.
-          bodyCallInputs.add(localsHandler.readLocal(
-              localsHandler.getTypeVariableAsLocal(argument)));
+          bodyCallInputs.add(localsHandler
+              .readLocal(localsHandler.getTypeVariableAsLocal(argument)));
         });
       }
 
       if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining.
           tryInlineMethod(body, null, null, bodyCallInputs, function)) {
         pop();
       } else {
         HInvokeConstructorBody invoke = new HInvokeConstructorBody(
             body.declaration, bodyCallInputs, backend.nonNullType);
         invoke.sideEffects =
@@ skipping 23 matching lines @@
 
     localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     var enclosing = element.enclosingElement;
-    if ((element.isConstructor || element.isGenerativeConstructorBody)
-        && backend.classNeedsRti(enclosing)) {
+    if ((element.isConstructor || element.isGenerativeConstructorBody) &&
+        backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
-        HParameterValue param = addParameter(
-            typeVariable.element, backend.nonNullType);
+        HParameterValue param =
+            addParameter(typeVariable.element, backend.nonNullType);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
       });
     }
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature signature = functionElement.functionSignature;
 
       // Put the type checks in the first successor of the entry,
       // because that is where the type guards will also be inserted.
       // This way we ensure that a type guard will dominate the type
       // check.
-      ClosureScope scopeData =
-          localsHandler.closureData.capturingScopes[node];
+      ClosureScope scopeData = localsHandler.closureData.capturingScopes[node];
       signature.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction newParameter =
@@ skipping 26 matching lines @@
 
     insertTraceCall(element);
     insertCoverageCall(element);
   }
 
   insertTraceCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'console') {
       if (element == backend.traceHelper) return;
       n(e) => e == null ? '' : e.name;
       String name = "${n(element.library)}:${n(element.enclosingClass)}."
-        "${n(element)}";
+          "${n(element)}";
       HConstant nameConstant = addConstantString(name);
-      add(new HInvokeStatic(backend.traceHelper,
-                            <HInstruction>[nameConstant],
-                            backend.dynamicType));
+      add(new HInvokeStatic(backend.traceHelper, <HInstruction>[nameConstant],
+          backend.dynamicType));
     }
   }
 
   insertCoverageCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'post') {
       if (element == backend.traceHelper) return;
       // TODO(sigmund): create a better uuid for elements.
       HConstant idConstant = graph.addConstantInt(element.hashCode, compiler);
       HConstant nameConstant = addConstantString(element.name);
       add(new HInvokeStatic(backend.traceHelper,
-                            <HInstruction>[idConstant, nameConstant],
-                            backend.dynamicType));
+          <HInstruction>[idConstant, nameConstant], backend.dynamicType));
     }
   }
 
   /// Check that [type] is valid in the context of `localsHandler.contextClass`.
   /// This should only be called in assertions.
   bool assertTypeInContext(DartType type, [Spannable spannable]) {
     return invariant(spannable == null ? CURRENT_ELEMENT_SPANNABLE : spannable,
         () {
-          ClassElement contextClass = Types.getClassContext(type);
-          return contextClass == null ||
-                 contextClass == localsHandler.contextClass;
-        },
+      ClassElement contextClass = Types.getClassContext(type);
+      return contextClass == null || contextClass == localsHandler.contextClass;
+    },
         message: "Type '$type' is not valid context of "
-                 "${localsHandler.contextClass}.");
+            "${localsHandler.contextClass}.");
   }
 
   /// Build a [HTypeConversion] for convertion [original] to type [type].
   ///
   /// Invariant: [type] must be valid in the context.
   /// See [LocalsHandler.substInContext].
-  HInstruction buildTypeConversion(HInstruction original,
-                                   DartType type,
-                                   int kind) {
+  HInstruction buildTypeConversion(
+      HInstruction original, DartType type, int kind) {
     if (type == null) return original;
     type = type.unaliased;
     assert(assertTypeInContext(type, original));
     if (type.isInterfaceType && !type.treatAsRaw) {
       TypeMask subtype = new TypeMask.subtype(type.element, compiler.world);
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
-      return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
-          original, representations);
+      return new HTypeConversion.withTypeRepresentation(
+          type, kind, subtype, original, representations);
     } else if (type.isTypeVariable) {
       TypeMask subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
-      return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
-          original, typeVariable);
+      return new HTypeConversion.withTypeRepresentation(
+          type, kind, subtype, original, typeVariable);
     } else if (type.isFunctionType) {
-      String name = kind == HTypeConversion.CAST_TYPE_CHECK
-          ? '_asCheck' : '_assertCheck';
+      String name =
+          kind == HTypeConversion.CAST_TYPE_CHECK ? '_asCheck' : '_assertCheck';
 
-      List<HInstruction> arguments =
-          <HInstruction>[buildFunctionType(type), original];
+      List<HInstruction> arguments = <HInstruction>[
+        buildFunctionType(type),
+        original
+      ];
       pushInvokeDynamic(
           null,
           new Selector.call(
               new Name(name, helpers.jsHelperLibrary), CallStructure.ONE_ARG),
           null,
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
@@ skipping 17 matching lines @@
   HInstruction _checkType(HInstruction original, DartType type, int kind) {
     assert(compiler.options.enableTypeAssertions);
     assert(type != null);
     type = localsHandler.substInContext(type);
     HInstruction other = buildTypeConversion(original, type, kind);
     registry?.registerTypeUse(new TypeUse.isCheck(type));
     return other;
   }
 
   HInstruction potentiallyCheckOrTrustType(HInstruction original, DartType type,
-      { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
+      {int kind: HTypeConversion.CHECKED_MODE_CHECK}) {
     if (type == null) return original;
     HInstruction checkedOrTrusted = original;
     if (compiler.options.trustTypeAnnotations) {
       checkedOrTrusted = _trustType(original, type);
     } else if (compiler.options.enableTypeAssertions) {
       checkedOrTrusted = _checkType(original, type, kind);
     }
     if (checkedOrTrusted == original) return original;
     add(checkedOrTrusted);
     return checkedOrTrusted;
   }
 
-  void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype,
-                       String message) {
+  void assertIsSubtype(
+      ast.Node node, DartType subtype, DartType supertype, String message) {
     HInstruction subtypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(subtype));
     HInstruction supertypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(supertype));
     HInstruction messageInstruction =
         graph.addConstantString(new ast.DartString.literal(message), compiler);
     Element element = helpers.assertIsSubtype;
-    var inputs = <HInstruction>[subtypeInstruction, supertypeInstruction,
-                                messageInstruction];
-    HInstruction assertIsSubtype = new HInvokeStatic(
-        element, inputs, subtypeInstruction.instructionType);
+    var inputs = <HInstruction>[
+      subtypeInstruction,
+      supertypeInstruction,
+      messageInstruction
+    ];
+    HInstruction assertIsSubtype =
+        new HInvokeStatic(element, inputs, subtypeInstruction.instructionType);
     registry?.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
     return graph;
   }
@@ skipping 11 matching lines @@
     return stack.removeLast();
   }
 
   void dup() {
     stack.add(stack.last);
   }
 
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (_checkOrTrustTypes) {
-      return potentiallyCheckOrTrustType(
-          value,
-          compiler.coreTypes.boolType,
+      return potentiallyCheckOrTrustType(value, compiler.coreTypes.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
     if (node != null) {
       target.sourceInformation = sourceInformationBuilder.buildGeneric(node);
@@ skipping 30 matching lines @@
     //
     void buildCondition() {
       visit(node.condition);
       pushInvokeStatic(node, helpers.assertTest, [pop()]);
     }
     void fail() {
       visit(node.message);
       pushInvokeStatic(node, helpers.assertThrow, [pop()]);
       pop();
     }
-    handleIf(node,
-             visitCondition: buildCondition,
-             visitThen: fail);
+    handleIf(node, visitCondition: buildCondition, visitThen: fail);
   }
 
   visitBlock(ast.Block node) {
     assert(!isAborted());
-    if (!isReachable) return;  // This can only happen when inlining.
+    if (!isReachable) return; // This can only happen when inlining.
     for (Link<ast.Node> link = node.statements.nodes;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       visit(link.head);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (!stack.isEmpty) {
           reporter.internalError(node, 'Non-empty instruction stack.');
         }
         return;
       }
     }
     assert(!current.isClosed());
     if (!stack.isEmpty) {
       reporter.internalError(node, 'Non-empty instruction stack.');
     }
   }
 
   visitClassNode(ast.ClassNode node) {
-    reporter.internalError(node,
-        'SsaBuilder.visitClassNode should not be called.');
+    reporter.internalError(
+        node, 'SsaBuilder.visitClassNode should not be called.');
   }
 
   visitThrowExpression(ast.Expression expression) {
     bool old = inExpressionOfThrow;
     try {
       inExpressionOfThrow = true;
       visit(expression);
     } finally {
       inExpressionOfThrow = old;
     }
@@ skipping 16 matching lines @@
   /**
    * Creates a new loop-header block. The previous [current] block
    * is closed with an [HGoto] and replaced by the newly created block.
    * Also notifies the locals handler that we're entering a loop.
    */
   JumpHandler beginLoopHeader(ast.Node node) {
     assert(!isAborted());
     HBasicBlock previousBlock = close(new HGoto());
 
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: true);
-    HBasicBlock loopEntry = graph.addNewLoopHeaderBlock(
-        jumpHandler.target,
-        jumpHandler.labels());
+    HBasicBlock loopEntry =
+        graph.addNewLoopHeaderBlock(jumpHandler.target, jumpHandler.labels());
     previousBlock.addSuccessor(loopEntry);
     open(loopEntry);
 
     localsHandler.beginLoopHeader(loopEntry);
     return jumpHandler;
   }
 
   /**
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchExitBlock] and
    *   any blocks that end in break.
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    * [savedLocals] are the locals from the end of the loop condition.
    * [branchExitBlock] is the exit (branching) block of the condition. Generally
    * this is not the top of the loop, since this would lead to critical edges.
    * It is null for degenerate do-while loops that have
    * no back edge because they abort (throw/return/break in the body and have
    * no continues).
    */
-  void endLoop(HBasicBlock loopEntry,
-               HBasicBlock branchExitBlock,
-               JumpHandler jumpHandler,
-               LocalsHandler savedLocals) {
+  void endLoop(HBasicBlock loopEntry, HBasicBlock branchExitBlock,
+      JumpHandler jumpHandler, LocalsHandler savedLocals) {
     HBasicBlock loopExitBlock = addNewBlock();
 
     List<LocalsHandler> breakHandlers = <LocalsHandler>[];
     // Collect data for the successors and the phis at each break.
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakHandlers.add(locals);
     });
 
     // The exit block is a successor of the loop condition if it is reached.
@@ skipping 29 matching lines @@
   }
 
   HSubExpressionBlockInformation wrapExpressionGraph(SubExpression expression) {
     if (expression == null) return null;
     return new HSubExpressionBlockInformation(expression);
   }
 
   // For while loops, initializer and update are null.
   // The condition function must return a boolean result.
   // None of the functions must leave anything on the stack.
-  void handleLoop(ast.Node loop,
-                  void initialize(),
-                  HInstruction condition(),
-                  void update(),
-                  void body()) {
+  void handleLoop(ast.Node loop, void initialize(), HInstruction condition(),
+      void update(), void body()) {
     // Generate:
     //  <initializer>
     //  loop-entry:
     //    if (!<condition>) goto loop-exit;
     //    <body>
     //    <updates>
     //    goto loop-entry;
     //  loop-exit:
 
     localsHandler.startLoop(loop);
 
     // The initializer.
     SubExpression initializerGraph = null;
     HBasicBlock startBlock;
     if (initialize != null) {
       HBasicBlock initializerBlock = openNewBlock();
       startBlock = initializerBlock;
       initialize();
       assert(!isAborted());
-      initializerGraph =
-          new SubExpression(initializerBlock, current);
+      initializerGraph = new SubExpression(initializerBlock, current);
     }
 
     loopNesting++;
     JumpHandler jumpHandler = beginLoopHeader(loop);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock conditionBlock = current;
     if (startBlock == null) startBlock = conditionBlock;
 
     HInstruction conditionInstruction = condition();
     HBasicBlock conditionEndBlock =
@@ skipping 22 matching lines @@
 
     bool loopIsDegenerate = !jumpHandler.hasAnyContinue() && bodyBlock == null;
     if (!loopIsDegenerate) {
       // Update.
       // We create an update block, even when we are in a while loop. There the
       // update block is the jump-target for continue statements. We could avoid
       // the creation if there is no continue, but for now we always create it.
       HBasicBlock updateBlock = addNewBlock();
 
       List<LocalsHandler> continueHandlers = <LocalsHandler>[];
-      jumpHandler.forEachContinue((HContinue instruction,
-                                   LocalsHandler locals) {
+      jumpHandler
+          .forEachContinue((HContinue instruction, LocalsHandler locals) {
         instruction.block.addSuccessor(updateBlock);
         continueHandlers.add(locals);
       });
 
-
       if (bodyBlock != null) {
         continueHandlers.add(localsHandler);
         bodyBlock.addSuccessor(updateBlock);
       }
 
       open(updateBlock);
       localsHandler =
           continueHandlers[0].mergeMultiple(continueHandlers, updateBlock);
 
       List<LabelDefinition> labels = jumpHandler.labels();
       JumpTarget target = elements.getTargetDefinition(loop);
       if (!labels.isEmpty) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation(
-                new HSubGraphBlockInformation(bodyGraph),
-                jumpHandler.labels(),
+                new HSubGraphBlockInformation(bodyGraph), jumpHandler.labels(),
                 isContinue: true),
             updateBlock);
       } else if (target != null && target.isContinueTarget) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation.implicit(
-                new HSubGraphBlockInformation(bodyGraph),
-                target,
+                new HSubGraphBlockInformation(bodyGraph), target,
                 isContinue: true),
             updateBlock);
       }
 
       localsHandler.enterLoopUpdates(loop);
 
       update();
 
       HBasicBlock updateEndBlock = close(new HGoto());
       // The back-edge completing the cycle.
       updateEndBlock.addSuccessor(conditionBlock);
       updateGraph = new SubExpression(updateBlock, updateEndBlock);
 
       // Avoid a critical edge from the condition to the loop-exit body.
       HBasicBlock conditionExitBlock = addNewBlock();
       open(conditionExitBlock);
       close(new HGoto());
       conditionEndBlock.addSuccessor(conditionExitBlock);
 
       endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
 
       conditionBlock.postProcessLoopHeader();
-      HLoopBlockInformation info =
-          new HLoopBlockInformation(
-              _loopKind(loop),
-              wrapExpressionGraph(initializerGraph),
-              wrapExpressionGraph(conditionExpression),
-              wrapStatementGraph(bodyGraph),
-              wrapExpressionGraph(updateGraph),
-              conditionBlock.loopInformation.target,
-              conditionBlock.loopInformation.labels,
-              sourceInformationBuilder.buildLoop(loop));
+      HLoopBlockInformation info = new HLoopBlockInformation(
+          _loopKind(loop),
+          wrapExpressionGraph(initializerGraph),
+          wrapExpressionGraph(conditionExpression),
+          wrapStatementGraph(bodyGraph),
+          wrapExpressionGraph(updateGraph),
+          conditionBlock.loopInformation.target,
+          conditionBlock.loopInformation.labels,
+          sourceInformationBuilder.buildLoop(loop));
 
       startBlock.setBlockFlow(info, current);
       loopInfo.loopBlockInformation = info;
     } else {
       // The body of the for/while loop always aborts, so there is no back edge.
       // We turn the code into:
       // if (condition) {
       //   body;
       // } else {
       //   // We always create an empty else block to avoid critical edges.
@@ skipping 11 matching lines @@
       SubGraph elseGraph = new SubGraph(elseBlock, elseBlock);
       // Remove the loop information attached to the header.
       conditionBlock.loopInformation = null;
 
       // Remove the [HLoopBranch] instruction and replace it with
       // [HIf].
       HInstruction condition = conditionEndBlock.last.inputs[0];
       conditionEndBlock.addAtExit(new HIf(condition));
       conditionEndBlock.addSuccessor(elseBlock);
       conditionEndBlock.remove(conditionEndBlock.last);
-      HIfBlockInformation info =
-          new HIfBlockInformation(
-              wrapExpressionGraph(conditionExpression),
-              wrapStatementGraph(bodyGraph),
-              wrapStatementGraph(elseGraph));
+      HIfBlockInformation info = new HIfBlockInformation(
+          wrapExpressionGraph(conditionExpression),
+          wrapStatementGraph(bodyGraph),
+          wrapStatementGraph(elseGraph));
 
       conditionEndBlock.setBlockFlow(info, current);
       HIf ifBlock = conditionEndBlock.last;
       ifBlock.blockInformation = conditionEndBlock.blockFlow;
 
       // If the body has any break, attach a synthesized label to the
       // if block.
       if (jumpHandler.hasAnyBreak()) {
         JumpTarget target = elements.getTargetDefinition(loop);
         LabelDefinition label = target.addLabel(null, 'loop');
         label.setBreakTarget();
         SubGraph labelGraph = new SubGraph(conditionBlock, current);
         HLabeledBlockInformation labelInfo = new HLabeledBlockInformation(
-                new HSubGraphBlockInformation(labelGraph),
-                <LabelDefinition>[label]);
+            new HSubGraphBlockInformation(labelGraph),
+            <LabelDefinition>[label]);
 
         conditionBlock.setBlockFlow(labelInfo, current);
 
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
           block.remove(breakInstruction);
         });
       }
     }
@@ skipping 33 matching lines @@
     }
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
     HInstruction buildCondition() {
       visit(node.condition);
       return popBoolified();
     }
-    handleLoop(node,
-               () {},
-               buildCondition,
-               () {},
-               () { visit(node.body); });
+    handleLoop(node, () {}, buildCondition, () {}, () {
+      visit(node.body);
+    });
   }
 
   visitDoWhile(ast.DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     localsHandler.startLoop(node);
     loopNesting++;
     JumpHandler jumpHandler = beginLoopHeader(node);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
@@ skipping 23 matching lines @@
       isAbortingBody = true;
       bodyExitBlock = lastOpenedBlock;
     }
 
     SubExpression conditionExpression;
     bool loopIsDegenerate = isAbortingBody && !hasContinues;
     if (!loopIsDegenerate) {
       HBasicBlock conditionBlock = addNewBlock();
 
       List<LocalsHandler> continueHandlers = <LocalsHandler>[];
-      jumpHandler.forEachContinue((HContinue instruction,
-                                   LocalsHandler locals) {
+      jumpHandler
+          .forEachContinue((HContinue instruction, LocalsHandler locals) {
         instruction.block.addSuccessor(conditionBlock);
         continueHandlers.add(locals);
       });
 
       if (!isAbortingBody) {
         bodyExitBlock.addSuccessor(conditionBlock);
       }
 
       if (!continueHandlers.isEmpty) {
         if (!isAbortingBody) continueHandlers.add(localsHandler);
         localsHandler =
             savedLocals.mergeMultiple(continueHandlers, conditionBlock);
         SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
         List<LabelDefinition> labels = jumpHandler.labels();
         HSubGraphBlockInformation bodyInfo =
             new HSubGraphBlockInformation(bodyGraph);
         HLabeledBlockInformation info;
         if (!labels.isEmpty) {
-          info = new HLabeledBlockInformation(bodyInfo, labels,
-                                              isContinue: true);
+          info =
+              new HLabeledBlockInformation(bodyInfo, labels, isContinue: true);
         } else {
           info = new HLabeledBlockInformation.implicit(bodyInfo, target,
-                                                       isContinue: true);
+              isContinue: true);
         }
         bodyEntryBlock.setBlockFlow(info, conditionBlock);
       }
       open(conditionBlock);
 
       visit(node.condition);
       assert(!isAborted());
       HInstruction conditionInstruction = popBoolified();
       HBasicBlock conditionEndBlock = close(
           new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
@@ skipping 10 matching lines @@
       // Avoid a critical edge from the condition to the loop-exit body.
       HBasicBlock conditionExitBlock = addNewBlock();
       open(conditionExitBlock);
       close(new HGoto());
       conditionEndBlock.addSuccessor(conditionExitBlock);
 
       endLoop(loopEntryBlock, conditionExitBlock, jumpHandler, localsHandler);
 
       loopEntryBlock.postProcessLoopHeader();
       SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock);
-      HLoopBlockInformation loopBlockInfo =
-          new HLoopBlockInformation(
-              HLoopBlockInformation.DO_WHILE_LOOP,
-              null,
-              wrapExpressionGraph(conditionExpression),
-              wrapStatementGraph(bodyGraph),
-              null,
-              loopEntryBlock.loopInformation.target,
-              loopEntryBlock.loopInformation.labels,
-              sourceInformationBuilder.buildLoop(node));
+      HLoopBlockInformation loopBlockInfo = new HLoopBlockInformation(
+          HLoopBlockInformation.DO_WHILE_LOOP,
+          null,
+          wrapExpressionGraph(conditionExpression),
+          wrapStatementGraph(bodyGraph),
+          null,
+          loopEntryBlock.loopInformation.target,
+          loopEntryBlock.loopInformation.labels,
+          sourceInformationBuilder.buildLoop(node));
       loopEntryBlock.setBlockFlow(loopBlockInfo, current);
       loopInfo.loopBlockInformation = loopBlockInfo;
     } else {
       // Since the loop has no back edge, we remove the loop information on the
       // header.
       loopEntryBlock.loopInformation = null;
 
       if (jumpHandler.hasAnyBreak()) {
         // Null branchBlock because the body of the do-while loop always aborts,
         // so we never get to the condition.
@@ skipping 36 matching lines @@
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type =
         new TypeMask.nonNullExact(closureClassElement, compiler.world);
     push(new HForeignNew(closureClassElement, type, capturedVariables)
-        ..sourceInformation = sourceInformationBuilder.buildCreate(node));
+      ..sourceInformation = sourceInformationBuilder.buildCreate(node));
 
     Element methodElement = nestedClosureData.closureElement;
     registry?.registerInstantiatedClosure(methodElement);
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
     LocalFunctionElement localFunction =
         elements.getFunctionDefinition(node.function);
     localsHandler.updateLocal(localFunction, pop());
   }
 
   @override
   void visitThisGet(ast.Identifier node, [_]) {
     stack.add(localsHandler.readThis());
   }
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       visitThisGet(node);
     } else {
-      reporter.internalError(node,
-          "SsaFromAstMixin.visitIdentifier on non-this.");
+      reporter.internalError(
+          node, "SsaFromAstMixin.visitIdentifier on non-this.");
     }
   }
 
   visitIf(ast.If node) {
     assert(isReachable);
-    handleIf(
-        node,
+    handleIf(node,
         visitCondition: () => visit(node.condition),
         visitThen: () => visit(node.thenPart),
         visitElse: node.elsePart != null ? () => visit(node.elsePart) : null,
         sourceInformation: sourceInformationBuilder.buildIf(node));
   }
 
   void handleIf(ast.Node diagnosticNode,
-                {void visitCondition(),
-                 void visitThen(),
-                 void visitElse(),
-                 SourceInformation sourceInformation}) {
+      {void visitCondition(),
+      void visitThen(),
+      void visitElse(),
+      SourceInformation sourceInformation}) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
-    branchBuilder.handleIf(
-        visitCondition, visitThen, visitElse,
+    branchBuilder.handleIf(visitCondition, visitThen, visitElse,
         sourceInformation: sourceInformation);
   }
 
   @override
   void visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleIfNull(() => visit(left), () => visit(right));
   }
 
   @override
   void visitLogicalAnd(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-    branchBuilder.handleLogicalAndOrWithLeftNode(
-        left,
-        () { visit(right); },
-        isAnd: true);
+    branchBuilder.handleLogicalAndOrWithLeftNode(left, () {
+      visit(right);
+    }, isAnd: true);
   }
 
   @override
   void visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-    branchBuilder.handleLogicalAndOrWithLeftNode(
-        left,
-        () { visit(right); },
-        isAnd: false);
+    branchBuilder.handleLogicalAndOrWithLeftNode(left, () {
+      visit(right);
+    }, isAnd: false);
   }
 
   @override
   void visitNot(ast.Send node, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     visit(expression);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGeneric(node);
     push(new HNot(popBoolified(), backend.boolType)
-        ..sourceInformation = sourceInformation);
+      ..sourceInformation = sourceInformation);
   }
 
   @override
-  void visitUnary(ast.Send node,
-                  UnaryOperator operator,
-                  ast.Node expression,_) {
+  void visitUnary(
+      ast.Send node, UnaryOperator operator, ast.Node expression, _) {
     assert(node.argumentsNode is ast.Prefix);
     HInstruction operand = visitAndPop(expression);
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       HConstant constant = operand;
       ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
     pushInvokeDynamic(
-        node,
-        elements.getSelector(node),
-        elements.getTypeMask(node),
-        [operand],
+        node, elements.getSelector(node), elements.getTypeMask(node), [operand],
         sourceInformation: sourceInformationBuilder.buildGeneric(node));
   }
 
   @override
-  void visitBinary(ast.Send node,
-                   ast.Node left,
-                   BinaryOperator operator,
-                   ast.Node right, _) {
+  void visitBinary(ast.Send node, ast.Node left, BinaryOperator operator,
+      ast.Node right, _) {
     handleBinary(node, left, right);
   }
 
   @override
   void visitIndex(ast.Send node, ast.Node receiver, ast.Node index, _) {
     generateDynamicSend(node);
   }
 
   @override
   void visitEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     handleBinary(node, left, right);
   }
 
   @override
   void visitNotEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     handleBinary(node, left, right);
     pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
   }
 
   void handleBinary(ast.Send node, ast.Node left, ast.Node right) {
-    visitBinarySend(
-        visitAndPop(left),
-        visitAndPop(right),
-        elements.getSelector(node),
-        elements.getTypeMask(node),
-        node,
+    visitBinarySend(visitAndPop(left), visitAndPop(right),
+        elements.getSelector(node), elements.getTypeMask(node), node,
         sourceInformation:
             sourceInformationBuilder.buildGeneric(node.selector));
   }
 
   /// TODO(johnniwinther): Merge [visitBinarySend] with [handleBinary] and
   /// remove use of [location] for source information.
-  void visitBinarySend(HInstruction left,
-                       HInstruction right,
-                       Selector selector,
-                       TypeMask mask,
-                       ast.Send send,
-                       {SourceInformation sourceInformation}) {
+  void visitBinarySend(HInstruction left, HInstruction right, Selector selector,
+      TypeMask mask, ast.Send send,
+      {SourceInformation sourceInformation}) {
     pushInvokeDynamic(send, selector, mask, [left, right],
         sourceInformation: sourceInformation);
   }
 
   HInstruction generateInstanceSendReceiver(ast.Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
   String noSuchMethodTargetSymbolString(Element error, [String prefix]) {
     String result = error.name;
     if (prefix == "set") return "$result=";
     return result;
   }
 
   /**
    * Returns a set of interceptor classes that contain the given
    * [selector].
    */
   void generateInstanceGetterWithCompiledReceiver(
-      ast.Send send,
-      Selector selector,
-      TypeMask mask,
-      HInstruction receiver) {
+      ast.Send send, Selector selector, TypeMask mask, HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     assert(selector.isGetter);
     pushInvokeDynamic(send, selector, mask, [receiver],
         sourceInformation: sourceInformationBuilder.buildGet(send));
   }
 
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
-  void generateIsDeferredLoadedCheckIfNeeded(PrefixElement prefixElement,
-                                             ast.Node location) {
+  void generateIsDeferredLoadedCheckIfNeeded(
+      PrefixElement prefixElement, ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(location, prefixElement);
     HInstruction loadIdConstant = addConstantString(loadId);
     String uri = prefixElement.deferredImport.uri.toString();
     HInstruction uriConstant = addConstantString(uri);
     Element helper = helpers.checkDeferredIsLoaded;
     pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
     pop();
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
-        compiler.deferredLoadTask.deferredPrefixElement(node, elements),
-        node);
+        compiler.deferredLoadTask.deferredPrefixElement(node, elements), node);
   }
 
   void handleInvalidStaticGet(ast.Send node, Element element) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     generateThrowNoSuchMethod(
-        node,
-        noSuchMethodTargetSymbolString(element, 'get'),
+        node, noSuchMethodTargetSymbolString(element, 'get'),
         argumentNodes: const Link<ast.Node>(),
         sourceInformation: sourceInformation);
   }
 
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
       SourceInformation sourceInformation =
           sourceInformationBuilder.buildGet(node);
       // An erroneous element indicates an unresolved static getter.
       handleInvalidStaticGet(node, element);
     } else {
       // This happens when [element] has parse errors.
       assert(invariant(node, element == null || element.isMalformed));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
       stack.add(graph.addConstantNull(compiler));
     }
   }
 
   /// Read a static or top level [field] of constant value.
-  void generateStaticConstGet(
-      ast.Send node,
-      FieldElement field,
-      ConstantExpression constant,
-      SourceInformation sourceInformation) {
+  void generateStaticConstGet(ast.Send node, FieldElement field,
+      ConstantExpression constant, SourceInformation sourceInformation) {
     ConstantValue value = backend.constants.getConstantValue(constant);
     HConstant instruction;
     // Constants that are referred via a deferred prefix should be referred
     // by reference.
-    PrefixElement prefix = compiler.deferredLoadTask
-        .deferredPrefixElement(node, elements);
+    PrefixElement prefix =
+        compiler.deferredLoadTask.deferredPrefixElement(node, elements);
     if (prefix != null) {
       instruction =
           graph.addDeferredConstant(value, prefix, sourceInformation, compiler);
     } else {
-      instruction = graph.addConstant(
-          value, compiler, sourceInformation: sourceInformation);
+      instruction = graph.addConstant(value, compiler,
+          sourceInformation: sourceInformation);
     }
     stack.add(instruction);
     // The inferrer may have found a better type than the constant
     // handler in the case of lists, because the constant handler
     // does not look at elements in the list.
-    TypeMask type =
-        TypeMaskFactory.inferredTypeForElement(field, compiler);
-    if (!type.containsAll(compiler.world) &&
-        !instruction.isConstantNull()) {
+    TypeMask type = TypeMaskFactory.inferredTypeForElement(field, compiler);
+    if (!type.containsAll(compiler.world) && !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
       // cannot be null.
       instruction.instructionType = type.nonNullable();
     }
   }
 
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
     generateIsDeferredLoadedCheckIfNeeded(prefix, node);
   }
 
   /// Read a static or top level [field].
   void generateStaticFieldGet(ast.Send node, FieldElement field) {
     ConstantExpression constant =
         backend.constants.getConstantForVariable(field);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (constant != null) {
       if (!field.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         generateStaticConstGet(node, field, constant, sourceInformation);
       } else {
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
-        HInstruction instruction = new HStatic(
-            field.declaration,
+        HInstruction instruction = new HStatic(field.declaration,
             TypeMaskFactory.inferredTypeForElement(field, compiler))
-                ..sourceInformation = sourceInformation;
+          ..sourceInformation = sourceInformation;
         push(instruction);
       }
     } else {
       HInstruction instruction = new HLazyStatic(
-          field,
-          TypeMaskFactory.inferredTypeForElement(field, compiler))
-              ..sourceInformation = sourceInformation;
+          field, TypeMaskFactory.inferredTypeForElement(field, compiler))
+        ..sourceInformation = sourceInformation;
       push(instruction);
     }
   }
 
   /// Generate a getter invocation of the static or top level [getter].
   void generateStaticGetterGet(ast.Send node, MethodElement getter) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (getter.isDeferredLoaderGetter) {
       generateDeferredLoaderGet(node, getter, sourceInformation);
     } else {
       pushInvokeStatic(node, getter, <HInstruction>[],
-                       sourceInformation: sourceInformation);
+          sourceInformation: sourceInformation);
     }
   }
 
   /// Generate a dynamic getter invocation.
   void generateDynamicGet(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     generateInstanceGetterWithCompiledReceiver(
         node, elements.getSelector(node), elements.getTypeMask(node), receiver);
   }
 
   /// Generate a closurization of the static or top level [function].
   void generateStaticFunctionGet(ast.Send node, MethodElement function) {
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     push(new HStatic(function.declaration, backend.nonNullType)
-        ..sourceInformation = sourceInformation);
+      ..sourceInformation = sourceInformation);
   }
 
   /// Read a local variable, function or parameter.
   void buildLocalGet(LocalElement local, SourceInformation sourceInformation) {
-    stack.add(localsHandler.readLocal(
-              local, sourceInformation: sourceInformation));
+    stack.add(
+        localsHandler.readLocal(local, sourceInformation: sourceInformation));
   }
 
   void handleLocalGet(ast.Send node, LocalElement local) {
     buildLocalGet(local, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  void visitDynamicPropertyGet(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      _) {
+  void visitDynamicPropertyGet(ast.Send node, ast.Node receiver, Name name, _) {
     generateDynamicGet(node);
   }
 
   @override
   void visitIfNotNullDynamicPropertyGet(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      _) {
+      ast.Send node, ast.Node receiver, Name name, _) {
     // exp?.x compiled as:
     //   t1 = exp;
     //   result = t1 == null ? t1 : t1.x;
     // This is equivalent to t1 == null ? null : t1.x, but in the current form
     // we will be able to later compress it as:
     //   t1 || t1.x
     HInstruction expression;
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(
         () {
           expression = visitAndPop(receiver);
           pushCheckNull(expression);
         },
         () => stack.add(expression),
         () {
           generateInstanceGetterWithCompiledReceiver(
               node,
               elements.getSelector(node),
               elements.getTypeMask(node),
               expression);
         });
   }
 
   /// Pushes a boolean checking [expression] against null.
   pushCheckNull(HInstruction expression) {
-    push(new HIdentity(expression, graph.addConstantNull(compiler),
-          null, backend.boolType));
+    push(new HIdentity(
+        expression, graph.addConstantNull(compiler), null, backend.boolType));
   }
 
   @override
   void visitLocalVariableGet(ast.Send node, LocalVariableElement variable, _) {
     handleLocalGet(node, variable);
   }
 
   @override
   void visitParameterGet(ast.Send node, ParameterElement parameter, _) {
     handleLocalGet(node, parameter);
   }
 
   @override
   void visitLocalFunctionGet(ast.Send node, LocalFunctionElement function, _) {
     handleLocalGet(node, function);
   }
 
   @override
-  void visitStaticFieldGet(
-      ast.Send node,
-      FieldElement field,
-      _) {
+  void visitStaticFieldGet(ast.Send node, FieldElement field, _) {
     generateStaticFieldGet(node, field);
   }
 
   @override
-  void visitStaticFunctionGet(
-      ast.Send node,
-      MethodElement function,
-      _) {
+  void visitStaticFunctionGet(ast.Send node, MethodElement function, _) {
     generateStaticFunctionGet(node, function);
   }
 
   @override
-  void visitStaticGetterGet(
-      ast.Send node,
-      FunctionElement getter,
-      _) {
+  void visitStaticGetterGet(ast.Send node, FunctionElement getter, _) {
     generateStaticGetterGet(node, getter);
   }
 
   @override
-  void visitThisPropertyGet(
-      ast.Send node,
-      Name name,
-      _) {
+  void visitThisPropertyGet(ast.Send node, Name name, _) {
     generateDynamicGet(node);
   }
 
   @override
-  void visitTopLevelFieldGet(
-      ast.Send node,
-      FieldElement field,
-      _) {
+  void visitTopLevelFieldGet(ast.Send node, FieldElement field, _) {
     generateStaticFieldGet(node, field);
   }
 
   @override
-  void visitTopLevelFunctionGet(
-      ast.Send node,
-      MethodElement function,
-      _) {
+  void visitTopLevelFunctionGet(ast.Send node, MethodElement function, _) {
     generateStaticFunctionGet(node, function);
   }
 
   @override
-  void visitTopLevelGetterGet(
-      ast.Send node,
-      FunctionElement getter,
-      _) {
+  void visitTopLevelGetterGet(ast.Send node, FunctionElement getter, _) {
     generateStaticGetterGet(node, getter);
   }
 
-  void generateInstanceSetterWithCompiledReceiver(ast.Send send,
-                                                  HInstruction receiver,
-                                                  HInstruction value,
-                                                  {Selector selector,
-                                                   TypeMask mask,
-                                                   ast.Node location}) {
-    assert(invariant(
-        send == null ? location : send,
+  void generateInstanceSetterWithCompiledReceiver(
+      ast.Send send, HInstruction receiver, HInstruction value,
+      {Selector selector, TypeMask mask, ast.Node location}) {
+    assert(invariant(send == null ? location : send,
         send == null || Elements.isInstanceSend(send, elements),
         message: "Unexpected instance setter"
-                 "${send != null ? " element: ${elements[send]}" : ""}"));
+            "${send != null ? " element: ${elements[send]}" : ""}"));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
       if (mask == null) {
         mask = elements.getTypeMask(send);
       }
     }
     if (location == null) {
       assert(send != null);
       location = send;
     }
     assert(selector.isSetter);
     pushInvokeDynamic(location, selector, mask, [receiver, value],
         sourceInformation: sourceInformationBuilder.buildAssignment(location));
     pop();
     stack.add(value);
   }
 
-  void generateNoSuchSetter(ast.Node location,
-                            Element element,
-                            HInstruction value) {
+  void generateNoSuchSetter(
+      ast.Node location, Element element, HInstruction value) {
     List<HInstruction> arguments =
         value == null ? const <HInstruction>[] : <HInstruction>[value];
     // An erroneous element indicates an unresolved static setter.
     generateThrowNoSuchMethod(
         location, noSuchMethodTargetSymbolString(element, 'set'),
         argumentValues: arguments);
   }
 
-  void generateNonInstanceSetter(ast.SendSet send,
-                                 Element element,
-                                 HInstruction value,
-                                 {ast.Node location}) {
+  void generateNonInstanceSetter(
+      ast.SendSet send, Element element, HInstruction value,
+      {ast.Node location}) {
     if (location == null) {
       assert(send != null);
       location = send;
     }
-    assert(invariant(location,
-        send == null || !Elements.isInstanceSend(send, elements),
+    assert(invariant(
+        location, send == null || !Elements.isInstanceSend(send, elements),
         message: "Unexpected non instance setter: $element."));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter) {
         pushInvokeStatic(location, element, <HInstruction>[value]);
         pop();
       } else {
         VariableElement field = element;
         value = potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(element, value), location);
       }
       stack.add(value);
     } else if (Elements.isError(element)) {
-      generateNoSuchSetter(location, element,  send == null ? null : value);
+      generateNoSuchSetter(location, element, send == null ? null : value);
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
     } else {
       stack.add(value);
       LocalElement local = element;
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = local;
       }
@@ skipping 30 matching lines @@
     } else {
       assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       List<js.Expression> templates = <js.Expression>[];
       for (DartType argument in interface.typeArguments) {
         // As we construct the template in stages, we have to make sure that for
         // each part the generated sub-template's holes match the index of the
         // inputs that are later used to instantiate it. We do this by starting
         // the indexing with the number of inputs from previous sub-templates.
-        templates.add(
-            rtiEncoder.getTypeRepresentationWithPlaceholders(
-                argument, (variable) {
-              HInstruction runtimeType = addTypeVariableReference(variable);
-              inputs.add(runtimeType);
-            }, firstPlaceholderIndex: inputs.length));
+        templates.add(rtiEncoder.getTypeRepresentationWithPlaceholders(argument,
+            (variable) {
+          HInstruction runtimeType = addTypeVariableReference(variable);
+          inputs.add(runtimeType);
+        }, firstPlaceholderIndex: inputs.length));
       }
       // TODO(sra): This is a fresh template each time.  We can't let the
       // template manager build them.
-      js.Template code = new js.Template(null,
-                                         new js.ArrayInitializer(templates));
-      HInstruction representation =
-          new HForeignCode(code, backend.readableArrayType, inputs,
-              nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
+      js.Template code =
+          new js.Template(null, new js.ArrayInitializer(templates));
+      HInstruction representation = new HForeignCode(
+          code, backend.readableArrayType, inputs,
+          nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
       return representation;
     }
   }
 
   @override
   void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
       ErroneousElement element = type.element;
       generateTypeError(node, element.message);
     } else {
-      HInstruction converted = buildTypeConversion(
-          expressionInstruction,
-          localsHandler.substInContext(type),
-          HTypeConversion.CAST_TYPE_CHECK);
+      HInstruction converted = buildTypeConversion(expressionInstruction,
+          localsHandler.substInContext(type), HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) add(converted);
       stack.add(converted);
     }
   }
 
   @override
   void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     push(buildIsNode(node, type, expressionInstruction));
   }
 
   @override
   void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     HInstruction instruction = buildIsNode(node, type, expressionInstruction);
     add(instruction);
     push(new HNot(instruction, backend.boolType));
   }
 
-  HInstruction buildIsNode(ast.Node node,
-                           DartType type,
-                           HInstruction expression) {
+  HInstruction buildIsNode(
+      ast.Node node, DartType type, HInstruction expression) {
     type = localsHandler.substInContext(type).unaliased;
     if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
-          new Selector.call(
-              new PrivateName('_isTest', helpers.jsHelperLibrary),
+          new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = helpers.checkSubtype;
-      HInstruction representations =
-          buildTypeArgumentRepresentations(type);
+      HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = compiler.world.hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
-      List<HInstruction> inputs = <HInstruction>[expression,
-                                                 isFieldName,
-                                                 representations,
-                                                 asFieldName];
+      List<HInstruction> inputs = <HInstruction>[
+        expression,
+        isFieldName,
+        representations,
+        asFieldName
+      ];
       pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else if (type.isMalformed) {
       ErroneousElement element = type.element;
       generateTypeError(node, element.message);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
@@ skipping 13 matching lines @@
 
   void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) {
     CallStructure callStructure = elements.getSelector(node).callStructure;
     if (callStructure.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<ast.Node> arguments = node.arguments;
       int positionalArgumentCount = callStructure.positionalArgumentCount;
       for (int i = 0;
-           i < positionalArgumentCount;
-           arguments = arguments.tail, i++) {
+          i < positionalArgumentCount;
+          arguments = arguments.tail, i++) {
         visit(arguments.head);
         list.add(pop());
       }
 
       // Visit named arguments and add them into a temporary map.
-      Map<String, HInstruction> instructions =
-          new Map<String, HInstruction>();
+      Map<String, HInstruction> instructions = new Map<String, HInstruction>();
       List<String> namedArguments = callStructure.namedArguments;
       int nameIndex = 0;
       for (; !arguments.isEmpty; arguments = arguments.tail) {
         visit(arguments.head);
         instructions[namedArguments[nameIndex++]] = pop();
       }
 
       // Iterate through the named arguments to add them to the list
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
       List<String> orderedNames = callStructure.getOrderedNamedArguments();
       for (String name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
   /**
    * Returns a list with the evaluated [arguments] in the normalized order.
    *
    * Precondition: `this.applies(element, world)`.
    * Invariant: [element] must be an implementation element.
    */
   List<HInstruction> makeStaticArgumentList(CallStructure callStructure,
-                                            Link<ast.Node> arguments,
-                                            FunctionElement element) {
+      Link<ast.Node> arguments, FunctionElement element) {
     assert(invariant(element, element.isImplementation));
 
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
     return callStructure.makeArgumentsList(
         arguments,
         element,
         compileArgument,
-        backend.isJsInterop(element) ?
-            handleConstantForOptionalParameterJsInterop :
-            handleConstantForOptionalParameter);
+        backend.isJsInterop(element)
+            ? handleConstantForOptionalParameterJsInterop
+            : handleConstantForOptionalParameter);
   }
 
-  void addGenericSendArgumentsToList(Link<ast.Node> link, List<HInstruction> list) {
+  void addGenericSendArgumentsToList(
+      Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   /// Generate a dynamic method, getter or setter invocation.
   void generateDynamicSend(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     _generateDynamicSend(node, receiver);
   }
 
   void _generateDynamicSend(ast.Send node, HInstruction receiver) {
     Selector selector = elements.getSelector(node);
     TypeMask mask = elements.getTypeMask(node);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildCall(node, node.selector);
 
     List<HInstruction> inputs = <HInstruction>[];
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
     pushInvokeDynamic(node, selector, mask, inputs,
-                      sourceInformation: sourceInformation);
+        sourceInformation: sourceInformation);
     if (selector.isSetter || selector.isIndexSet) {
       pop();
       stack.add(inputs.last);
     }
   }
 
   @override
-  visitDynamicPropertyInvoke(
-      ast.Send node,
-      ast.Node receiver,
-      ast.NodeList arguments,
-      Selector selector,
-      _) {
+  visitDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
+      ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
   }
 
   @override
-  visitIfNotNullDynamicPropertyInvoke(
-      ast.Send node,
-      ast.Node receiver,
-      ast.NodeList arguments,
-      Selector selector,
-      _) {
+  visitIfNotNullDynamicPropertyInvoke(ast.Send node, ast.Node receiver,
+      ast.NodeList arguments, Selector selector, _) {
     /// Desugar `exp?.m()` to `(t1 = exp) == null ? t1 : t1.m()`
     HInstruction receiver;
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-    brancher.handleConditional(
-        () {
-          receiver = generateInstanceSendReceiver(node);
-          pushCheckNull(receiver);
-        },
-        () => stack.add(receiver),
-        () => _generateDynamicSend(node, receiver));
+    brancher.handleConditional(() {
+      receiver = generateInstanceSendReceiver(node);
+      pushCheckNull(receiver);
+    }, () => stack.add(receiver), () => _generateDynamicSend(node, receiver));
   }
 
   @override
   visitThisPropertyInvoke(
-      ast.Send node,
-      ast.NodeList arguments,
-      Selector selector,
-      _) {
+      ast.Send node, ast.NodeList arguments, Selector selector, _) {
     generateDynamicSend(node);
   }
 
   @override
-  visitExpressionInvoke(
-      ast.Send node,
-      ast.Node expression,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    generateCallInvoke(
-        node,
-        visitAndPop(expression),
+  visitExpressionInvoke(ast.Send node, ast.Node expression,
+      ast.NodeList arguments, CallStructure callStructure, _) {
+    generateCallInvoke(node, visitAndPop(expression),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitThisInvoke(
-      ast.Send node,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    generateCallInvoke(
-        node,
-        localsHandler.readThis(),
+      ast.Send node, ast.NodeList arguments, CallStructure callStructure, _) {
+    generateCallInvoke(node, localsHandler.readThis(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  visitParameterInvoke(
-      ast.Send node,
-      ParameterElement parameter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    generateCallInvoke(
-        node,
-            localsHandler.readLocal(parameter),
+  visitParameterInvoke(ast.Send node, ParameterElement parameter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
+    generateCallInvoke(node, localsHandler.readLocal(parameter),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  visitLocalVariableInvoke(
-      ast.Send node,
-      LocalVariableElement variable,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    generateCallInvoke(
-        node,
-        localsHandler.readLocal(variable),
+  visitLocalVariableInvoke(ast.Send node, LocalVariableElement variable,
+      ast.NodeList arguments, CallStructure callStructure, _) {
+    generateCallInvoke(node, localsHandler.readLocal(variable),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  visitLocalFunctionInvoke(
-      ast.Send node,
-      LocalFunctionElement function,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    generateCallInvoke(
-        node,
-        localsHandler.readLocal(function),
+  visitLocalFunctionInvoke(ast.Send node, LocalFunctionElement function,
+      ast.NodeList arguments, CallStructure callStructure, _) {
+    generateCallInvoke(node, localsHandler.readLocal(function),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   visitLocalFunctionIncompatibleInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateCallInvoke(node, localsHandler.readLocal(function),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     // Don't visit the first argument, which is the type, and the second
     // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       // We should not get here because the call should be compiled to NSM.
-      reporter.internalError(node.argumentsNode,
-          'At least two arguments expected.');
+      reporter.internalError(
+          node.argumentsNode, 'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     if (nativeBehavior.codeTemplate.positionalArgumentCount != inputs.length) {
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC,
-          {'text':
-            'Mismatch between number of placeholders'
-            ' and number of arguments.'});
-      stack.add(graph.addConstantNull(compiler));  // Result expected on stack.
+      reporter.reportErrorMessage(node, MessageKind.GENERIC, {
+        'text': 'Mismatch between number of placeholders'
+            ' and number of arguments.'
+      });
+      stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
     if (native.HasCapturedPlaceholders.check(nativeBehavior.codeTemplate.ast)) {
       reporter.reportErrorMessage(node, MessageKind.JS_PLACEHOLDER_CAPTURE);
     }
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
 
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildCall(node, node.argumentsNode);
     if (nativeBehavior.codeTemplate.isExpression) {
-      push(new HForeignCode(
-          nativeBehavior.codeTemplate, ssaType, inputs,
-          effects: nativeBehavior.sideEffects,
-          nativeBehavior: nativeBehavior)
-              ..sourceInformation = sourceInformation);
+      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
+          effects: nativeBehavior.sideEffects, nativeBehavior: nativeBehavior)
+        ..sourceInformation = sourceInformation);
     } else {
-      push(new HForeignCode(
-          nativeBehavior.codeTemplate, ssaType, inputs,
+      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
           isStatement: true,
           effects: nativeBehavior.sideEffects,
           nativeBehavior: nativeBehavior)
-              ..sourceInformation = sourceInformation);
+        ..sourceInformation = sourceInformation);
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       reporter.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], backend.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
-      reporter.internalError(node,
-          'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
+      reporter.internalError(
+          node, 'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
       String name = backend.namer.staticStateHolder;
       push(new HForeignCode(
-          js.js.parseForeignJS(name),
-          backend.dynamicType,
-          <HInstruction>[],
+          js.js.parseForeignJS(name), backend.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = helpers.currentIsolate;
       if (element == null) {
-        reporter.internalError(node,
-            'Isolate library and compiler mismatch.');
+        reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       pushInvokeStatic(null, element, [], typeMask: backend.dynamicType);
     }
   }
 
   void handleForeignJsGetFlag(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
-     ast.Node argument;
-     switch (arguments.length) {
-     case 0:
-       reporter.reportErrorMessage(
-           node, MessageKind.GENERIC,
-           {'text': 'Error: Expected one argument to JS_GET_FLAG.'});
-       return;
-     case 1:
-       argument = arguments[0];
-       break;
-     default:
-       for (int i = 1; i < arguments.length; i++) {
-         reporter.reportErrorMessage(
-             arguments[i], MessageKind.GENERIC,
-             {'text': 'Error: Extra argument to JS_GET_FLAG.'});
-       }
-       return;
-     }
-     ast.LiteralString string = argument.asLiteralString();
-     if (string == null) {
-       reporter.reportErrorMessage(
-           argument, MessageKind.GENERIC,
-           {'text': 'Error: Expected a literal string.'});
-     }
-     String name = string.dartString.slowToString();
-     bool value = false;
-     switch (name) {
-       case 'MUST_RETAIN_METADATA':
-         value = backend.mustRetainMetadata;
-         break;
-       case 'USE_CONTENT_SECURITY_POLICY':
-         value = compiler.options.useContentSecurityPolicy;
-         break;
-       default:
-         reporter.reportErrorMessage(
-             node, MessageKind.GENERIC,
-             {'text': 'Error: Unknown internal flag "$name".'});
-     }
-     stack.add(graph.addConstantBool(value, compiler));
+    ast.Node argument;
+    switch (arguments.length) {
+      case 0:
+        reporter.reportErrorMessage(node, MessageKind.GENERIC,
+            {'text': 'Error: Expected one argument to JS_GET_FLAG.'});
+        return;
+      case 1:
+        argument = arguments[0];
+        break;
+      default:
+        for (int i = 1; i < arguments.length; i++) {
+          reporter.reportErrorMessage(arguments[i], MessageKind.GENERIC,
+              {'text': 'Error: Extra argument to JS_GET_FLAG.'});
+        }
+        return;
+    }
+    ast.LiteralString string = argument.asLiteralString();
+    if (string == null) {
+      reporter.reportErrorMessage(argument, MessageKind.GENERIC,
+          {'text': 'Error: Expected a literal string.'});
+    }
+    String name = string.dartString.slowToString();
+    bool value = false;
+    switch (name) {
+      case 'MUST_RETAIN_METADATA':
+        value = backend.mustRetainMetadata;
+        break;
+      case 'USE_CONTENT_SECURITY_POLICY':
+        value = compiler.options.useContentSecurityPolicy;
+        break;
+      default:
+        reporter.reportErrorMessage(node, MessageKind.GENERIC,
+            {'text': 'Error: Unknown internal flag "$name".'});
+    }
+    stack.add(graph.addConstantBool(value, compiler));
   }
 
   void handleForeignJsGetName(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     switch (arguments.length) {
-    case 0:
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC,
-          {'text': 'Error: Expected one argument to JS_GET_NAME.'});
-      return;
-    case 1:
-      argument = arguments[0];
-      break;
-    default:
-      for (int i = 1; i < arguments.length; i++) {
-        reporter.reportErrorMessage(
-            arguments[i], MessageKind.GENERIC,
-            {'text': 'Error: Extra argument to JS_GET_NAME.'});
-      }
-      return;
+      case 0:
+        reporter.reportErrorMessage(node, MessageKind.GENERIC,
+            {'text': 'Error: Expected one argument to JS_GET_NAME.'});
+        return;
+      case 1:
+        argument = arguments[0];
+        break;
+      default:
+        for (int i = 1; i < arguments.length; i++) {
+          reporter.reportErrorMessage(arguments[i], MessageKind.GENERIC,
+              {'text': 'Error: Extra argument to JS_GET_NAME.'});
+        }
+        return;
     }
     Element element = elements[argument];
     if (element == null ||
         element is! FieldElement ||
         element.enclosingClass != helpers.jsGetNameEnum) {
-      reporter.reportErrorMessage(
-          argument, MessageKind.GENERIC,
+      reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsGetName enum value.'});
     }
     EnumClassElement enumClass = element.enclosingClass;
     int index = enumClass.enumValues.indexOf(element);
-    stack.add(
-        addConstantStringFromName(
-            backend.namer.getNameForJsGetName(
-                argument, JsGetName.values[index])));
+    stack.add(addConstantStringFromName(
+        backend.namer.getNameForJsGetName(argument, JsGetName.values[index])));
   }
 
   void handleForeignJsBuiltin(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     if (arguments.length < 2) {
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC,
+      reporter.reportErrorMessage(node, MessageKind.GENERIC,
           {'text': 'Error: Expected at least two arguments to JS_BUILTIN.'});
     }
 
     Element builtinElement = elements[arguments[1]];
     if (builtinElement == null ||
         (builtinElement is! FieldElement) ||
         builtinElement.enclosingClass != helpers.jsBuiltinEnum) {
-      reporter.reportErrorMessage(
-          argument, MessageKind.GENERIC,
+      reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
     }
     EnumClassElement enumClass = builtinElement.enclosingClass;
     int index = enumClass.enumValues.indexOf(builtinElement);
 
     js.Template template =
         backend.emitter.builtinTemplateFor(JsBuiltin.values[index]);
 
     List<HInstruction> compiledArguments = <HInstruction>[];
     for (int i = 2; i < arguments.length; i++) {
       visit(arguments[i]);
       compiledArguments.add(pop());
     }
 
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
 
-    push(new HForeignCode(template,
-                          ssaType,
-                          compiledArguments,
-                          nativeBehavior: nativeBehavior));
+    push(new HForeignCode(template, ssaType, compiledArguments,
+        nativeBehavior: nativeBehavior));
   }
 
   void handleForeignJsEmbeddedGlobal(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node globalNameNode;
     switch (arguments.length) {
-    case 0:
-    case 1:
-      reporter.reportErrorMessage(
-          node, MessageKind.GENERIC,
-          {'text': 'Error: Expected two arguments to JS_EMBEDDED_GLOBAL.'});
-      return;
-    case 2:
-      // The type has been extracted earlier. We are only interested in the
-      // name in this function.
-      globalNameNode = arguments[1];
-      break;
-    default:
-      for (int i = 2; i < arguments.length; i++) {
-        reporter.reportErrorMessage(
-            arguments[i], MessageKind.GENERIC,
-            {'text': 'Error: Extra argument to JS_EMBEDDED_GLOBAL.'});
-      }
-      return;
+      case 0:
+      case 1:
+        reporter.reportErrorMessage(node, MessageKind.GENERIC,
+            {'text': 'Error: Expected two arguments to JS_EMBEDDED_GLOBAL.'});
+        return;
+      case 2:
+        // The type has been extracted earlier. We are only interested in the
+        // name in this function.
+        globalNameNode = arguments[1];
+        break;
+      default:
+        for (int i = 2; i < arguments.length; i++) {
+          reporter.reportErrorMessage(arguments[i], MessageKind.GENERIC,
+              {'text': 'Error: Extra argument to JS_EMBEDDED_GLOBAL.'});
+        }
+        return;
     }
     visit(globalNameNode);
     HInstruction globalNameHNode = pop();
     if (!globalNameHNode.isConstantString()) {
-      reporter.reportErrorMessage(
-          arguments[1], MessageKind.GENERIC,
-          {'text': 'Error: Expected String as second argument '
-                   'to JS_EMBEDDED_GLOBAL.'});
+      reporter.reportErrorMessage(arguments[1], MessageKind.GENERIC, {
+        'text': 'Error: Expected String as second argument '
+            'to JS_EMBEDDED_GLOBAL.'
+      });
       return;
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
     push(new HForeignCode(expr, ssaType, const [],
-            nativeBehavior: nativeBehavior));
+        nativeBehavior: nativeBehavior));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
       HInstruction argumentInstruction = pop();
       if (argumentInstruction is HConstant) {
         ConstantValue argumentConstant = argumentInstruction.constant;
         if (argumentConstant is TypeConstantValue) {
           ConstantValue constant =
               new InterceptorConstantValue(argumentConstant.representedType);
           HInstruction instruction = graph.addConstant(constant, compiler);
           stack.add(instruction);
           return;
         }
       }
     }
     reporter.reportErrorMessage(
-        node,
-        MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
+        node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(compiler));
   }
 
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       push(new HInvokeClosure(new Selector.callClosure(0),
-                              <HInstruction>[pop()],
-                              backend.dynamicType));
+          <HInstruction>[pop()], backend.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = helpers.callInIsolate;
       if (element == null) {
-        reporter.internalError(node,
-            'Isolate library and compiler mismatch.');
+        reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
       pushInvokeStatic(node, element, inputs, typeMask: backend.dynamicType);
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(ast.Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      reporter.internalError(node.argumentsNode,
-          '"$name" requires exactly one argument.');
+      reporter.internalError(
+          node.argumentsNode, '"$name" requires exactly one argument.');
     }
     ast.Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
-      reporter.internalError(closure,
-          '"$name" requires a static or top-level method.');
+      reporter.internalError(
+          closure, '"$name" requires a static or top-level method.');
     }
     FunctionElement function = element;
     // TODO(johnniwinther): Try to eliminate the need to distinguish declaration
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
-      reporter.internalError(closure,
-          '"$name" does not handle closure with optional parameters.');
+      reporter.internalError(
+          closure, '"$name" does not handle closure with optional parameters.');
     }
 
-    registry?.registerStaticUse(
-        new StaticUse.foreignUse(function));
+    registry?.registerStaticUse(new StaticUse.foreignUse(function));
     push(new HForeignCode(
         js.js.expressionTemplateYielding(
             backend.emitter.staticFunctionAccess(function)),
         backend.dynamicType,
         <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignJsSetStaticState(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
-      reporter.internalError(node.argumentsNode,
-          'Exactly one argument required.');
+      reporter.internalError(
+          node.argumentsNode, 'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
-    push(new HForeignCode(
-        js.js.parseForeignJS("$isolateName = #"),
-        backend.dynamicType,
-        <HInstruction>[pop()],
+    push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
+        backend.dynamicType, <HInstruction>[pop()],
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ast.Send node) {
     if (!node.arguments.isEmpty) {
       reporter.internalError(node.argumentsNode, 'Too many arguments.');
     }
     push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
-                          backend.dynamicType,
-                          <HInstruction>[],
-                          nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
+        backend.dynamicType, <HInstruction>[],
+        nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
   }
 
   void handleForeignSend(ast.Send node, FunctionElement element) {
     String name = element.name;
     if (name == 'JS') {
       handleForeignJs(node);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
       handleForeignJsCurrentIsolateContext(node);
     } else if (name == 'JS_CALL_IN_ISOLATE') {
       handleForeignJsCallInIsolate(node);
@@ skipping 17 matching lines @@
       stack.add(graph.addConstantNull(compiler));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(node);
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(node);
     } else {
       reporter.internalError(node, "Unknown foreign: ${element}");
     }
   }
 
-  generateDeferredLoaderGet(ast.Send node,
-                            FunctionElement deferredLoader,
-                            SourceInformation sourceInformation) {
+  generateDeferredLoaderGet(ast.Send node, FunctionElement deferredLoader,
+      SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
     Element loadFunction = compiler.loadLibraryFunction;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(node, prefixElement);
-    var inputs = [graph.addConstantString(
-        new ast.DartString.literal(loadId), compiler)];
+    var inputs = [
+      graph.addConstantString(new ast.DartString.literal(loadId), compiler)
+    ];
     push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
-                           targetCanThrow: false)
-        ..sourceInformation = sourceInformation);
+        targetCanThrow: false)..sourceInformation = sourceInformation);
   }
 
-  generateSuperNoSuchMethodSend(ast.Send node,
-                                Selector selector,
-                                List<HInstruction> arguments) {
+  generateSuperNoSuchMethodSend(
+      ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       element = coreClasses.objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
     if (compiler.enabledInvokeOn && !element.enclosingClass.isObject) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
-    ConstantValue nameConstant = constantSystem.createString(
-        new ast.DartString.literal(publicName));
+    ConstantValue nameConstant =
+        constantSystem.createString(new ast.DartString.literal(publicName));
 
     js.Name internalName = backend.namer.invocationName(selector);
 
     Element createInvocationMirror = helpers.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
-    pushInvokeStatic(null,
-                     createInvocationMirror,
-                     [graph.addConstant(nameConstant, compiler),
-                      graph.addConstantStringFromName(internalName, compiler),
-                      graph.addConstant(kindConstant, compiler),
-                      argumentsInstruction,
-                      argumentNamesInstruction],
-                     typeMask: backend.dynamicType);
+    pushInvokeStatic(
+        null,
+        createInvocationMirror,
+        [
+          graph.addConstant(nameConstant, compiler),
+          graph.addConstantStringFromName(internalName, compiler),
+          graph.addConstant(kindConstant, compiler),
+          argumentsInstruction,
+          argumentNamesInstruction
+        ],
+        typeMask: backend.dynamicType);
 
     var inputs = <HInstruction>[pop()];
     push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
-  void generateSuperInvoke(ast.Send node,
-                           FunctionElement function,
-                           SourceInformation sourceInformation) {
+  void generateSuperInvoke(ast.Send node, FunctionElement function,
+      SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
-    assert(invariant(node,
-        selector.applies(function.implementation, compiler.world),
+    assert(invariant(
+        node, selector.applies(function.implementation, compiler.world),
         message: "$selector does not apply to ${function.implementation}"));
-    List<HInstruction> inputs =
-        makeStaticArgumentList(selector.callStructure,
-                               node.arguments,
-                               function.implementation);
+    List<HInstruction> inputs = makeStaticArgumentList(
+        selector.callStructure, node.arguments, function.implementation);
     push(buildInvokeSuper(selector, function, inputs, sourceInformation));
   }
 
   /// Access the value from the super [element].
   void handleSuperGet(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     push(buildInvokeSuper(
         selector, element, const <HInstruction>[], sourceInformation));
   }
 
   /// Invoke .call on the value retrieved from the super [element].
   void handleSuperCallInvoke(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
-    HInstruction target = buildInvokeSuper(
-        selector, element, const <HInstruction>[],
-        sourceInformationBuilder.buildGet(node));
+    HInstruction target = buildInvokeSuper(selector, element,
+        const <HInstruction>[], sourceInformationBuilder.buildGet(node));
     add(target);
-    generateCallInvoke(
-        node,
-        target,
+    generateCallInvoke(node, target,
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   /// Invoke super [method].
-  void handleSuperMethodInvoke(
-      ast.Send node,
-      MethodElement method) {
-    generateSuperInvoke(node, method,
-        sourceInformationBuilder.buildCall(node, node.selector));
+  void handleSuperMethodInvoke(ast.Send node, MethodElement method) {
+    generateSuperInvoke(
+        node, method, sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   /// Access an unresolved super property.
   void handleUnresolvedSuperInvoke(ast.Send node) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> arguments = <HInstruction>[];
     if (!node.isPropertyAccess) {
       addGenericSendArgumentsToList(node.arguments, arguments);
     }
     generateSuperNoSuchMethodSend(node, selector, arguments);
   }
 
   @override
   void visitUnresolvedSuperIndex(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      _) {
+      ast.Send node, Element element, ast.Node index, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
   void visitUnresolvedSuperUnary(
-      ast.Send node,
-      UnaryOperator operator,
-      Element element,
-      _) {
+      ast.Send node, UnaryOperator operator, Element element, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
-  void visitUnresolvedSuperBinary(
-      ast.Send node,
-      Element element,
-      BinaryOperator operator,
-      ast.Node argument,
-      _) {
+  void visitUnresolvedSuperBinary(ast.Send node, Element element,
+      BinaryOperator operator, ast.Node argument, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
-  void visitUnresolvedSuperGet(
-      ast.Send node,
-      Element element,
-      _) {
+  void visitUnresolvedSuperGet(ast.Send node, Element element, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
   void visitUnresolvedSuperSet(
-      ast.Send node,
-      Element element,
-      ast.Node rhs,
-      _) {
+      ast.Send node, Element element, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperSetterGet(
-      ast.Send node,
-      MethodElement setter,
-      _) {
+  void visitSuperSetterGet(ast.Send node, MethodElement setter, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
   void visitUnresolvedSuperInvoke(
-      ast.Send node,
-      Element element,
-      ast.Node argument,
-      Selector selector,
-      _) {
+      ast.Send node, Element element, ast.Node argument, Selector selector, _) {
     handleUnresolvedSuperInvoke(node);
   }
 
   @override
-  void visitSuperFieldGet(
-      ast.Send node,
-      FieldElement field,
-      _) {
+  void visitSuperFieldGet(ast.Send node, FieldElement field, _) {
     handleSuperGet(node, field);
   }
 
   @override
-  void visitSuperGetterGet(
-      ast.Send node,
-      MethodElement method,
-      _) {
+  void visitSuperGetterGet(ast.Send node, MethodElement method, _) {
     handleSuperGet(node, method);
   }
 
   @override
-  void visitSuperMethodGet(
-      ast.Send node,
-      MethodElement method,
-      _) {
+  void visitSuperMethodGet(ast.Send node, MethodElement method, _) {
     handleSuperGet(node, method);
   }
 
   @override
-  void visitSuperFieldInvoke(
-      ast.Send node,
-      FieldElement field,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitSuperFieldInvoke(ast.Send node, FieldElement field,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleSuperCallInvoke(node, field);
   }
 
   @override
-  void visitSuperGetterInvoke(
-      ast.Send node,
-      MethodElement getter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitSuperGetterInvoke(ast.Send node, MethodElement getter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleSuperCallInvoke(node, getter);
   }
 
   @override
-  void visitSuperMethodInvoke(
-      ast.Send node,
-      MethodElement method,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitSuperMethodInvoke(ast.Send node, MethodElement method,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
-  void visitSuperIndex(
-      ast.Send node,
-      MethodElement method,
-      ast.Node index,
-      _) {
+  void visitSuperIndex(ast.Send node, MethodElement method, ast.Node index, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
   void visitSuperEquals(
-      ast.Send node,
-      MethodElement method,
-      ast.Node argument,
-      _) {
+      ast.Send node, MethodElement method, ast.Node argument, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
-  void visitSuperBinary(
-      ast.Send node,
-      MethodElement method,
-      BinaryOperator operator,
-      ast.Node argument,
-      _) {
+  void visitSuperBinary(ast.Send node, MethodElement method,
+      BinaryOperator operator, ast.Node argument, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
   void visitSuperNotEquals(
-      ast.Send node,
-      MethodElement method,
-      ast.Node argument,
-      _) {
+      ast.Send node, MethodElement method, ast.Node argument, _) {
     handleSuperMethodInvoke(node, method);
     pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
   }
 
   @override
   void visitSuperUnary(
-      ast.Send node,
-      UnaryOperator operator,
-      MethodElement method,
-      _) {
+      ast.Send node, UnaryOperator operator, MethodElement method, _) {
     handleSuperMethodInvoke(node, method);
   }
 
   @override
-  void visitSuperMethodIncompatibleInvoke(
-      ast.Send node,
-      MethodElement method,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitSuperMethodIncompatibleInvoke(ast.Send node, MethodElement method,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidSuperInvoke(node, arguments);
   }
 
   @override
-  void visitSuperSetterInvoke(
-      ast.Send node,
-      SetterElement setter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitSuperSetterInvoke(ast.Send node, SetterElement setter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidSuperInvoke(node, arguments);
   }
 
   void handleInvalidSuperInvoke(ast.Send node, ast.NodeList arguments) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(arguments.nodes, inputs);
     generateSuperNoSuchMethodSend(node, selector, inputs);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     ClassWorld classWorld = compiler.world;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
     return compiler.world.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   /**
    * Generate code to extract the type arguments from the object, substitute
    * them as an instance of the type we are testing against (if necessary), and
    * extract the type argument by the index of the variable in the list of type
    * variables for that class.
    */
-  HInstruction readTypeVariable(
-      ClassElement cls,
-      TypeVariableElement variable,
+  HInstruction readTypeVariable(ClassElement cls, TypeVariableElement variable,
       {SourceInformation sourceInformation}) {
     assert(sourceElement.isInstanceMember);
 
     HInstruction target = localsHandler.readThis();
     HConstant index = graph.addConstantInt(variable.index, compiler);
 
     if (needsSubstitutionForTypeVariableAccess(cls)) {
       // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
       // string concatenation in the implementation), and may prevent
       // segmentation of '$'.
       js.Name substitutionName = backend.namer.runtimeTypeName(cls);
-      HInstruction substitutionNameInstr = graph.addConstantStringFromName(
-          substitutionName, compiler);
-      pushInvokeStatic(null,
-                       helpers.getRuntimeTypeArgument,
-                       [target, substitutionNameInstr, index],
-                       typeMask: backend.dynamicType,
-                       sourceInformation: sourceInformation);
+      HInstruction substitutionNameInstr =
+          graph.addConstantStringFromName(substitutionName, compiler);
+      pushInvokeStatic(null, helpers.getRuntimeTypeArgument,
+          [target, substitutionNameInstr, index],
+          typeMask: backend.dynamicType, sourceInformation: sourceInformation);
     } else {
-      pushInvokeStatic(
-          null,
-          helpers.getTypeArgumentByIndex,
-          [target, index],
-          typeMask: backend.dynamicType,
-          sourceInformation: sourceInformation);
+      pushInvokeStatic(null, helpers.getTypeArgumentByIndex, [target, index],
+          typeMask: backend.dynamicType, sourceInformation: sourceInformation);
     }
     return pop();
   }
 
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
   bool hasDirectLocal(Local local) {
     return !localsHandler.isAccessedDirectly(local) ||
-            localsHandler.directLocals[local] != null;
+        localsHandler.directLocals[local] != null;
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
-  HInstruction addTypeVariableReference(
-      TypeVariableType type,
+  HInstruction addTypeVariableReference(TypeVariableType type,
       {SourceInformation sourceInformation}) {
-
     assert(assertTypeInContext(type));
     Element member = sourceElement;
     bool isClosure = member.enclosingElement.isClosure;
     if (isClosure) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
       member = member.outermostEnclosingMemberOrTopLevel;
     }
-    bool isInConstructorContext = member.isConstructor ||
-        member.isGenerativeConstructorBody;
+    bool isInConstructorContext =
+        member.isConstructor || member.isGenerativeConstructorBody;
     Local typeVariableLocal = localsHandler.getTypeVariableAsLocal(type);
     if (isClosure) {
       if (member.isFactoryConstructor ||
           (isInConstructorContext && hasDirectLocal(typeVariableLocal))) {
         // The type variable is used from a closure in a factory constructor.
         // The value of the type argument is stored as a local on the closure
         // itself.
-        return localsHandler.readLocal(
-            typeVariableLocal, sourceInformation: sourceInformation);
+        return localsHandler.readLocal(typeVariableLocal,
+            sourceInformation: sourceInformation);
       } else if (member.isFunction ||
-                 member.isGetter ||
-                 member.isSetter ||
-                 isInConstructorContext) {
+          member.isGetter ||
+          member.isSetter ||
+          isInConstructorContext) {
         // The type variable is stored on the "enclosing object" and needs to be
         // accessed using the this-reference in the closure.
-        return readTypeVariable(
-            member.enclosingClass,
-            type.element,
+        return readTypeVariable(member.enclosingClass, type.element,
             sourceInformation: sourceInformation);
       } else {
         assert(member.isField);
         // The type variable is stored in a parameter of the method.
         return localsHandler.readLocal(typeVariableLocal);
       }
     } else if (isInConstructorContext ||
-               // When [member] is a field, we can be either
-               // generating a checked setter or inlining its
-               // initializer in a constructor. An initializer is
-               // never built standalone, so in that case [target] is not
-               // the [member] itself.
-               (member.isField && member != target)) {
+        // When [member] is a field, we can be either
+        // generating a checked setter or inlining its
+        // initializer in a constructor. An initializer is
+        // never built standalone, so in that case [target] is not
+        // the [member] itself.
+        (member.isField && member != target)) {
       // The type variable is stored in a parameter of the method.
-      return localsHandler.readLocal(
-          typeVariableLocal, sourceInformation: sourceInformation);
+      return localsHandler.readLocal(typeVariableLocal,
+          sourceInformation: sourceInformation);
     } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
-      return readTypeVariable(
-          member.enclosingClass,
-          type.element,
+      return readTypeVariable(member.enclosingClass, type.element,
           sourceInformation: sourceInformation);
     } else {
-      reporter.internalError(type.element,
-          'Unexpected type variable in static context.');
+      reporter.internalError(
+          type.element, 'Unexpected type variable in static context.');
       return null;
     }
   }
 
-  HInstruction analyzeTypeArgument(
-      DartType argument,
+  HInstruction analyzeTypeArgument(DartType argument,
       {SourceInformation sourceInformation}) {
-
     assert(assertTypeInContext(argument));
     if (argument.treatAsDynamic) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     if (argument.isTypeVariable) {
-      return addTypeVariableReference(
-          argument, sourceInformation: sourceInformation);
+      return addTypeVariableReference(argument,
+          sourceInformation: sourceInformation);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     js.Expression template =
         rtiEncoder.getTypeRepresentationWithPlaceholders(argument, (variable) {
-            inputs.add(addTypeVariableReference(variable));
-        });
+      inputs.add(addTypeVariableReference(variable));
+    });
 
     js.Template code = new js.Template(null, template);
     HInstruction result = new HForeignCode(code, backend.stringType, inputs,
         nativeBehavior: native.NativeBehavior.PURE);
     add(result);
     return result;
   }
 
-  HInstruction handleListConstructor(InterfaceType type,
-                                     ast.Node currentNode,
-                                     HInstruction newObject) {
+  HInstruction handleListConstructor(
+      InterfaceType type, ast.Node currentNode, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
     Element copyHelper = helpers.copyTypeArguments;
     pushInvokeStatic(null, copyHelper, [source, target],
         sourceInformation: target.sourceInformation);
     pop();
   }
 
   HInstruction callSetRuntimeTypeInfo(ClassElement element,
-                                      List<HInstruction> rtiInputs,
-                                      HInstruction newObject) {
+      List<HInstruction> rtiInputs, HInstruction newObject) {
     if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
       return newObject;
     }
 
     HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
-        null,
-        typeInfoSetterElement,
-        <HInstruction>[newObject, typeInfo],
+        null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
         typeMask: backend.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
-    assert(invariant(
-        CURRENT_ELEMENT_SPANNABLE,
+    assert(invariant(CURRENT_ELEMENT_SPANNABLE,
         stack.last is HInvokeStatic || stack.last == newObject,
-        message:
-          "Unexpected `stack.last`: Found ${stack.last}, "
-          "expected ${newObject} or an HInvokeStatic. "
-          "State: element=$element, rtiInputs=$rtiInputs, stack=$stack."));
+        message: "Unexpected `stack.last`: Found ${stack.last}, "
+            "expected ${newObject} or an HInvokeStatic. "
+            "State: element=$element, rtiInputs=$rtiInputs, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
     bool isFixedList = false;
     bool isFixedListConstructorCall =
         Elements.isFixedListConstructorCall(elements[send], send, compiler);
     bool isGrowableListConstructorCall =
         Elements.isGrowableListConstructorCall(elements[send], send, compiler);
 
     TypeMask computeType(element) {
       Element originalElement = elements[send];
-      if (isFixedListConstructorCall
-          || Elements.isFilledListConstructorCall(
-                  originalElement, send, compiler)) {
+      if (isFixedListConstructorCall ||
+          Elements.isFilledListConstructorCall(
+              originalElement, send, compiler)) {
         isFixedList = true;
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
         return inferred.containsAll(compiler.world)
             ? backend.fixedArrayType
             : inferred;
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
         return inferred.containsAll(compiler.world)
             ? backend.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
-                    originalElement, compiler)) {
+          originalElement, compiler)) {
         isFixedList = true;
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
         ClassElement cls = element.enclosingClass;
         assert(backend.isNative(cls.thisType.element));
         return inferred.containsAll(compiler.world)
             ? new TypeMask.nonNullExact(cls.thisType.element, compiler.world)
             : inferred;
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
@@ skipping 17 matching lines @@
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
         constructorDeclaration == compiler.symbolConstructor;
     final bool isJSArrayTypedConstructor =
         constructorDeclaration == helpers.jsArrayTypedConstructor;
 
     if (isSymbolConstructor) {
       constructor = compiler.symbolValidatedConstructor;
       assert(invariant(send, constructor != null,
-                       message: 'Constructor Symbol.validated is missing'));
+          message: 'Constructor Symbol.validated is missing'));
       callStructure = compiler.symbolValidatedConstructorSelector.callStructure;
       assert(invariant(send, callStructure != null,
-                       message: 'Constructor Symbol.validated is missing'));
+          message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = constructorDeclaration.isRedirectingFactory;
     if (!constructorDeclaration.isCyclicRedirection) {
       // Insert a check for every deferred redirection on the path to the
       // final target.
       ConstructorElement target = constructorDeclaration;
       while (target.isRedirectingFactory) {
         if (constructorDeclaration.redirectionDeferredPrefix != null) {
           generateIsDeferredLoadedCheckIfNeeded(
-              target.redirectionDeferredPrefix,
-              node);
+              target.redirectionDeferredPrefix, node);
         }
         target = target.immediateRedirectionTarget;
       }
     }
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor)) {
@@ skipping 15 matching lines @@
         pop();
       });
       generateAbstractClassInstantiationError(send, cls.name);
       return;
     }
 
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     constructorImplementation = constructor.implementation;
     if (constructorImplementation.isMalformed ||
-        !callStructure.signatureApplies(
-            constructorImplementation.functionSignature)) {
+        !callStructure
+            .signatureApplies(constructorImplementation.functionSignature)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
     var inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         backend.isNativeOrExtendsNative(constructor.enclosingClass) &&
         !backend.isJsInterop(constructor)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
-    inputs.addAll(makeStaticArgumentList(callStructure,
-                                         send.arguments,
-                                         constructorImplementation));
+    inputs.addAll(makeStaticArgumentList(
+        callStructure, send.arguments, constructorImplementation));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(compiler)) {
         HTypeConversion conversion = new HTypeConversion(
-          null, HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType,
-          inputs[0], null);
+            null,
+            HTypeConversion.ARGUMENT_TYPE_CHECK,
+            backend.numType,
+            inputs[0],
+            null);
         add(conversion);
         inputs[0] = conversion;
       }
       js.Template code = js.js.parseForeignJS('new Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double or
       // outside the unsigned 32 bit range.
       // TODO(sra): Array allocation should be an instruction so that canThrow
       // can depend on a length type discovered in optimization.
       bool canThrow = true;
       if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
         var constant = inputs[0];
         int value = constant.constant.primitiveValue;
         if (0 <= value && value < 0x100000000) canThrow = false;
       }
       HForeignCode foreign = new HForeignCode(code, elementType, inputs,
           nativeBehavior: behavior,
           throwBehavior: canThrow
               ? native.NativeThrowBehavior.MAY
               : native.NativeThrowBehavior.NEVER);
       push(foreign);
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeignCode(code, backend.nullType, [stack.last],
-                throwBehavior: native.NativeThrowBehavior.MAY));
+            throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       SourceInformation sourceInformation =
           sourceInformationBuilder.buildNew(send);
       potentiallyAddTypeArguments(inputs, cls, expectedType);
       addInlinedInstantiation(expectedType);
       pushInvokeStatic(node, constructor, inputs,
@@ skipping 10 matching lines @@
       if (context != null) {
         context.allocatedFixedLists.add(newInstance);
       }
     }
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
     if (backend.classNeedsRti(coreClasses.listClass) &&
-        (isFixedListConstructorCall || isGrowableListConstructorCall ||
-         isJSArrayTypedConstructor)) {
+        (isFixedListConstructorCall ||
+            isGrowableListConstructorCall ||
+            isJSArrayTypedConstructor)) {
       newInstance = handleListConstructor(type, send, pop());
       stack.add(newInstance);
     }
 
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
       HInstruction checked = potentiallyCheckOrTrustType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
-  void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
-                                   InterfaceType expectedType,
-                                   {SourceInformation sourceInformation}) {
+  void potentiallyAddTypeArguments(
+      List<HInstruction> inputs, ClassElement cls, InterfaceType expectedType,
+      {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
     assert(expectedType.typeArguments.isEmpty ||
         cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
-      inputs.add(analyzeTypeArgument(
-          argument, sourceInformation: sourceInformation));
+      inputs.add(
+          analyzeTypeArgument(argument, sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.options.enableTypeAssertions) return false;
 
     Map<DartType, Set<DartType>> seenChecksMap =
         new Map<DartType, Set<DartType>>();
     bool definitelyFails = false;
 
-    addTypeVariableBoundCheck(GenericType instance,
-                              DartType typeArgument,
-                              TypeVariableType typeVariable,
-                              DartType bound) {
+    addTypeVariableBoundCheck(GenericType instance, DartType typeArgument,
+        TypeVariableType typeVariable, DartType bound) {
       if (definitelyFails) return;
 
-      int subtypeRelation = compiler.types.computeSubtypeRelation(typeArgument, bound);
+      int subtypeRelation =
+          compiler.types.computeSubtypeRelation(typeArgument, bound);
       if (subtypeRelation == Types.IS_SUBTYPE) return;
 
-      String message =
-          "Can't create an instance of malbounded type '$type': "
+      String message = "Can't create an instance of malbounded type '$type': "
           "'${typeArgument}' is not a subtype of bound '${bound}' for "
           "type variable '${typeVariable}' of type "
           "${type == instance
               ? "'${type.element.thisType}'"
               : "'${instance.element.thisType}' on the supertype "
                 "'${instance}' of '${type}'"
             }.";
       if (subtypeRelation == Types.NOT_SUBTYPE) {
         generateTypeError(node, message);
         definitelyFails = true;
         return;
       } else if (subtypeRelation == Types.MAYBE_SUBTYPE) {
         Set<DartType> seenChecks =
             seenChecksMap.putIfAbsent(typeArgument, () => new Set<DartType>());
         if (!seenChecks.contains(bound)) {
           seenChecks.add(bound);
           assertIsSubtype(node, typeArgument, bound, message);
         }
       }
     }
 
     compiler.types.checkTypeVariableBounds(type, addTypeVariableBoundCheck);
     if (definitelyFails) {
       return true;
     }
     for (InterfaceType supertype in type.element.allSupertypes) {
       DartType instance = type.asInstanceOf(supertype.element);
-      compiler.types.checkTypeVariableBounds(instance,
-          addTypeVariableBoundCheck);
+      compiler.types
+          .checkTypeVariableBounds(instance, addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
-      ast.Send node,
-      FunctionElement function,
-      CallStructure callStructure) {
+      ast.Send node, FunctionElement function, CallStructure callStructure) {
     List<HInstruction> inputs = makeStaticArgumentList(
-        callStructure,
-        node.arguments,
-        function.implementation);
+        callStructure, node.arguments, function.implementation);
 
     if (function == compiler.identicalFunction) {
       pushWithPosition(
           new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
       return;
     } else {
       pushInvokeStatic(node, function, inputs,
-          sourceInformation: sourceInformationBuilder.buildCall(
-              node, node.selector));
+          sourceInformation:
+              sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
   /// Generate an invocation to a static or top level function with the wrong
   /// number of arguments.
-  void generateStaticFunctionIncompatibleInvoke(ast.Send node,
-                                                Element element) {
+  void generateStaticFunctionIncompatibleInvoke(
+      ast.Send node, Element element) {
     generateWrongArgumentCountError(node, element, node.arguments);
   }
 
   @override
-  void visitStaticFieldInvoke(
-      ast.Send node,
-      FieldElement field,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitStaticFieldInvoke(ast.Send node, FieldElement field,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticFieldGet(node, field);
-    generateCallInvoke(
-        node,
-        pop(),
+    generateCallInvoke(node, pop(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  void visitStaticFunctionInvoke(
-      ast.Send node,
-      MethodElement function,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitStaticFunctionInvoke(ast.Send node, MethodElement function,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticFunctionInvoke(node, function, callStructure);
   }
 
   @override
   void visitStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticFunctionIncompatibleInvoke(node, function);
   }
 
   @override
-  void visitStaticGetterInvoke(
-      ast.Send node,
-      FunctionElement getter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitStaticGetterInvoke(ast.Send node, FunctionElement getter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticGetterGet(node, getter);
-    generateCallInvoke(
-        node,
-        pop(),
+    generateCallInvoke(node, pop(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  void visitTopLevelFieldInvoke(
-      ast.Send node,
-      FieldElement field,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitTopLevelFieldInvoke(ast.Send node, FieldElement field,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticFieldGet(node, field);
-    generateCallInvoke(
-        node,
-        pop(),
+    generateCallInvoke(node, pop(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  void visitTopLevelFunctionInvoke(
-      ast.Send node,
-      MethodElement function,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitTopLevelFunctionInvoke(ast.Send node, MethodElement function,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     if (backend.isForeign(function)) {
       handleForeignSend(node, function);
     } else {
       generateStaticFunctionInvoke(node, function, callStructure);
     }
   }
 
   @override
   void visitTopLevelFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticFunctionIncompatibleInvoke(node, function);
   }
 
   @override
-  void visitTopLevelGetterInvoke(
-      ast.Send node,
-      FunctionElement getter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitTopLevelGetterInvoke(ast.Send node, FunctionElement getter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticGetterGet(node, getter);
-    generateCallInvoke(
-        node,
-        pop(),
+    generateCallInvoke(node, pop(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
-  void visitTopLevelSetterGet(
-      ast.Send node,
-      MethodElement setter,
-      _) {
+  void visitTopLevelSetterGet(ast.Send node, MethodElement setter, _) {
     handleInvalidStaticGet(node, setter);
   }
 
   @override
-  void visitStaticSetterGet(
-      ast.Send node,
-      MethodElement setter,
-      _) {
+  void visitStaticSetterGet(ast.Send node, MethodElement setter, _) {
     handleInvalidStaticGet(node, setter);
   }
 
   @override
-  void visitUnresolvedGet(
-      ast.Send node,
-      Element element,
-      _) {
+  void visitUnresolvedGet(ast.Send node, Element element, _) {
     generateStaticUnresolvedGet(node, element);
   }
 
   void handleInvalidStaticInvoke(ast.Send node, Element element) {
-    generateThrowNoSuchMethod(node,
-                              noSuchMethodTargetSymbolString(element),
-                              argumentNodes: node.arguments);
+    generateThrowNoSuchMethod(node, noSuchMethodTargetSymbolString(element),
+        argumentNodes: node.arguments);
   }
 
   @override
-  void visitStaticSetterInvoke(
-      ast.Send node,
-      MethodElement setter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitStaticSetterInvoke(ast.Send node, MethodElement setter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidStaticInvoke(node, setter);
   }
 
   @override
-  void visitTopLevelSetterInvoke(
-      ast.Send node,
-      MethodElement setter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  void visitTopLevelSetterInvoke(ast.Send node, MethodElement setter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     handleInvalidStaticInvoke(node, setter);
   }
 
   @override
-  void visitUnresolvedInvoke(
-      ast.Send node,
-      Element element,
-      ast.NodeList arguments,
-      Selector selector,
-      _) {
+  void visitUnresolvedInvoke(ast.Send node, Element element,
+      ast.NodeList arguments, Selector selector, _) {
     if (element is ErroneousElement) {
       // An erroneous element indicates that the function could not be
       // resolved (a warning has been issued).
       handleInvalidStaticInvoke(node, element);
     } else {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
     }
     return;
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     return graph.addConstantString(dartString, compiler);
   }
 
   HConstant addConstantStringFromName(js.Name name) {
     return graph.addConstantStringFromName(name, compiler);
   }
 
-  visitClassTypeLiteralGet(
-      ast.Send node,
-      ConstantExpression constant,
-      _) {
+  visitClassTypeLiteralGet(ast.Send node, ConstantExpression constant, _) {
     generateConstantTypeLiteral(node);
   }
 
-  visitClassTypeLiteralInvoke(
-      ast.Send node,
-      ConstantExpression constant,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  visitClassTypeLiteralInvoke(ast.Send node, ConstantExpression constant,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateConstantTypeLiteral(node);
     generateTypeLiteralCall(node);
   }
 
-  visitTypedefTypeLiteralGet(
-      ast.Send node,
-      ConstantExpression constant,
-      _) {
+  visitTypedefTypeLiteralGet(ast.Send node, ConstantExpression constant, _) {
     generateConstantTypeLiteral(node);
   }
 
-  visitTypedefTypeLiteralInvoke(
-      ast.Send node,
-      ConstantExpression constant,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  visitTypedefTypeLiteralInvoke(ast.Send node, ConstantExpression constant,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateConstantTypeLiteral(node);
     generateTypeLiteralCall(node);
   }
 
   visitTypeVariableTypeLiteralGet(
-      ast.Send node,
-      TypeVariableElement element,
-      _) {
+      ast.Send node, TypeVariableElement element, _) {
     generateTypeVariableLiteral(node, element.type);
   }
 
-  visitTypeVariableTypeLiteralInvoke(
-      ast.Send node,
-      TypeVariableElement element,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  visitTypeVariableTypeLiteralInvoke(ast.Send node, TypeVariableElement element,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateTypeVariableLiteral(node, element.type);
     generateTypeLiteralCall(node);
   }
 
-  visitDynamicTypeLiteralGet(
-      ast.Send node,
-      ConstantExpression constant,
-      _) {
+  visitDynamicTypeLiteralGet(ast.Send node, ConstantExpression constant, _) {
     generateConstantTypeLiteral(node);
   }
 
-  visitDynamicTypeLiteralInvoke(
-      ast.Send node,
-      ConstantExpression constant,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  visitDynamicTypeLiteralInvoke(ast.Send node, ConstantExpression constant,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     generateConstantTypeLiteral(node);
     generateTypeLiteralCall(node);
   }
 
   /// Generate the constant value for a constant type literal.
   void generateConstantTypeLiteral(ast.Send node) {
     // TODO(karlklose): add type representation
     if (node.isCall) {
       // The node itself is not a constant but we register the selector (the
       // identifier that refers to the class/typedef) as a constant.
       stack.add(addConstant(node.selector));
     } else {
       stack.add(addConstant(node));
     }
   }
 
   /// Generate the literal for [typeVariable] in the current context.
-  void generateTypeVariableLiteral(ast.Send node,
-                                   TypeVariableType typeVariable) {
+  void generateTypeVariableLiteral(
+      ast.Send node, TypeVariableType typeVariable) {
     DartType type = localsHandler.substInContext(typeVariable);
     HInstruction value = analyzeTypeArgument(type,
         sourceInformation: sourceInformationBuilder.buildGet(node));
-    pushInvokeStatic(node,
-                     helpers.runtimeTypeToString,
-                     [value],
-                     typeMask: backend.stringType);
-    pushInvokeStatic(node,
-                     helpers.createRuntimeType,
-                     [pop()]);
+    pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
+        typeMask: backend.stringType);
+    pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
     // This send is of the form 'e(...)', where e is resolved to a type
     // reference. We create a regular closure call on the result of the type
     // reference instead of creating a NoSuchMethodError to avoid pulling it
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
     generateCallInvoke(node, target,
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   /// Generate a '.call' invocation on [target].
-  void generateCallInvoke(ast.Send node,
-                          HInstruction target,
-                          SourceInformation sourceInformation) {
+  void generateCallInvoke(
+      ast.Send node, HInstruction target, SourceInformation sourceInformation) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[target];
     addDynamicSendArgumentsToList(node, inputs);
     push(new HInvokeClosure(
-            new Selector.callClosureFrom(selector),
-            inputs, backend.dynamicType)
-        ..sourceInformation = sourceInformation);
+        new Selector.callClosureFrom(selector), inputs, backend.dynamicType)
+      ..sourceInformation = sourceInformation);
   }
 
   visitGetterSend(ast.Send node) {
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(Spannable node, String reason) {
     reporter.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
     generateError(node, message, helpers.throwRuntimeError);
   }
 
   void generateTypeError(ast.Node node, String message) {
     generateError(node, message, helpers.throwTypeError);
   }
 
   void generateAbstractClassInstantiationError(ast.Node node, String message) {
-    generateError(node,
-                  message,
-                  helpers.throwAbstractClassInstantiationError);
+    generateError(node, message, helpers.throwAbstractClassInstantiationError);
   }
 
-  void generateThrowNoSuchMethod(ast.Node diagnosticNode,
-                                 String methodName,
-                                 {Link<ast.Node> argumentNodes,
-                                  List<HInstruction> argumentValues,
-                                  List<String> existingArguments,
-                                  SourceInformation sourceInformation}) {
+  void generateThrowNoSuchMethod(ast.Node diagnosticNode, String methodName,
+      {Link<ast.Node> argumentNodes,
+      List<HInstruction> argumentValues,
+      List<String> existingArguments,
+      SourceInformation sourceInformation}) {
     Element helper = helpers.throwNoSuchMethod;
     ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
     HInstruction receiver = graph.addConstant(receiverConstant, compiler);
     ast.DartString dartString = new ast.DartString.literal(methodName);
     ConstantValue nameConstant = constantSystem.createString(dartString);
     HInstruction name = graph.addConstant(nameConstant, compiler);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
@@ skipping 10 matching lines @@
       for (String name in existingArguments) {
         HInstruction nameConstant =
             graph.addConstantString(new ast.DartString.literal(name), compiler);
         existingNames.add(nameConstant);
       }
       existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
       existingNamesList = graph.addConstantNull(compiler);
     }
-    pushInvokeStatic(diagnosticNode,
-                     helper,
-                     [receiver, name, arguments, existingNamesList],
-                     sourceInformation: sourceInformation);
+    pushInvokeStatic(
+        diagnosticNode, helper, [receiver, name, arguments, existingNamesList],
+        sourceInformation: sourceInformation);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
    */
   void generateWrongArgumentCountError(ast.Node diagnosticNode,
-                                       FunctionElement function,
-                                       Link<ast.Node> argumentNodes) {
+      FunctionElement function, Link<ast.Node> argumentNodes) {
     List<String> existingArguments = <String>[];
     FunctionSignature signature = function.functionSignature;
     signature.forEachParameter((Element parameter) {
       existingArguments.add(parameter.name);
     });
-    generateThrowNoSuchMethod(diagnosticNode,
-                              function.name,
-                              argumentNodes: argumentNodes,
-                              existingArguments: existingArguments);
+    generateThrowNoSuchMethod(diagnosticNode, function.name,
+        argumentNodes: argumentNodes, existingArguments: existingArguments);
   }
 
   @override
   void bulkHandleNode(ast.Node node, String message, _) {
     internalError(node, "Unexpected bulk handled node: $node");
   }
 
   @override
   void bulkHandleNew(ast.NewExpression node, [_]) {
     Element element = elements[node.send];
     final bool isSymbolConstructor = element == compiler.symbolConstructor;
     if (!Elements.isMalformed(element)) {
       ConstructorElement function = element;
       element = function.effectiveTarget;
     }
     if (Elements.isError(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR ||
           error.messageKind == MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR) {
         generateThrowNoSuchMethod(
-            node.send,
-            noSuchMethodTargetSymbolString(error, 'constructor'),
+            node.send, noSuchMethodTargetSymbolString(error, 'constructor'),
             argumentNodes: node.send.arguments);
       } else {
         MessageTemplate template = MessageTemplate.TEMPLATES[error.messageKind];
         Message message = template.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
     } else if (node.isConst) {
@@ skipping 13 matching lines @@
   void errorNonConstantConstructorInvoke(
       ast.NewExpression node,
       Element element,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     bulkHandleNew(node);
   }
 
-  void pushInvokeDynamic(ast.Node node,
-                         Selector selector,
-                         TypeMask mask,
-                         List<HInstruction> arguments,
-                         {SourceInformation sourceInformation}) {
-
+  void pushInvokeDynamic(ast.Node node, Selector selector, TypeMask mask,
+      List<HInstruction> arguments,
+      {SourceInformation sourceInformation}) {
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
-      bool isLength = selector.isGetter
-          && selector.name == "length";
+      bool isLength = selector.isGetter && selector.name == "length";
       if (isLength || selector.isIndex) {
         return compiler.world.isSubtypeOf(
-            element.enclosingClass.declaration,
-            helpers.jsIndexableClass);
+            element.enclosingClass.declaration, helpers.jsIndexableClass);
       } else if (selector.isIndexSet) {
-        return compiler.world.isSubtypeOf(
-            element.enclosingClass.declaration,
+        return compiler.world.isSubtypeOf(element.enclosingClass.declaration,
             helpers.jsMutableIndexableClass);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.enclosingClass;
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
@@ skipping 23 matching lines @@
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
     TypeMask type =
         TypeMaskFactory.inferredTypeForSelector(selector, mask, compiler);
     if (selector.isGetter) {
-      push(
-          new HInvokeDynamicGetter(selector, mask, null, inputs, type)
-              ..sourceInformation = sourceInformation);
+      push(new HInvokeDynamicGetter(selector, mask, null, inputs, type)
+        ..sourceInformation = sourceInformation);
     } else if (selector.isSetter) {
-      push(
-          new HInvokeDynamicSetter(selector, mask, null, inputs, type)
-              ..sourceInformation = sourceInformation);
+      push(new HInvokeDynamicSetter(selector, mask, null, inputs, type)
+        ..sourceInformation = sourceInformation);
     } else {
-      push(
-          new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
-              ..sourceInformation = sourceInformation);
+      push(new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
+        ..sourceInformation = sourceInformation);
     }
   }
 
   bool _hasNamedParameters(FunctionElement function) {
     FunctionSignature params = function.functionSignature;
-    return params.optionalParameterCount > 0
-        && params.optionalParametersAreNamed;
+    return params.optionalParameterCount > 0 &&
+        params.optionalParametersAreNamed;
   }
 
   HForeignCode invokeJsInteropFunction(FunctionElement element,
-                                       List<HInstruction> arguments,
-                                       SourceInformation sourceInformation) {
+      List<HInstruction> arguments, SourceInformation sourceInformation) {
     assert(backend.isJsInterop(element));
     nativeEmitter.nativeMethods.add(element);
     String templateString;
 
     if (element.isFactoryConstructor &&
-        backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass)) {
+        backend.jsInteropAnalysis
+            .hasAnonymousAnnotation(element.contextClass)) {
       // Factory constructor that is syntactic sugar for creating a JavaScript
       // object literal.
       ConstructorElement constructor = element;
       FunctionSignature params = constructor.functionSignature;
       int i = 0;
       int positions = 0;
       var filteredArguments = <HInstruction>[];
       var parameterNameMap = new Map<String, js.Expression>();
       params.orderedForEachParameter((ParameterElement parameter) {
         // TODO(jacobr): throw if parameter names do not match names of property
         // names in the class.
-        assert (parameter.isNamed);
+        assert(parameter.isNamed);
         HInstruction argument = arguments[i];
         if (argument != null) {
           filteredArguments.add(argument);
           parameterNameMap[parameter.name] =
               new js.InterpolatedExpression(positions++);
         }
         i++;
       });
-      var codeTemplate = new js.Template(null,
-          js.objectLiteral(parameterNameMap));
+      var codeTemplate =
+          new js.Template(null, js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
       if (compiler.options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
-          codeTemplate,
-          backend.dynamicType, filteredArguments,
+          codeTemplate, backend.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
-    var target = new HForeignCode(js.js.parseForeignJS(
-            "${backend.namer.fixedBackendPath(element)}."
+    var target = new HForeignCode(
+        js.js.parseForeignJS("${backend.namer.fixedBackendPath(element)}."
             "${backend.nativeData.getFixedBackendName(element)}"),
         backend.dynamicType,
         <HInstruction>[]);
     add(target);
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
-    DartType type = element.isConstructor ?
-        element.enclosingClass.thisType : element.type.returnType;
+    DartType type = element.isConstructor
+        ? element.enclosingClass.thisType
+        : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
-    nativeBehavior.typesReturned.add(
-        compiler.options.trustJSInteropTypeAnnotations
-            ? type : const DynamicType());
+    nativeBehavior.typesReturned.add(compiler
+        .options.trustJSInteropTypeAnnotations ? type : const DynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
-    if (!compiler.options.trustJSInteropTypeAnnotations || type.isObject ||
+    if (!compiler.options.trustJSInteropTypeAnnotations ||
+        type.isObject ||
         type.isDynamic) {
-      nativeBehavior.typesInstantiated.add(
-          backend.helpers.jsJavaScriptObjectClass.thisType);
+      nativeBehavior.typesInstantiated
+          .add(backend.helpers.jsJavaScriptObjectClass.thisType);
     }
 
     String code;
     if (element.isGetter) {
       code = "#";
     } else if (element.isSetter) {
       code = "# = #";
     } else {
       var args = new List.filled(arguments.length, '#').join(',');
       code = element.isConstructor ? "new #($args)" : "#($args)";
     }
     js.Template codeTemplate = js.js.parseForeignJS(code);
     nativeBehavior.codeTemplate = codeTemplate;
 
-    return new HForeignCode(
-        codeTemplate,
-        backend.dynamicType, inputs,
-        nativeBehavior: nativeBehavior)
-      ..sourceInformation = sourceInformation;
+    return new HForeignCode(codeTemplate, backend.dynamicType, inputs,
+        nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation;
   }
 
-  void pushInvokeStatic(ast.Node location,
-                        Element element,
-                        List<HInstruction> arguments,
-                        {TypeMask typeMask,
-                         InterfaceType instanceType,
-                         SourceInformation sourceInformation}) {
+  void pushInvokeStatic(
+      ast.Node location, Element element, List<HInstruction> arguments,
+      {TypeMask typeMask,
+      InterfaceType instanceType,
+      SourceInformation sourceInformation}) {
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
-                        instanceType: instanceType)) {
+        instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask =
           TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     bool targetCanThrow = !compiler.world.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
     if (backend.isJsInterop(element)) {
-      instruction = invokeJsInteropFunction(element, arguments,
-          sourceInformation);
+      instruction =
+          invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
-      instruction = new HInvokeStatic(
-          element.declaration, arguments, typeMask,
+      instruction = new HInvokeStatic(element.declaration, arguments, typeMask,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (!currentInlinedInstantiations.isEmpty) {
-        instruction.instantiatedTypes = new List<DartType>.from(
-            currentInlinedInstantiations);
+        instruction.instantiatedTypes =
+            new List<DartType>.from(currentInlinedInstantiations);
       }
       instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
     }
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
-  HInstruction buildInvokeSuper(Selector selector,
-                                Element element,
-                                List<HInstruction> arguments,
-                                [SourceInformation sourceInformation]) {
+  HInstruction buildInvokeSuper(
+      Selector selector, Element element, List<HInstruction> arguments,
+      [SourceInformation sourceInformation]) {
     HInstruction receiver = localsHandler.readThis();
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     List<HInstruction> inputs = <HInstruction>[];
     if (backend.isInterceptedSelector(selector) &&
         // Fields don't need an interceptor; consider generating HFieldGet/Set
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(element, compiler);
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
-    HInstruction instruction = new HInvokeSuper(
-        element,
-        currentNonClosureClass,
-        selector,
-        inputs,
-        type,
-        sourceInformation,
+    HInstruction instruction = new HInvokeSuper(element, currentNonClosureClass,
+        selector, inputs, type, sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         compiler.world.getSideEffectsOfSelector(selector, null);
     return instruction;
   }
 
-  void handleComplexOperatorSend(ast.SendSet node,
-                                 HInstruction receiver,
-                                 Link<ast.Node> arguments) {
+  void handleComplexOperatorSend(
+      ast.SendSet node, HInstruction receiver, Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinarySend(
         receiver,
         rhs,
         elements.getOperatorSelectorInComplexSendSet(node),
         elements.getOperatorTypeMaskInComplexSendSet(node),
         node,
         sourceInformation:
-          sourceInformationBuilder.buildGeneric(node.assignmentOperator));
+            sourceInformationBuilder.buildGeneric(node.assignmentOperator));
   }
 
   void handleSuperSendSet(ast.SendSet node) {
     Element element = elements[node];
     List<HInstruction> setterInputs = <HInstruction>[];
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
-      if (Elements.isUnresolved(element)
-          || !setterSelector.applies(element, compiler.world)) {
-        generateSuperNoSuchMethodSend(
-            node, setterSelector, setterInputs);
+      if (Elements.isUnresolved(element) ||
+          !setterSelector.applies(element, compiler.world)) {
+        generateSuperNoSuchMethodSend(node, setterSelector, setterInputs);
         pop();
       } else {
         add(buildInvokeSuper(setterSelector, element, setterInputs));
       }
     }
     if (identical(node.assignmentOperator.source, '=')) {
       addDynamicSendArgumentsToList(node, setterInputs);
       generateSuperSendSet();
       stack.add(setterInputs.last);
     } else {
       Element getter = elements[node.selector];
       List<HInstruction> getterInputs = <HInstruction>[];
       Link<ast.Node> arguments = node.arguments;
       if (node.isIndex) {
         // If node is of the form [:super.foo[0] += 2:], the send has
         // two arguments: the index and the left hand side. We get
         // the index and add it as input of the getter and the
         // setter.
         visit(arguments.head);
         arguments = arguments.tail;
         HInstruction index = pop();
         getterInputs.add(index);
         setterInputs.add(index);
       }
       HInstruction getterInstruction;
       Selector getterSelector =
           elements.getGetterSelectorInComplexSendSet(node);
       if (Elements.isUnresolved(getter)) {
-        generateSuperNoSuchMethodSend(
-            node,
-            getterSelector,
-            getterInputs);
+        generateSuperNoSuchMethodSend(node, getterSelector, getterInputs);
         getterInstruction = pop();
       } else {
-        getterInstruction = buildInvokeSuper(
-            getterSelector, getter, getterInputs);
+        getterInstruction =
+            buildInvokeSuper(getterSelector, getter, getterInputs);
         add(getterInstruction);
       }
 
       if (node.isIfNullAssignment) {
         SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-        brancher.handleIfNull(() => stack.add(getterInstruction),
-            () {
-              addDynamicSendArgumentsToList(node, setterInputs);
-              generateSuperSendSet();
-              stack.add(setterInputs.last);
-            });
+        brancher.handleIfNull(() => stack.add(getterInstruction), () {
+          addDynamicSendArgumentsToList(node, setterInputs);
+          generateSuperSendSet();
+          stack.add(setterInputs.last);
+        });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
         setterInputs.add(pop());
         generateSuperSendSet();
         stack.add(node.isPostfix ? getterInstruction : setterInputs.last);
       }
     }
   }
 
   @override
   void handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitFinalSuperFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperGetterSet(
-      ast.SendSet node,
-      FunctionElement getter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FunctionElement getter, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperIndexSet(
-      ast.SendSet node,
-      FunctionElement function,
-      ast.Node index,
-      ast.Node rhs,
-      _) {
+  void visitSuperIndexSet(ast.SendSet node, FunctionElement function,
+      ast.Node index, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperMethodSet(
-      ast.Send node,
-      MethodElement method,
-      ast.Node rhs,
-      _) {
+      ast.Send node, MethodElement method, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperSetterSet(
-      ast.SendSet node,
-      FunctionElement setter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FunctionElement setter, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperIndexSet(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      ast.Node rhs,
-      _) {
+      ast.Send node, Element element, ast.Node index, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperIndexPrefix(
       ast.Send node,
       MethodElement indexFunction,
       MethodElement indexSetFunction,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperIndexPostfix(
       ast.Send node,
       MethodElement indexFunction,
       MethodElement indexSetFunction,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterIndexPrefix(
-      ast.Send node,
-      Element element,
-      MethodElement setter,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitUnresolvedSuperGetterIndexPrefix(ast.Send node, Element element,
+      MethodElement setter, ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterIndexPostfix(
-      ast.Send node,
-      Element element,
-      MethodElement setter,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitUnresolvedSuperGetterIndexPostfix(ast.Send node, Element element,
+      MethodElement setter, ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperSetterIndexPrefix(
       ast.Send node,
       MethodElement indexFunction,
       Element element,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperSetterIndexPostfix(
       ast.Send node,
       MethodElement indexFunction,
       Element element,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperIndexPrefix(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitUnresolvedSuperIndexPrefix(ast.Send node, Element element,
+      ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperIndexPostfix(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitUnresolvedSuperIndexPostfix(ast.Send node, Element element,
+      ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperCompoundIndexSet(
       ast.SendSet node,
       MethodElement getter,
       MethodElement setter,
       ast.Node index,
       AssignmentOperator operator,
@@ skipping 20 matching lines @@
       MethodElement getter,
       Element element,
       ast.Node index,
       AssignmentOperator operator,
       ast.Node rhs,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperCompoundIndexSet(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitUnresolvedSuperCompoundIndexSet(ast.Send node, Element element,
+      ast.Node index, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperFieldCompound(
-      ast.Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperFieldCompound(ast.Send node, FieldElement field,
+      AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitFinalSuperFieldCompound(
-      ast.Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitFinalSuperFieldCompound(ast.Send node, FieldElement field,
+      AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitFinalSuperFieldPrefix(
-      ast.Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      _) {
+      ast.Send node, FieldElement field, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperPrefix(
-      ast.Send node,
-      Element element,
-      IncDecOperator operator,
-      _) {
+      ast.Send node, Element element, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperPostfix(
-      ast.Send node,
-      Element element,
-      IncDecOperator operator,
-      _) {
+      ast.Send node, Element element, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperCompound(
-      ast.Send node,
-      Element element,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitUnresolvedSuperCompound(ast.Send node, Element element,
+      AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitFinalSuperFieldPostfix(
-      ast.Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      _) {
+      ast.Send node, FieldElement field, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperFieldFieldCompound(
-      ast.Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperFieldFieldCompound(ast.Send node, FieldElement readField,
+      FieldElement writtenField, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperGetterSetterCompound(
-      ast.Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperGetterSetterCompound(ast.Send node, FunctionElement getter,
+      FunctionElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperMethodSetterCompound(
-      ast.Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperMethodSetterCompound(ast.Send node, FunctionElement method,
+      FunctionElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperMethodCompound(
-      ast.Send node,
-      FunctionElement method,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperMethodCompound(ast.Send node, FunctionElement method,
+      AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterCompound(
-      ast.Send node,
-      Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitUnresolvedSuperGetterCompound(ast.Send node, Element element,
+      MethodElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperSetterCompound(
-      ast.Send node,
-      MethodElement getter,
-      Element element,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitUnresolvedSuperSetterCompound(ast.Send node, MethodElement getter,
+      Element element, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperFieldSetterCompound(
-      ast.Send node,
-      FieldElement field,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperFieldSetterCompound(ast.Send node, FieldElement field,
+      FunctionElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperGetterFieldCompound(
-      ast.Send node,
-      FunctionElement getter,
-      FieldElement field,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitSuperGetterFieldCompound(ast.Send node, FunctionElement getter,
+      FieldElement field, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitIndexSet(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, _) {
     generateDynamicSend(node);
   }
 
   @override
-  void visitCompoundIndexSet(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      AssignmentOperator operator,
-      ast.Node rhs,
-      _) {
+  void visitCompoundIndexSet(ast.SendSet node, ast.Node receiver,
+      ast.Node index, AssignmentOperator operator, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     handleIndexSendSet(node);
   }
 
   @override
-  void visitIndexPrefix(
-      ast.Send node,
-      ast.Node receiver,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitIndexPrefix(ast.Send node, ast.Node receiver, ast.Node index,
+      IncDecOperator operator, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     handleIndexSendSet(node);
   }
 
   @override
-  void visitIndexPostfix(
-      ast.Send node,
-      ast.Node receiver,
-      ast.Node index,
-      IncDecOperator operator,
-      _) {
+  void visitIndexPostfix(ast.Send node, ast.Node receiver, ast.Node index,
+      IncDecOperator operator, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     handleIndexSendSet(node);
   }
 
   void handleIndexSendSet(ast.SendSet node) {
     ast.Operator op = node.assignmentOperator;
     if ("=" == op.source) {
       internalError(node, "Unexpected index set.");
     } else {
       visit(node.receiver);
       HInstruction receiver = pop();
       Link<ast.Node> arguments = node.arguments;
       HInstruction index;
       if (node.isIndex) {
         visit(arguments.head);
         arguments = arguments.tail;
         index = pop();
       }
 
-      pushInvokeDynamic(
-          node,
-          elements.getGetterSelectorInComplexSendSet(node),
-          elements.getGetterTypeMaskInComplexSendSet(node),
-          [receiver, index]);
+      pushInvokeDynamic(node, elements.getGetterSelectorInComplexSendSet(node),
+          elements.getGetterTypeMaskInComplexSendSet(node), [receiver, index]);
       HInstruction getterInstruction = pop();
       if (node.isIfNullAssignment) {
         // Compile x[i] ??= e as:
         //   t1 = x[i]
         //   if (t1 == null)
         //      t1 = x[i] = e;
         //   result = t1
         SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-        brancher.handleIfNull(() => stack.add(getterInstruction),
-            () {
-              visit(arguments.head);
-              HInstruction value = pop();
-              pushInvokeDynamic(
-                  node,
-                  elements.getSelector(node),
-                  elements.getTypeMask(node),
-                  [receiver, index, value]);
-              pop();
-              stack.add(value);
-            });
+        brancher.handleIfNull(() => stack.add(getterInstruction), () {
+          visit(arguments.head);
+          HInstruction value = pop();
+          pushInvokeDynamic(node, elements.getSelector(node),
+              elements.getTypeMask(node), [receiver, index, value]);
+          pop();
+          stack.add(value);
+        });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
         HInstruction value = pop();
-        pushInvokeDynamic(
-            node,
-            elements.getSelector(node),
-            elements.getTypeMask(node),
-            [receiver, index, value]);
+        pushInvokeDynamic(node, elements.getSelector(node),
+            elements.getTypeMask(node), [receiver, index, value]);
         pop();
         if (node.isPostfix) {
           stack.add(getterInstruction);
         } else {
           stack.add(value);
         }
       }
     }
   }
 
   @override
-  void visitThisPropertySet(
-      ast.SendSet node,
-      Name name,
-      ast.Node rhs,
-      _) {
+  void visitThisPropertySet(ast.SendSet node, Name name, ast.Node rhs, _) {
     generateInstanceSetterWithCompiledReceiver(
-        node,
-        localsHandler.readThis(),
-        visitAndPop(rhs));
+        node, localsHandler.readThis(), visitAndPop(rhs));
   }
 
   @override
   void visitDynamicPropertySet(
-      ast.SendSet node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     generateInstanceSetterWithCompiledReceiver(
-        node,
-        generateInstanceSendReceiver(node),
-        visitAndPop(rhs));
+        node, generateInstanceSendReceiver(node), visitAndPop(rhs));
   }
 
   @override
   void visitIfNotNullDynamicPropertySet(
-      ast.SendSet node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     // compile e?.x = e2 to:
     //
     // t1 = e
     // if (t1 == null)
     //   result = t1 // same as result = null
     // else
     //   result = e.x = e2
     HInstruction receiverInstruction;
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(
         () {
           receiverInstruction = generateInstanceSendReceiver(node);
           pushCheckNull(receiverInstruction);
         },
         () => stack.add(receiverInstruction),
         () {
           generateInstanceSetterWithCompiledReceiver(
-              node,
-              receiverInstruction,
-              visitAndPop(rhs));
+              node, receiverInstruction, visitAndPop(rhs));
         });
   }
 
   @override
   void visitParameterSet(
-      ast.SendSet node,
-      ParameterElement parameter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ParameterElement parameter, ast.Node rhs, _) {
     generateNonInstanceSetter(node, parameter, visitAndPop(rhs));
   }
 
   @override
   void visitFinalParameterSet(
-      ast.SendSet node,
-      ParameterElement parameter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ParameterElement parameter, ast.Node rhs, _) {
     generateNoSuchSetter(node, parameter, visitAndPop(rhs));
   }
 
   @override
   void visitLocalVariableSet(
-      ast.SendSet node,
-      LocalVariableElement variable,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, LocalVariableElement variable, ast.Node rhs, _) {
     generateNonInstanceSetter(node, variable, visitAndPop(rhs));
   }
 
   @override
   void visitFinalLocalVariableSet(
-      ast.SendSet node,
-      LocalVariableElement variable,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, LocalVariableElement variable, ast.Node rhs, _) {
     generateNoSuchSetter(node, variable, visitAndPop(rhs));
   }
 
   @override
   void visitLocalFunctionSet(
-      ast.SendSet node,
-      LocalFunctionElement function,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, LocalFunctionElement function, ast.Node rhs, _) {
     generateNoSuchSetter(node, function, visitAndPop(rhs));
   }
 
   @override
   void visitTopLevelFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNonInstanceSetter(node, field, visitAndPop(rhs));
   }
 
   @override
   void visitFinalTopLevelFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, field, visitAndPop(rhs));
   }
 
   @override
   void visitTopLevelGetterSet(
-      ast.SendSet node,
-      GetterElement getter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, GetterElement getter, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, getter, visitAndPop(rhs));
   }
 
   @override
   void visitTopLevelSetterSet(
-      ast.SendSet node,
-      SetterElement setter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, SetterElement setter, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNonInstanceSetter(node, setter, visitAndPop(rhs));
   }
 
   @override
   void visitTopLevelFunctionSet(
-      ast.SendSet node,
-      MethodElement function,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, MethodElement function, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, function, visitAndPop(rhs));
   }
 
   @override
   void visitStaticFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNonInstanceSetter(node, field, visitAndPop(rhs));
   }
 
   @override
   void visitFinalStaticFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, field, visitAndPop(rhs));
   }
 
   @override
   void visitStaticGetterSet(
-      ast.SendSet node,
-      GetterElement getter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, GetterElement getter, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, getter, visitAndPop(rhs));
   }
 
   @override
   void visitStaticSetterSet(
-      ast.SendSet node,
-      SetterElement setter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, SetterElement setter, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNonInstanceSetter(node, setter, visitAndPop(rhs));
   }
 
   @override
   void visitStaticFunctionSet(
-      ast.SendSet node,
-      MethodElement function,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, MethodElement function, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNoSuchSetter(node, function, visitAndPop(rhs));
   }
 
   @override
-  void visitUnresolvedSet(
-      ast.SendSet node,
-      Element element,
-      ast.Node rhs,
-      _) {
+  void visitUnresolvedSet(ast.SendSet node, Element element, ast.Node rhs, _) {
     generateIsDeferredLoadedCheckOfSend(node);
     generateNonInstanceSetter(node, element, visitAndPop(rhs));
   }
 
   @override
   void visitClassTypeLiteralSet(
-      ast.SendSet node,
-      TypeConstantExpression constant,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, TypeConstantExpression constant, ast.Node rhs, _) {
     generateThrowNoSuchMethod(node, constant.type.name,
-                              argumentNodes: node.arguments);
+        argumentNodes: node.arguments);
   }
 
   @override
   void visitTypedefTypeLiteralSet(
-      ast.SendSet node,
-      TypeConstantExpression constant,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, TypeConstantExpression constant, ast.Node rhs, _) {
     generateThrowNoSuchMethod(node, constant.type.name,
-                              argumentNodes: node.arguments);
+        argumentNodes: node.arguments);
   }
 
   @override
   void visitDynamicTypeLiteralSet(
-      ast.SendSet node,
-      TypeConstantExpression constant,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, TypeConstantExpression constant, ast.Node rhs, _) {
     generateThrowNoSuchMethod(node, constant.type.name,
-                              argumentNodes: node.arguments);
+        argumentNodes: node.arguments);
   }
 
   @override
   void visitTypeVariableTypeLiteralSet(
-      ast.SendSet node,
-      TypeVariableElement element,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, TypeVariableElement element, ast.Node rhs, _) {
     generateThrowNoSuchMethod(node, element.name,
-                              argumentNodes: node.arguments);
+        argumentNodes: node.arguments);
   }
 
   void handleCompoundSendSet(ast.SendSet node) {
     Element element = elements[node];
     Element getter = elements[node.selector];
 
     if (!Elements.isUnresolved(getter) && getter.impliesType) {
       if (node.isIfNullAssignment) {
         // C ??= x is compiled just as C.
         stack.add(addConstant(node.selector));
       } else {
         ast.Identifier selector = node.selector;
         generateThrowNoSuchMethod(node, selector.source,
-                                  argumentNodes: node.arguments);
+            argumentNodes: node.arguments);
       }
       return;
     }
 
     if (Elements.isInstanceSend(node, elements)) {
       void generateAssignment(HInstruction receiver) {
         // desugars `e.x op= e2` to `e.x = e.x op e2`
         generateInstanceGetterWithCompiledReceiver(
             node,
             elements.getGetterSelectorInComplexSendSet(node),
             elements.getGetterTypeMaskInComplexSendSet(node),
             receiver);
         HInstruction getterInstruction = pop();
         if (node.isIfNullAssignment) {
           SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-          brancher.handleIfNull(() => stack.add(getterInstruction),
-              () {
-                visit(node.arguments.head);
-                generateInstanceSetterWithCompiledReceiver(
-                    node, receiver, pop());
-              });
+          brancher.handleIfNull(() => stack.add(getterInstruction), () {
+            visit(node.arguments.head);
+            generateInstanceSetterWithCompiledReceiver(node, receiver, pop());
+          });
         } else {
           handleComplexOperatorSend(node, getterInstruction, node.arguments);
           HInstruction value = pop();
           generateInstanceSetterWithCompiledReceiver(node, receiver, value);
         }
         if (node.isPostfix) {
           pop();
           stack.add(getterInstruction);
         }
       }
       if (node.isConditional) {
         // generate `e?.x op= e2` as:
         //   t1 = e
         //   t1 == null ? t1 : (t1.x = t1.x op e2);
         HInstruction receiver;
         SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-        brancher.handleConditional(
-            () {
-              receiver = generateInstanceSendReceiver(node);
-              pushCheckNull(receiver);
-            },
-            () => stack.add(receiver),
-            () => generateAssignment(receiver));
+        brancher.handleConditional(() {
+          receiver = generateInstanceSendReceiver(node);
+          pushCheckNull(receiver);
+        }, () => stack.add(receiver), () => generateAssignment(receiver));
       } else {
         generateAssignment(generateInstanceSendReceiver(node));
       }
       return;
     }
 
     if (getter.isMalformed) {
       generateStaticUnresolvedGet(node, getter);
     } else if (getter.isField) {
       generateStaticFieldGet(node, getter);
     } else if (getter.isGetter) {
       generateStaticGetterGet(node, getter);
     } else if (getter.isFunction) {
       generateStaticFunctionGet(node, getter);
     } else if (getter.isLocal) {
       handleLocalGet(node, getter);
     } else {
       internalError(node, "Unexpected getter: $getter");
     }
     HInstruction getterInstruction = pop();
     if (node.isIfNullAssignment) {
       SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-      brancher.handleIfNull(() => stack.add(getterInstruction),
-          () {
-            visit(node.arguments.head);
-            generateNonInstanceSetter(node, element, pop());
-          });
+      brancher.handleIfNull(() => stack.add(getterInstruction), () {
+        visit(node.arguments.head);
+        generateNonInstanceSetter(node, element, pop());
+      });
     } else {
       handleComplexOperatorSend(node, getterInstruction, node.arguments);
       HInstruction value = pop();
       generateNonInstanceSetter(node, element, value);
     }
     if (node.isPostfix) {
       pop();
       stack.add(getterInstruction);
     }
   }
 
   @override
   void handleDynamicCompounds(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      CompoundRhs rhs,
-      _) {
+      ast.Send node, ast.Node receiver, Name name, CompoundRhs rhs, _) {
     handleCompoundSendSet(node);
   }
 
   @override
   void handleLocalCompounds(
-      ast.SendSet node,
-      LocalElement local,
-      CompoundRhs rhs,
-      _,
+      ast.SendSet node, LocalElement local, CompoundRhs rhs, _,
       {bool isSetterValid}) {
     handleCompoundSendSet(node);
   }
 
   @override
   void handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       _) {
     handleCompoundSendSet(node);
   }
 
   @override
   handleDynamicSetIfNulls(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      arg) {
+      ast.Send node, ast.Node receiver, Name name, ast.Node rhs, arg) {
     handleCompoundSendSet(node);
   }
 
   @override
-  handleLocalSetIfNulls(
-      ast.SendSet node,
-      LocalElement local,
-      ast.Node rhs,
-      arg,
+  handleLocalSetIfNulls(ast.SendSet node, LocalElement local, ast.Node rhs, arg,
       {bool isSetterValid}) {
     handleCompoundSendSet(node);
   }
 
   @override
   handleStaticSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       arg) {
     handleCompoundSendSet(node);
   }
 
   @override
   handleSuperSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       arg) {
     handleSuperSendSet(node);
   }
 
   @override
-  handleSuperIndexSetIfNull(
-      ast.SendSet node,
-      Element indexFunction,
-      Element indexSetFunction,
-      ast.Node index,
-      ast.Node rhs,
-      arg,
-      {bool isGetterValid,
-       bool isSetterValid}) {
+  handleSuperIndexSetIfNull(ast.SendSet node, Element indexFunction,
+      Element indexSetFunction, ast.Node index, ast.Node rhs, arg,
+      {bool isGetterValid, bool isSetterValid}) {
     handleCompoundSendSet(node);
   }
 
   @override
   visitIndexSetIfNull(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      ast.Node rhs,
-      arg,
-      {bool isGetterValid,
-       bool isSetterValid}) {
+      ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, arg,
+      {bool isGetterValid, bool isSetterValid}) {
     generateIsDeferredLoadedCheckOfSend(node);
     handleIndexSendSet(node);
   }
 
   @override
   handleTypeLiteralConstantSetIfNulls(
-      ast.SendSet node,
-      ConstantExpression constant,
-      ast.Node rhs,
-      arg) {
+      ast.SendSet node, ConstantExpression constant, ast.Node rhs, arg) {
     // The type variable is never `null`.
     generateConstantTypeLiteral(node);
   }
 
   @override
   visitTypeVariableTypeLiteralSetIfNull(
-      ast.Send node,
-      TypeVariableElement element,
-      ast.Node rhs,
-      arg) {
+      ast.Send node, TypeVariableElement element, ast.Node rhs, arg) {
     // The type variable is never `null`.
     generateTypeVariableLiteral(node, element.type);
   }
 
   void visitLiteralInt(ast.LiteralInt node) {
     stack.add(graph.addConstantInt(node.value, compiler));
   }
 
   void visitLiteralDouble(ast.LiteralDouble node) {
     stack.add(graph.addConstantDouble(node.value, compiler));
@@ skipping 24 matching lines @@
   }
 
   void visitLiteralNull(ast.LiteralNull node) {
     stack.add(graph.addConstantNull(compiler));
   }
 
   visitNodeList(ast.NodeList node) {
     for (Link<ast.Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       if (isAborted()) {
         reporter.reportHintMessage(
-            link.head,
-            MessageKind.GENERIC,
-            {'text': 'dead code'});
+            link.head, MessageKind.GENERIC, {'text': 'dead code'});
       } else {
         visit(link.head);
       }
     }
   }
 
   void visitParenthesizedExpression(ast.ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitOperator(ast.Operator node) {
     // Operators are intercepted in their surrounding Send nodes.
-    reporter.internalError(node,
-        'SsaBuilder.visitOperator should not be called.');
+    reporter.internalError(
+        node, 'SsaBuilder.visitOperator should not be called.');
   }
 
   visitCascade(ast.Cascade node) {
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(ast.CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
   void handleInTryStatement() {
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   visitRethrow(ast.Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
-      reporter.internalError(node,
-          'rethrowableException should not be null.');
+      reporter.internalError(node, 'rethrowableException should not be null.');
     }
     handleInTryStatement();
-    closeAndGotoExit(
-        new HThrow(exception,
-                   sourceInformationBuilder.buildThrow(node),
-                   isRethrow: true));
+    closeAndGotoExit(new HThrow(
+        exception, sourceInformationBuilder.buildThrow(node),
+        isRethrow: true));
   }
 
   visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
     ConstructorElement targetConstructor =
         elements.getRedirectingTargetConstructor(node).implementation;
     ConstructorElement redirectingConstructor = sourceElement.implementation;
     List<HInstruction> inputs = <HInstruction>[];
     FunctionSignature targetSignature = targetConstructor.functionSignature;
     FunctionSignature redirectingSignature =
         redirectingConstructor.functionSignature;
 
     List<Element> targetRequireds = targetSignature.requiredParameters;
-    List<Element> redirectingRequireds
-        = redirectingSignature.requiredParameters;
+    List<Element> redirectingRequireds =
+        redirectingSignature.requiredParameters;
 
-    List<Element> targetOptionals =
-        targetSignature.orderedOptionalParameters;
+    List<Element> targetOptionals = targetSignature.orderedOptionalParameters;
     List<Element> redirectingOptionals =
         redirectingSignature.orderedOptionalParameters;
 
     // TODO(25579): This code can do the wrong thing redirecting constructor and
     // the target do not correspond. It is correct if there is no
     // warning. Ideally the redirecting constructor and the target would be the
     // same function.
 
     void loadLocal(ParameterElement parameter) {
       inputs.add(localsHandler.readLocal(parameter));
     }
     void loadPosition(int position, ParameterElement optionalParameter) {
       if (position < redirectingRequireds.length) {
         loadLocal(redirectingRequireds[position]);
       } else if (position < redirectingSignature.parameterCount &&
-                 !redirectingSignature.optionalParametersAreNamed) {
+          !redirectingSignature.optionalParametersAreNamed) {
         loadLocal(redirectingOptionals[position - redirectingRequireds.length]);
       } else if (optionalParameter != null) {
         inputs.add(handleConstantForOptionalParameter(optionalParameter));
       } else {
         // Wrong.
         inputs.add(graph.addConstantNull(compiler));
       }
     }
 
     int position = 0;
 
     for (ParameterElement targetParameter in targetRequireds) {
       loadPosition(position++, null);
     }
 
     if (targetOptionals.isNotEmpty) {
       if (targetSignature.optionalParametersAreNamed) {
         for (ParameterElement parameter in targetOptionals) {
-          ParameterElement redirectingParameter =
-              redirectingOptionals.firstWhere(
-                  (p) => p.name == parameter.name,
-                  orElse: () => null);
+          ParameterElement redirectingParameter = redirectingOptionals
+              .firstWhere((p) => p.name == parameter.name, orElse: () => null);
           if (redirectingParameter == null) {
             inputs.add(handleConstantForOptionalParameter(parameter));
           } else {
             inputs.add(localsHandler.readLocal(redirectingParameter));
           }
         }
       } else {
         for (ParameterElement parameter in targetOptionals) {
           loadPosition(position++, parameter);
         }
@@ skipping 16 matching lines @@
   }
 
   /// Returns true if the [type] is a valid return type for an asynchronous
   /// function.
   ///
   /// Asynchronous functions return a `Future`, and a valid return is thus
   /// either dynamic, Object, or Future.
   ///
   /// We do not accept the internal Future implementation class.
   bool isValidAsyncReturnType(DartType type) {
-    assert (isBuildingAsyncFunction);
+    assert(isBuildingAsyncFunction);
     // TODO(sigurdm): In an internal library a function could be declared:
     //
     // _FutureImpl foo async => 1;
     //
     // This should be valid (because the actual value returned from an async
     // function is a `_FutureImpl`), but currently false is returned in this
     // case.
     return type.isDynamic ||
-           type.isObject ||
-           (type is InterfaceType &&
-               type.element == coreClasses.futureClass);
+        type.isObject ||
+        (type is InterfaceType && type.element == coreClasses.futureClass);
   }
 
   visitReturn(ast.Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
       if (isBuildingAsyncFunction) {
         if (compiler.options.enableTypeAssertions &&
             !isValidAsyncReturnType(returnType)) {
-          String message =
-                "Async function returned a Future, "
-                "was declared to return a $returnType.";
+          String message = "Async function returned a Future, "
+              "was declared to return a $returnType.";
           generateTypeError(node, message);
           pop();
           return;
         }
       } else {
         value = potentiallyCheckOrTrustType(value, returnType);
       }
     }
 
     handleInTryStatement();
@@ skipping 13 matching lines @@
   visitYield(ast.Yield node) {
     visit(node.expression);
     HInstruction yielded = pop();
     add(new HYield(yielded, node.hasStar));
   }
 
   visitAwait(ast.Await node) {
     visit(node.expression);
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
-    push(new HAwait(awaited, new TypeMask.subclass(
-        coreClasses.objectClass, compiler.world)));
+    push(new HAwait(awaited,
+        new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
-    reporter.internalError(node,
-        'Visiting type annotation in SSA builder.');
+    reporter.internalError(node, 'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       ast.Node definition = link.head;
       LocalElement local = elements[definition];
       if (definition is ast.Identifier) {
         HInstruction initialValue = graph.addConstantNull(compiler);
         localsHandler.updateLocal(local, initialValue);
       } else {
         ast.SendSet node = definition;
         generateNonInstanceSetter(
             node, local, visitAndPop(node.arguments.first));
-        pop();  // Discard value.
+        pop(); // Discard value.
       }
     }
   }
 
   HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) {
     InterfaceType type = localsHandler.substInContext(elements.getType(node));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
       arguments.add(analyzeTypeArgument(argument));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfo(type.element, arguments, object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
     if (node.isConst) {
       instruction = addConstant(node);
     } else {
       List<HInstruction> inputs = <HInstruction>[];
       for (Link<ast.Node> link = node.elements.nodes;
-           !link.isEmpty;
-           link = link.tail) {
+          !link.isEmpty;
+          link = link.tail) {
         visit(link.head);
         inputs.add(pop());
       }
       instruction = buildLiteralList(inputs);
       add(instruction);
       instruction = setRtiIfNeeded(instruction, node);
     }
 
     TypeMask type =
         TypeMaskFactory.inferredForNode(sourceElement, node, compiler);
     if (!type.containsAll(compiler.world)) instruction.instructionType = type;
     stack.add(instruction);
   }
 
   visitConditional(ast.Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(() => visit(node.condition),
-                               () => visit(node.thenExpression),
-                               () => visit(node.elseExpression));
+        () => visit(node.thenExpression), () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   visitStringInterpolationPart(ast.StringInterpolationPart node) {
     // The parts are iterated in visitStringInterpolation.
-    reporter.internalError(node,
-      'SsaBuilder.visitStringInterpolation should not be called.');
+    reporter.internalError(
+        node, 'SsaBuilder.visitStringInterpolation should not be called.');
   }
 
   visitEmptyStatement(ast.EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(ast.Modifiers node) {
     compiler.unimplemented(node, 'SsaFromAstMixin.visitModifiers.');
   }
 
@@ skipping 49 matching lines @@
     }
     return new JumpHandler(this, element);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     visit(node.expression);
     HInstruction expression = pop();
-    pushInvokeStatic(node,
-                     helpers.streamIteratorConstructor,
-                     [expression, graph.addConstantNull(compiler)]);
+    pushInvokeStatic(node, helpers.streamIteratorConstructor,
+        [expression, graph.addConstantNull(compiler)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elements.getMoveNextTypeMask(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(future,
           new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
       return popBoolified();
     }
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask callMask = elements.getCurrentTypeMask(node);
       pushInvokeDynamic(node, call, callMask, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
       Selector selector = elements.getSelector(identifier);
       TypeMask mask = elements.getTypeMask(identifier);
 
       HInstruction value = pop();
-      if (identifier.asSend() != null
-          && Elements.isInstanceSend(identifier, elements)) {
+      if (identifier.asSend() != null &&
+          Elements.isInstanceSend(identifier, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(identifier);
         assert(receiver != null);
-        generateInstanceSetterWithCompiledReceiver(
-            null,
-            receiver,
-            value,
-            selector: selector,
-            mask: mask,
-            location: identifier);
+        generateInstanceSetterWithCompiledReceiver(null, receiver, value,
+            selector: selector, mask: mask, location: identifier);
       } else {
-        generateNonInstanceSetter(
-            null, variable, value, location: identifier);
+        generateNonInstanceSetter(null, variable, value, location: identifier);
       }
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
 
-    void buildUpdate() {};
+    void buildUpdate() {}
+    ;
 
     buildProtectedByFinally(() {
-      handleLoop(node,
-                 buildInitializer,
-                 buildCondition,
-                 buildUpdate,
-                 buildBody);
+      handleLoop(
+          node, buildInitializer, buildCondition, buildUpdate, buildBody);
     }, () {
-      pushInvokeDynamic(node,
-          Selectors.cancel,
-          null,
-          [streamIterator]);
-      push(new HAwait(pop(), new TypeMask.subclass(
-          coreClasses.objectClass, compiler.world)));
+      pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
+      push(new HAwait(pop(),
+          new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
     // If the receiver supports JavaScript indexing we generate an indexing loop
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
@@ skipping 56 matching lines @@
   buildAssignLoopVariable(ast.ForIn node, HInstruction value) {
     ast.Node identifier = node.declaredIdentifier;
     Element variable = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
     TypeMask mask = elements.getTypeMask(identifier);
 
     if (identifier.asSend() != null &&
         Elements.isInstanceSend(identifier, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(identifier);
       assert(receiver != null);
-      generateInstanceSetterWithCompiledReceiver(
-          null,
-          receiver,
-          value,
-          selector: selector,
-          mask: mask,
-          location: identifier);
+      generateInstanceSetterWithCompiledReceiver(null, receiver, value,
+          selector: selector, mask: mask, location: identifier);
     } else {
       generateNonInstanceSetter(null, variable, value, location: identifier);
     }
-    pop();  // Discard the value pushed by the setter call.
+    pop(); // Discard the value pushed by the setter call.
   }
 
   buildSyncForInIndexable(ast.ForIn node, TypeMask arrayType) {
     // Generate a structure equivalent to:
     //
     //     int end = a.length;
     //     for (int i = 0;
     //          i < a.length;
     //          checkConcurrentModificationError(a.length == end, a), ++i) {
     //       <declaredIdentifier> = a[i];
     //       <body>
     //     }
     Element loopVariable = elements.getForInVariable(node);
     SyntheticLocal indexVariable = new SyntheticLocal('_i', loopVariable);
     TypeMask boolType = backend.boolType;
 
     // These variables are shared by initializer, condition, body and update.
-    HInstruction array;  // Set in buildInitializer.
-    bool isFixed;  // Set in buildInitializer.
-    HInstruction originalLength = null;  // Set for growable lists.
+    HInstruction array; // Set in buildInitializer.
+    bool isFixed; // Set in buildInitializer.
+    HInstruction originalLength = null; // Set for growable lists.
 
     HInstruction buildGetLength() {
       Element lengthElement = helpers.jsIndexableLength;
       HFieldGet result = new HFieldGet(
           lengthElement, array, backend.positiveIntType,
           isAssignable: !isFixed);
       add(result);
       return result;
     }
 
     void buildConcurrentModificationErrorCheck() {
       if (originalLength == null) return;
       // The static call checkConcurrentModificationError() is expanded in
       // codegen to:
       //
       //     array.length == _end || throwConcurrentModificationError(array)
       //
       HInstruction length = buildGetLength();
       push(new HIdentity(length, originalLength, null, boolType));
-      pushInvokeStatic(node,
-          helpers.checkConcurrentModificationError,
-          [pop(), array]);
+      pushInvokeStatic(
+          node, helpers.checkConcurrentModificationError, [pop(), array]);
       pop();
     }
 
     void buildInitializer() {
       visit(node.expression);
       array = pop();
       isFixed = isFixedLength(array.instructionType, compiler);
-      localsHandler.updateLocal(indexVariable,
-          graph.addConstantInt(0, compiler));
+      localsHandler.updateLocal(
+          indexVariable, graph.addConstantInt(0, compiler));
       originalLength = buildGetLength();
     }
 
     HInstruction buildCondition() {
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction length = buildGetLength();
       HInstruction compare = new HLess(index, length, null, boolType);
       add(compare);
       return compare;
     }
@@ skipping 39 matching lines @@
 
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitLabel(ast.Label node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
 
   visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
-    if (body is ast.Loop
-        || body is ast.SwitchStatement
-        || Elements.isUnusedLabel(node, elements)) {
+    if (body is ast.Loop ||
+        body is ast.SwitchStatement ||
+        Elements.isUnusedLabel(node, elements)) {
       // Loops and switches handle their own labels.
       visit(body);
       return;
     }
     JumpTarget targetElement = elements.getTargetDefinition(body);
     LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
     assert(targetElement.isBreakTarget);
     JumpHandler handler = new JumpHandler(this, targetElement);
     // Introduce a new basic block.
     HBasicBlock entryBlock = openNewBlock();
@@ skipping 10 matching lines @@
     if (!isAborted()) {
       goto(current, joinBlock);
       breakHandlers.add(localsHandler);
     }
     open(joinBlock);
     localsHandler = beforeLocals.mergeMultiple(breakHandlers, joinBlock);
 
     if (hasBreak) {
       // There was at least one reachable break, so the label is needed.
       entryBlock.setBlockFlow(
-          new HLabeledBlockInformation(new HSubGraphBlockInformation(bodyGraph),
-                                       handler.labels()),
+          new HLabeledBlockInformation(
+              new HSubGraphBlockInformation(bodyGraph), handler.labels()),
           joinBlock);
     }
     handler.close();
   }
 
   visitLiteralMap(ast.LiteralMap node) {
     if (node.isConst) {
       stack.add(addConstant(node));
       return;
     }
     List<HInstruction> listInputs = <HInstruction>[];
     for (Link<ast.Node> link = node.entries.nodes;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       visit(link.head);
       listInputs.add(pop());
       listInputs.add(pop());
     }
 
     Element constructor;
     List<HInstruction> inputs = <HInstruction>[];
 
     if (listInputs.isEmpty) {
       constructor = helpers.mapLiteralConstructorEmpty;
@@ skipping 38 matching lines @@
     // If rti is needed and the map literal has no type parameters,
     // 'constructor' is a static function that forwards the call to the factory
     // constructor without type parameters.
     assert(constructor is ConstructorElement || constructor is FunctionElement);
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType =
         new TypeMask.nonNullSubtype(helpers.mapLiteralClass, compiler.world);
-    TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
-        constructor, compiler);
+    TypeMask returnTypeMask =
+        TypeMaskFactory.inferredReturnTypeForElement(constructor, compiler);
     TypeMask instructionType =
         mapType.intersection(returnTypeMask, compiler.world);
 
     addInlinedInstantiation(expectedType);
     pushInvokeStatic(node, constructor, inputs,
         typeMask: instructionType, instanceType: expectedType);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(ast.NamedArgument node) {
     visit(node.expression);
   }
 
   Map<ast.CaseMatch, ConstantValue> buildSwitchCaseConstants(
       ast.SwitchStatement node) {
-
     Map<ast.CaseMatch, ConstantValue> constants =
         new Map<ast.CaseMatch, ConstantValue>();
     for (ast.SwitchCase switchCase in node.cases) {
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           ast.CaseMatch match = labelOrCase;
           ConstantValue constant = getConstantForNode(match.expression);
           constants[labelOrCase] = constant;
         }
       }
@@ skipping 33 matching lines @@
       buildSimpleSwitchStatement(node, constants);
     } else {
       buildComplexSwitchStatement(node, constants, caseIndex, hasDefault);
     }
   }
 
   /**
    * Builds a simple switch statement which does not handle uses of continue
    * statements to labeled switch cases.
    */
-  void buildSimpleSwitchStatement(ast.SwitchStatement node,
-                                  Map<ast.CaseMatch, ConstantValue> constants) {
+  void buildSimpleSwitchStatement(
+      ast.SwitchStatement node, Map<ast.CaseMatch, ConstantValue> constants) {
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
     Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
       List<ConstantValue> constantList = <ConstantValue>[];
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           constantList.add(constants[labelOrCase]);
         }
       }
       return constantList;
     }
     bool isDefaultCase(ast.SwitchCase switchCase) {
       return switchCase.isDefaultCase;
     }
     void buildSwitchCase(ast.SwitchCase node) {
       visit(node.statements);
     }
-    handleSwitch(node,
-                 jumpHandler,
-                 buildExpression,
-                 node.cases,
-                 getConstants,
-                 isDefaultCase,
-                 buildSwitchCase);
+    handleSwitch(node, jumpHandler, buildExpression, node.cases, getConstants,
+        isDefaultCase, buildSwitchCase);
     jumpHandler.close();
   }
 
   /**
    * Builds a switch statement that can handle arbitrary uses of continue
    * statements to labeled switch cases.
    */
-  void buildComplexSwitchStatement(ast.SwitchStatement node,
-                                   Map<ast.CaseMatch, ConstantValue> constants,
-                                   Map<ast.SwitchCase, int> caseIndex,
-                                   bool hasDefault) {
+  void buildComplexSwitchStatement(
+      ast.SwitchStatement node,
+      Map<ast.CaseMatch, ConstantValue> constants,
+      Map<ast.SwitchCase, int> caseIndex,
+      bool hasDefault) {
     // If the switch statement has switch cases targeted by continue
     // statements we create the following encoding:
     //
     //   switch (e) {
     //     l_1: case e0: s_1; break;
     //     l_2: case e1: s_2; continue l_i;
     //     ...
     //     l_n: default: s_n; continue l_j;
     //   }
     //
@@ skipping 51 matching lines @@
         int index = caseIndex[switchCase];
         HInstruction value = graph.addConstantInt(index, compiler);
         localsHandler.updateLocal(switchTarget, value);
       } else {
         // Generate synthetic default case 'target = null; break;'.
         HInstruction value = graph.addConstantNull(compiler);
         localsHandler.updateLocal(switchTarget, value);
       }
       jumpTargets[switchTarget].generateBreak();
     }
-    handleSwitch(node,
-                 jumpHandler,
-                 buildExpression,
-                 switchCases,
-                 getConstants,
-                 isDefaultCase,
-                 buildSwitchCase);
+    handleSwitch(node, jumpHandler, buildExpression, switchCases, getConstants,
+        isDefaultCase, buildSwitchCase);
     jumpHandler.close();
 
-    HInstruction buildCondition() =>
-        graph.addConstantBool(true, compiler);
+    HInstruction buildCondition() => graph.addConstantBool(true, compiler);
 
     void buildSwitch() {
       HInstruction buildExpression() {
         return localsHandler.readLocal(switchTarget);
       }
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
         return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])];
       }
       void buildSwitchCase(ast.SwitchCase switchCase) {
         visit(switchCase.statements);
         if (!isAborted()) {
           // Ensure that we break the loop if the case falls through. (This
           // is only possible for the last case.)
           jumpTargets[switchTarget].generateBreak();
         }
       }
       // Pass a [NullJumpHandler] because the target for the contained break
       // is not the generated switch statement but instead the loop generated
       // in the call to [handleLoop] below.
-      handleSwitch(node,
-                   new NullJumpHandler(reporter),
-                   buildExpression, node.cases, getConstants,
-                   (_) => false, // No case is default.
-                   buildSwitchCase);
+      handleSwitch(
+          node,
+          new NullJumpHandler(reporter),
+          buildExpression,
+          node.cases,
+          getConstants,
+          (_) => false, // No case is default.
+          buildSwitchCase);
     }
 
     void buildLoop() {
-      handleLoop(node,
-          () {},
-          buildCondition,
-          () {},
-          buildSwitch);
+      handleLoop(node, () {}, buildCondition, () {}, buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
-            code,
-            backend.boolType,
-            [localsHandler.readLocal(switchTarget)],
+            code, backend.boolType, [localsHandler.readLocal(switchTarget)],
             nativeBehavior: native.NativeBehavior.PURE));
       }
       handleIf(node,
           visitCondition: buildCondition,
           visitThen: buildLoop,
           visitElse: () => {});
     }
   }
 
   /**
    * Creates a switch statement.
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
    * [buildExpression] creates the switch expression.
    * [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or
    *   a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes.
    * [getConstants] returns the set of constants for a switch case.
    * [isDefaultCase] returns [:true:] if the provided switch case should be
    *   considered default for the created switch statement.
    * [buildSwitchCase] creates the statements for the switch case.
    */
   void handleSwitch(
       ast.Node errorNode,
       JumpHandler jumpHandler,
       HInstruction buildExpression(),
       var switchCases,
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase),
       bool isDefaultCase(ast.SwitchCase switchCase),
       void buildSwitchCase(ast.SwitchCase switchCase)) {
-
     HBasicBlock expressionStart = openNewBlock();
     HInstruction expression = buildExpression();
     if (switchCases.isEmpty) {
       return;
     }
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionEnd = close(switchInstruction);
     LocalsHandler savedLocals = localsHandler;
 
@@ skipping 45 matching lines @@
     // If we never jump to the join block, [caseHandlers] will stay empty, and
     // the join block is never added to the graph.
     HBasicBlock joinBlock = new HBasicBlock();
     List<LocalsHandler> caseHandlers = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
       instruction.block.addSuccessor(joinBlock);
       caseHandlers.add(locals);
     });
     jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
       assert(invariant(errorNode, false,
-                       message: 'Continue cannot target a switch.'));
+          message: 'Continue cannot target a switch.'));
     });
     if (!isAborted()) {
       current.close(new HGoto());
       lastOpenedBlock.addSuccessor(joinBlock);
       caseHandlers.add(localsHandler);
     }
     if (!hasDefault) {
       // Always create a default case, to avoid a critical edge in the
       // graph.
       HBasicBlock defaultCase = addNewBlock();
       expressionEnd.addSuccessor(defaultCase);
       open(defaultCase);
       close(new HGoto());
       defaultCase.addSuccessor(joinBlock);
       caseHandlers.add(savedLocals);
-      statements.add(new HSubGraphBlockInformation(new SubGraph(
-          defaultCase, defaultCase)));
+      statements.add(new HSubGraphBlockInformation(
+          new SubGraph(defaultCase, defaultCase)));
     }
     assert(caseHandlers.length == joinBlock.predecessors.length);
     if (caseHandlers.length != 0) {
       graph.addBlock(joinBlock);
       open(joinBlock);
       if (caseHandlers.length == 1) {
         localsHandler = caseHandlers[0];
       } else {
         localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock);
       }
     } else {
       // The joinblock is not used.
       joinBlock = null;
     }
 
     HSubExpressionBlockInformation expressionInfo =
-        new HSubExpressionBlockInformation(new SubExpression(expressionStart,
-                                                             expressionEnd));
+        new HSubExpressionBlockInformation(
+            new SubExpression(expressionStart, expressionEnd));
     expressionStart.setBlockFlow(
-        new HSwitchBlockInformation(expressionInfo,
-                                    statements,
-                                    jumpHandler.target,
-                                    jumpHandler.labels()),
+        new HSwitchBlockInformation(expressionInfo, statements,
+            jumpHandler.target, jumpHandler.labels()),
         joinBlock);
 
     jumpHandler.close();
   }
 
   visitSwitchCase(ast.SwitchCase node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitSwitchCase.');
   }
 
   visitCaseMatch(ast.CaseMatch node) {
@@ skipping 80 matching lines @@
     addExitTrySuccessor(startFinallyBlock);
 
     // Use the locals handler not altered by the catch and finally
     // blocks.
     // TODO(sigurdm): We can probably do this, because try-variables are boxed.
     // Need to verify.
     localsHandler = savedLocals;
     open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
-          wrapStatementGraph(bodyGraph),
-          null, // No catch-variable.
-          null, // No catchGraph.
-          wrapStatementGraph(finallyGraph)),
+            wrapStatementGraph(bodyGraph),
+            null, // No catch-variable.
+            null, // No catchGraph.
+            wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Save the current locals. The catch block and the finally block
     // must not reuse the existing locals handler. None of the variables
     // that have been defined in the body-block will be used, but for
     // loops we will add (unnecessary) phis that will reference the body
     // variables. This makes it look as if the variables were used
@@ skipping 69 matching lines @@
           }
         }
       }
 
       void visitThen() {
         ast.CatchBlock catchBlock = link.head;
         link = link.tail;
         if (catchBlock.exception != null) {
           LocalVariableElement exceptionVariable =
               elements[catchBlock.exception];
-          localsHandler.updateLocal(exceptionVariable,
-                                    unwrappedException);
+          localsHandler.updateLocal(exceptionVariable, unwrappedException);
         }
         ast.Node trace = catchBlock.trace;
         if (trace != null) {
           pushInvokeStatic(trace, helpers.traceFromException, [exception]);
           HInstruction traceInstruction = pop();
           LocalVariableElement traceVariable = elements[trace];
           localsHandler.updateLocal(traceVariable, traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
-          closeAndGotoExit(
-              new HThrow(exception,
-                         exception.sourceInformation,
-                         isRethrow: true));
+          closeAndGotoExit(new HThrow(exception, exception.sourceInformation,
+              isRethrow: true));
         } else {
           ast.CatchBlock newBlock = link.head;
-          handleIf(node,
-                   visitCondition: () { pushCondition(newBlock); },
-                   visitThen: visitThen,
-                   visitElse: visitElse);
+          handleIf(node, visitCondition: () {
+            pushCondition(newBlock);
+          }, visitThen: visitThen, visitElse: visitElse);
         }
       }
 
       ast.CatchBlock firstBlock = link.head;
-      handleIf(node,
-          visitCondition: () { pushCondition(firstBlock); },
-          visitThen: visitThen,
-          visitElse: visitElse);
+      handleIf(node, visitCondition: () {
+        pushCondition(firstBlock);
+      }, visitThen: visitThen, visitElse: visitElse);
       if (!isAborted()) endCatchBlock = close(new HGoto());
 
       rethrowableException = oldRethrowableException;
       tryInstruction.catchBlock = startCatchBlock;
       catchGraph = new SubGraph(startCatchBlock, lastOpenedBlock);
     }
 
     SubGraph finallyGraph = null;
     if (node.finallyBlock != null) {
       localsHandler = new LocalsHandler.from(savedLocals);
       startFinallyBlock = graph.addNewBlock();
       open(startFinallyBlock);
       visit(node.finallyBlock);
       if (!isAborted()) endFinallyBlock = close(new HGoto());
       tryInstruction.finallyBlock = startFinallyBlock;
       finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
     }
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
-    addOptionalSuccessor(b1, b2) { if (b2 != null) b1.addSuccessor(b2); }
+    addOptionalSuccessor(b1, b2) {
+      if (b2 != null) b1.addSuccessor(b2);
+    }
     addExitTrySuccessor(successor) {
       if (successor == null) return;
       // Iterate over all blocks created inside this try/catch, and
       // attach successor information to blocks that end with
       // [HExitTry].
       for (int i = startTryBlock.id; i < successor.id; i++) {
         HBasicBlock block = graph.blocks[i];
         var last = block.last;
         if (last is HExitTry) {
           block.addSuccessor(successor);
@@ skipping 33 matching lines @@
     // we explicitely mark this block a predecessor of the catch
     // block and the finally block.
     addExitTrySuccessor(startCatchBlock);
     addExitTrySuccessor(startFinallyBlock);
 
     // Use the locals handler not altered by the catch and finally
     // blocks.
     localsHandler = savedLocals;
     open(exitBlock);
     enterBlock.setBlockFlow(
-        new HTryBlockInformation(
-          wrapStatementGraph(bodyGraph),
-          exception,
-          wrapStatementGraph(catchGraph),
-          wrapStatementGraph(finallyGraph)),
+        new HTryBlockInformation(wrapStatementGraph(bodyGraph), exception,
+            wrapStatementGraph(catchGraph), wrapStatementGraph(finallyGraph)),
         exitBlock);
     inTryStatement = oldInTryStatement;
   }
 
   visitCatchBlock(ast.CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(ast.Typedef node) {
     compiler.unimplemented(node, 'SsaFromAstMixin.visitTypedef.');
   }
 
   visitTypeVariable(ast.TypeVariable node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
-  void enterInlinedMethod(FunctionElement function,
-                          ast.Node _,
-                          List<HInstruction> compiledArguments,
-                          {InterfaceType instanceType}) {
+  void enterInlinedMethod(FunctionElement function, ast.Node _,
+      List<HInstruction> compiledArguments,
+      {InterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
-        function, returnLocal, returnType, elements, stack, localsHandler,
+        function,
+        returnLocal,
+        returnType,
+        elements,
+        stack,
+        localsHandler,
         inTryStatement,
         allInlinedFunctionsCalledOnce && isFunctionCalledOnce(function));
     inliningStack.add(state);
 
     // Setting up the state of the (AST) builder is performed even when the
     // inlined function is in IR, because the irInliner uses the [returnElement]
     // of the AST builder.
-    setupStateForInlining(
-        function, compiledArguments, instanceType: instanceType);
+    setupStateForInlining(function, compiledArguments,
+        instanceType: instanceType);
   }
 
   void leaveInlinedMethod() {
     HInstruction result = localsHandler.readLocal(returnLocal);
     AstInliningState state = inliningStack.removeLast();
     restoreState(state);
     stack.add(result);
   }
 
   void doInline(FunctionElement function) {
     visitInlinedFunction(function);
   }
 
   void emitReturn(HInstruction value, ast.Node node) {
     if (inliningStack.isEmpty) {
-      closeAndGotoExit(new HReturn(value,
-          sourceInformationBuilder.buildReturn(node)));
+      closeAndGotoExit(
+          new HReturn(value, sourceInformationBuilder.buildReturn(node)));
     } else {
       localsHandler.updateLocal(returnLocal, value);
     }
   }
 
   @override
   void handleTypeLiteralConstantCompounds(
-      ast.SendSet node,
-      ConstantExpression constant,
-      CompoundRhs rhs,
-      _) {
+      ast.SendSet node, ConstantExpression constant, CompoundRhs rhs, _) {
     handleTypeLiteralCompound(node);
   }
 
   @override
   void handleTypeVariableTypeLiteralCompounds(
-      ast.SendSet node,
-      TypeVariableElement typeVariable,
-      CompoundRhs rhs,
-      _) {
+      ast.SendSet node, TypeVariableElement typeVariable, CompoundRhs rhs, _) {
     handleTypeLiteralCompound(node);
   }
 
   void handleTypeLiteralCompound(ast.SendSet node) {
     generateIsDeferredLoadedCheckOfSend(node);
     ast.Identifier selector = node.selector;
     generateThrowNoSuchMethod(node, selector.source,
-                              argumentNodes: node.arguments);
+        argumentNodes: node.arguments);
   }
 
   @override
-  void visitConstantGet(
-    ast.Send node,
-    ConstantExpression constant,
-    _) {
+  void visitConstantGet(ast.Send node, ConstantExpression constant, _) {
     visitNode(node);
   }
 
   @override
-  void visitConstantInvoke(
-    ast.Send node,
-    ConstantExpression constant,
-    ast.NodeList arguments,
-    CallStructure callStreucture,
-    _) {
+  void visitConstantInvoke(ast.Send node, ConstantExpression constant,
+      ast.NodeList arguments, CallStructure callStreucture, _) {
     visitNode(node);
   }
 
   @override
   void errorUndefinedBinaryExpression(
-      ast.Send node,
-      ast.Node left,
-      ast.Operator operator,
-      ast.Node right,
-      _) {
+      ast.Send node, ast.Node left, ast.Operator operator, ast.Node right, _) {
     visitNode(node);
   }
 
   @override
   void errorUndefinedUnaryExpression(
-      ast.Send node,
-      ast.Operator operator,
-      ast.Node expression,
-      _) {
+      ast.Send node, ast.Operator operator, ast.Node expression, _) {
     visitNode(node);
   }
 
   @override
   void bulkHandleError(ast.Node node, ErroneousElement error, _) {
     // TODO(johnniwinther): Use an uncatchable error when supported.
     generateRuntimeError(node, error.message);
   }
 }
 
@@ skipping 37 matching lines @@
       append(stringify(node, expression));
       return;
     }
 
     // If the `toString` method is guaranteed to return a string we can call it
     // directly.
     Selector selector = Selectors.toString_;
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(
         selector, expression.instructionType, compiler);
     if (type.containsOnlyString(compiler.world)) {
-      builder.pushInvokeDynamic(
-          node, selector,
-          expression.instructionType, <HInstruction>[expression]);
+      builder.pushInvokeDynamic(node, selector, expression.instructionType,
+          <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
   void visitStringInterpolation(ast.StringInterpolation node) {
     node.visitChildren(this);
   }
 
   void visitStringInterpolationPart(ast.StringInterpolationPart node) {
     visit(node.expression);
     visit(node.string);
   }
 
   void visitStringJuxtaposition(ast.StringJuxtaposition node) {
     node.visitChildren(this);
   }
 
   void visitNodeList(ast.NodeList node) {
-     node.visitChildren(this);
+    node.visitChildren(this);
   }
 
   void append(HInstruction expression) {
     result = (result == null) ? expression : concat(result, expression);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
-    HInstruction instruction = new HStringConcat(
-        left, right, builder.backend.stringType);
+    HInstruction instruction =
+        new HStringConcat(left, right, builder.backend.stringType);
     builder.add(instruction);
     return instruction;
   }
 
   HInstruction stringify(ast.Node node, HInstruction expression) {
     HInstruction instruction =
         new HStringify(expression, builder.backend.stringType);
     builder.add(instruction);
     return instruction;
   }
@@ skipping 14 matching lines @@
   static const INLINING_NODES_INSIDE_LOOP_ARG_FACTOR = 4;
 
   bool seenReturn = false;
   bool tooDifficult = false;
   int nodeCount = 0;
   final int maxInliningNodes;
   final bool useMaxInliningNodes;
   final bool allowLoops;
   final bool enableUserAssertions;
 
-  InlineWeeder(this.maxInliningNodes,
-               this.useMaxInliningNodes,
-               this.allowLoops,
-               this.enableUserAssertions);
+  InlineWeeder(this.maxInliningNodes, this.useMaxInliningNodes, this.allowLoops,
+      this.enableUserAssertions);
 
-  static bool canBeInlined(FunctionElement function,
-                           int maxInliningNodes,
-                           bool useMaxInliningNodes,
-                           {bool allowLoops: false,
-                            bool enableUserAssertions: null}) {
+  static bool canBeInlined(
+      FunctionElement function, int maxInliningNodes, bool useMaxInliningNodes,
+      {bool allowLoops: false, bool enableUserAssertions: null}) {
     assert(enableUserAssertions is bool); // Ensure we passed it.
     if (function.resolvedAst.elements.containsTryStatement) return false;
 
-    InlineWeeder weeder =
-        new InlineWeeder(maxInliningNodes, useMaxInliningNodes, allowLoops,
-            enableUserAssertions);
+    InlineWeeder weeder = new InlineWeeder(maxInliningNodes,
+        useMaxInliningNodes, allowLoops, enableUserAssertions);
     ast.FunctionExpression functionExpression = function.node;
     weeder.visit(functionExpression.initializers);
     weeder.visit(functionExpression.body);
     weeder.visit(functionExpression.asyncModifier);
     return !weeder.tooDifficult;
   }
 
   bool registerNode() {
     if (!useMaxInliningNodes) return true;
     if (nodeCount++ > maxInliningNodes) {
@@ skipping 58 matching lines @@
     tooDifficult = true;
   }
 
   void visitRethrow(ast.Rethrow node) {
     if (!registerNode()) return;
     tooDifficult = true;
   }
 
   void visitReturn(ast.Return node) {
     if (!registerNode()) return;
-    if (seenReturn
-        || identical(node.beginToken.stringValue, 'native')) {
+    if (seenReturn || identical(node.beginToken.stringValue, 'native')) {
       tooDifficult = true;
       return;
     }
     node.visitChildren(this);
     seenReturn = true;
   }
 
   void visitThrow(ast.Throw node) {
     if (!registerNode()) return;
     // For now, we don't want to handle throw after a return even if
@@ skipping 19 matching lines @@
 
 class AstInliningState extends InliningState {
   final Local oldReturnLocal;
   final DartType oldReturnType;
   final TreeElements oldElements;
   final List<HInstruction> oldStack;
   final LocalsHandler oldLocalsHandler;
   final bool inTryStatement;
   final bool allFunctionsCalledOnce;
 
-  AstInliningState(FunctionElement function,
-                   this.oldReturnLocal,
-                   this.oldReturnType,
-                   this.oldElements,
-                   this.oldStack,
-                   this.oldLocalsHandler,
-                   this.inTryStatement,
-                   this.allFunctionsCalledOnce)
+  AstInliningState(
+      FunctionElement function,
+      this.oldReturnLocal,
+      this.oldReturnType,
+      this.oldElements,
+      this.oldStack,
+      this.oldLocalsHandler,
+      this.inTryStatement,
+      this.allFunctionsCalledOnce)
       : super(function);
 }
 
 class SsaBranch {
   final SsaBranchBuilder branchBuilder;
   final HBasicBlock block;
   LocalsHandler startLocals;
   LocalsHandler exitLocals;
   SubGraph graph;
 
   SsaBranch(this.branchBuilder) : block = new HBasicBlock();
 }
 
 class SsaBranchBuilder {
   final SsaBuilder builder;
   final ast.Node diagnosticNode;
 
   SsaBranchBuilder(this.builder, [this.diagnosticNode]);
 
   Compiler get compiler => builder.compiler;
 
   void checkNotAborted() {
     if (builder.isAborted()) {
       compiler.unimplemented(diagnosticNode, "aborted control flow");
     }
   }
 
-  void buildCondition(void visitCondition(),
-                      SsaBranch conditionBranch,
-                      SsaBranch thenBranch,
-                      SsaBranch elseBranch,
-                      SourceInformation sourceInformation) {
+  void buildCondition(
+      void visitCondition(),
+      SsaBranch conditionBranch,
+      SsaBranch thenBranch,
+      SsaBranch elseBranch,
+      SourceInformation sourceInformation) {
     startBranch(conditionBranch);
     visitCondition();
     checkNotAborted();
     assert(identical(builder.current, builder.lastOpenedBlock));
     HInstruction conditionValue = builder.popBoolified();
     HIf branch = new HIf(conditionValue)..sourceInformation = sourceInformation;
     HBasicBlock conditionExitBlock = builder.current;
     builder.close(branch);
     conditionBranch.exitLocals = builder.localsHandler;
     conditionExitBlock.addSuccessor(thenBranch.block);
     conditionExitBlock.addSuccessor(elseBranch.block);
     bool conditionBranchLocalsCanBeReused =
         mergeLocals(conditionBranch, thenBranch, mayReuseFromLocals: true);
     mergeLocals(conditionBranch, elseBranch,
-                mayReuseFromLocals: conditionBranchLocalsCanBeReused);
+        mayReuseFromLocals: conditionBranchLocalsCanBeReused);
 
     conditionBranch.graph =
         new SubExpression(conditionBranch.block, conditionExitBlock);
   }
 
   /**
    * Returns true if the locals of the [fromBranch] may be reused. A [:true:]
    * return value implies that [mayReuseFromLocals] was set to [:true:].
    */
   bool mergeLocals(SsaBranch fromBranch, SsaBranch toBranch,
-                   {bool mayReuseFromLocals}) {
+      {bool mayReuseFromLocals}) {
     LocalsHandler fromLocals = fromBranch.exitLocals;
     if (toBranch.startLocals == null) {
       if (mayReuseFromLocals) {
         toBranch.startLocals = fromLocals;
         return false;
       } else {
         toBranch.startLocals = new LocalsHandler.from(fromLocals);
         return true;
       }
     } else {
       toBranch.startLocals.mergeWith(fromLocals, toBranch.block);
       return true;
     }
   }
 
   void startBranch(SsaBranch branch) {
     builder.graph.addBlock(branch.block);
     builder.localsHandler = branch.startLocals;
     builder.open(branch.block);
   }
 
-  HInstruction buildBranch(SsaBranch branch,
-                           void visitBranch(),
-                           SsaBranch joinBranch,
-                           bool isExpression) {
+  HInstruction buildBranch(SsaBranch branch, void visitBranch(),
+      SsaBranch joinBranch, bool isExpression) {
     startBranch(branch);
     visitBranch();
     branch.graph = new SubGraph(branch.block, builder.lastOpenedBlock);
     branch.exitLocals = builder.localsHandler;
     if (!builder.isAborted()) {
       builder.goto(builder.current, joinBranch.block);
       mergeLocals(branch, joinBranch, mayReuseFromLocals: true);
     }
     if (isExpression) {
       checkNotAborted();
       return builder.pop();
     }
     return null;
   }
 
-  handleIf(void visitCondition(),
-           void visitThen(),
-           void visitElse(),
-           {SourceInformation sourceInformation}) {
+  handleIf(void visitCondition(), void visitThen(), void visitElse(),
+      {SourceInformation sourceInformation}) {
     if (visitElse == null) {
       // Make sure to have an else part to avoid a critical edge. A
       // critical edge is an edge that connects a block with multiple
       // successors to a block with multiple predecessors. We avoid
       // such edges because they prevent inserting copies during code
       // generation of phi instructions.
       visitElse = () {};
     }
 
-    _handleDiamondBranch(
-        visitCondition, visitThen, visitElse, isExpression: false,
-        sourceInformation: sourceInformation);
+    _handleDiamondBranch(visitCondition, visitThen, visitElse,
+        isExpression: false, sourceInformation: sourceInformation);
   }
 
-  handleConditional(void visitCondition(),
-                    void visitThen(),
-                    void visitElse()) {
+  handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
     assert(visitElse != null);
-    _handleDiamondBranch(
-        visitCondition, visitThen, visitElse, isExpression: true);
+    _handleDiamondBranch(visitCondition, visitThen, visitElse,
+        isExpression: true);
   }
 
   handleIfNull(void left(), void right()) {
     // x ?? y is transformed into: x == null ? y : x
     HInstruction leftExpression;
-    handleConditional(
-        () {
-          left();
-          leftExpression = builder.pop();
-          builder.pushCheckNull(leftExpression);
-        },
-        right,
-        () => builder.stack.add(leftExpression));
+    handleConditional(() {
+      left();
+      leftExpression = builder.pop();
+      builder.pushCheckNull(leftExpression);
+    }, right, () => builder.stack.add(leftExpression));
   }
 
   void handleLogicalAndOr(void left(), void right(), {bool isAnd}) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //   }
     //   result = phi(t1, false);
     //
@@ skipping 17 matching lines @@
 
     void visitThen() {
       right();
       boolifiedRight = builder.popBoolified();
     }
 
     handleIf(visitCondition, visitThen, null);
     HConstant notIsAnd =
         builder.graph.addConstantBool(!isAnd, builder.compiler);
     JavaScriptBackend backend = builder.backend;
-    HPhi result = new HPhi.manyInputs(null,
-                                      <HInstruction>[boolifiedRight, notIsAnd],
-                                      backend.dynamicType);
+    HPhi result = new HPhi.manyInputs(
+        null, <HInstruction>[boolifiedRight, notIsAnd], backend.dynamicType);
     builder.current.addPhi(result);
     builder.stack.add(result);
   }
 
-  void handleLogicalAndOrWithLeftNode(ast.Node left,
-                                      void visitRight(),
-                                      {bool isAnd}) {
+  void handleLogicalAndOrWithLeftNode(ast.Node left, void visitRight(),
+      {bool isAnd}) {
     // This method is similar to [handleLogicalAndOr] but optimizes the case
     // where left is a logical "and" or logical "or".
     //
     // For example (x && y) && z is transformed into x && (y && z):
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //     if (t1) {
     //       t2 = boolify(z);
     //     }
     //     t3 = phi(t2, false);
     //   }
     //   result = phi(t3, false);
 
     ast.Send send = left.asSend();
-    if (send != null &&
-        (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
+    if (send != null && (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
       ast.Node newLeft = send.receiver;
       Link<ast.Node> link = send.argumentsNode.nodes;
       assert(link.tail.isEmpty);
       ast.Node middle = link.head;
       handleLogicalAndOrWithLeftNode(
           newLeft,
-          () => handleLogicalAndOrWithLeftNode(middle, visitRight,
-                                               isAnd: isAnd),
+          () =>
+              handleLogicalAndOrWithLeftNode(middle, visitRight, isAnd: isAnd),
           isAnd: isAnd);
     } else {
       handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
     }
   }
 
-  void _handleDiamondBranch(void visitCondition(),
-                            void visitThen(),
-                            void visitElse(),
-                            {bool isExpression,
-                             SourceInformation sourceInformation}) {
+  void _handleDiamondBranch(
+      void visitCondition(), void visitThen(), void visitElse(),
+      {bool isExpression, SourceInformation sourceInformation}) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
     SsaBranch joinBranch = new SsaBranch(this);
 
     conditionBranch.startLocals = builder.localsHandler;
     builder.goto(builder.current, conditionBranch.block);
 
     buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch,
-                   sourceInformation);
+        sourceInformation);
     HInstruction thenValue =
         buildBranch(thenBranch, visitThen, joinBranch, isExpression);
     HInstruction elseValue =
         buildBranch(elseBranch, visitElse, joinBranch, isExpression);
 
     if (isExpression) {
       assert(thenValue != null && elseValue != null);
       JavaScriptBackend backend = builder.backend;
       HPhi phi = new HPhi.manyInputs(
           null, <HInstruction>[thenValue, elseValue], backend.dynamicType);
       joinBranch.block.addPhi(phi);
       builder.stack.add(phi);
     }
 
     HBasicBlock joinBlock;
     // If at least one branch did not abort, open the joinBranch.
     if (!joinBranch.block.predecessors.isEmpty) {
       startBranch(joinBranch);
       joinBlock = joinBranch.block;
     }
 
-    HIfBlockInformation info =
-        new HIfBlockInformation(
-          new HSubExpressionBlockInformation(conditionBranch.graph),
-          new HSubGraphBlockInformation(thenBranch.graph),
-          new HSubGraphBlockInformation(elseBranch.graph));
+    HIfBlockInformation info = new HIfBlockInformation(
+        new HSubExpressionBlockInformation(conditionBranch.graph),
+        new HSubGraphBlockInformation(thenBranch.graph),
+        new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }
 
 class TypeBuilder implements DartTypeVisitor<dynamic, SsaBuilder> {
   final ClassWorld classWorld;
 
   TypeBuilder(this.classWorld);
 
   void visit(DartType type, SsaBuilder builder) => type.accept(this, builder);
 
   void visitVoidType(VoidType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.VoidRuntimeType;
     builder.push(new HVoidType(type, new TypeMask.exact(cls, classWorld)));
   }
 
-  void visitTypeVariableType(TypeVariableType type,
-                             SsaBuilder builder) {
+  void visitTypeVariableType(TypeVariableType type, SsaBuilder builder) {
     ClassElement cls = builder.backend.helpers.RuntimeType;
     TypeMask instructionType = new TypeMask.subclass(cls, classWorld);
     if (!builder.sourceElement.enclosingElement.isClosure &&
         builder.sourceElement.isInstanceMember) {
       HInstruction receiver = builder.localsHandler.readThis();
       builder.push(new HReadTypeVariable(type, receiver, instructionType));
     } else {
-      builder.push(
-          new HReadTypeVariable.noReceiver(
-              type, builder.addTypeVariableReference(type), instructionType));
+      builder.push(new HReadTypeVariable.noReceiver(
+          type, builder.addTypeVariableReference(type), instructionType));
     }
   }
 
   void visitFunctionType(FunctionType type, SsaBuilder builder) {
     type.returnType.accept(this, builder);
     HInstruction returnType = builder.pop();
     List<HInstruction> inputs = <HInstruction>[returnType];
 
     for (DartType parameter in type.parameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
     for (DartType parameter in type.optionalParameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
     List<DartType> namedParameterTypes = type.namedParameterTypes;
     List<String> names = type.namedParameters;
     for (int index = 0; index < names.length; index++) {
       ast.DartString dartString = new ast.DartString.literal(names[index]);
-      inputs.add(
-          builder.graph.addConstantString(dartString, builder.compiler));
+      inputs.add(builder.graph.addConstantString(dartString, builder.compiler));
       namedParameterTypes[index].accept(this, builder);
       inputs.add(builder.pop());
     }
 
     ClassElement cls = builder.backend.helpers.RuntimeFunctionType;
-    builder.push(new HFunctionType(inputs, type,
-        new TypeMask.exact(cls, classWorld)));
+    builder.push(
+        new HFunctionType(inputs, type, new TypeMask.exact(cls, classWorld)));
   }
 
   void visitMalformedType(MalformedType type, SsaBuilder builder) {
     visitDynamicType(const DynamicType(), builder);
   }
 
   void visitStatementType(StatementType type, SsaBuilder builder) {
     throw 'not implemented visitStatementType($type)';
   }
 
   void visitInterfaceType(InterfaceType type, SsaBuilder builder) {
     List<HInstruction> inputs = <HInstruction>[];
     for (DartType typeArgument in type.typeArguments) {
       typeArgument.accept(this, builder);
       inputs.add(builder.pop());
     }
     ClassElement cls;
     if (type.typeArguments.isEmpty) {
       cls = builder.backend.helpers.RuntimeTypePlain;
     } else {
       cls = builder.backend.helpers.RuntimeTypeGeneric;
     }
-    builder.push(new HInterfaceType(inputs, type,
-        new TypeMask.exact(cls, classWorld)));
+    builder.push(
+        new HInterfaceType(inputs, type, new TypeMask.exact(cls, classWorld)));
   }
 
   void visitTypedefType(TypedefType type, SsaBuilder builder) {
     DartType unaliased = type.unaliased;
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
@@ skipping 10 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }