dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
-import '../common/names.dart' show
-    Identifiers,
-    Names,
-    Selectors;
-import '../common/tasks.dart' show
-    CompilerTask;
-import '../compiler.dart' show
-    Compiler;
+import '../common/names.dart' show Identifiers, Names, Selectors;
+import '../common/tasks.dart' show CompilerTask;
+import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
-import '../elements/modelx.dart' show
-    SynthesizedConstructorElementX,
-    ConstructorBodyElementX,
-    FunctionSignatureX;
+import '../elements/modelx.dart'
+    show
+        SynthesizedConstructorElementX,
+        ConstructorBodyElementX,
+        FunctionSignatureX;
 import '../io/source_information.dart';
-import '../js_backend/backend_helpers.dart' show
-    BackendHelpers;
-import '../js_backend/js_backend.dart' show
-    JavaScriptBackend,
-    SyntheticConstantKind;
-import '../resolution/tree_elements.dart' show
-    TreeElements;
+import '../js_backend/backend_helpers.dart' show BackendHelpers;
+import '../js_backend/js_backend.dart'
+    show JavaScriptBackend, SyntheticConstantKind;
+import '../resolution/tree_elements.dart' show TreeElements;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/operators.dart' as op;
 import '../tree/tree.dart' as ast;
-import '../types/types.dart' show
-    TypeMask;
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
-import '../constants/values.dart' show
-    ConstantValue;
+import '../types/types.dart' show TypeMask;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector;
+import '../constants/values.dart' show ConstantValue;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder.dart';
-import '../native/native.dart' show
-    NativeBehavior,
-    HasCapturedPlaceholders;
+import '../native/native.dart' show NativeBehavior, HasCapturedPlaceholders;
 
 // TODO(karlklose): remove.
 import '../js/js.dart' as js show js, Template, Expression, Name;
 import '../ssa/types.dart' show TypeMaskFactory;
 import '../util/util.dart';
 
 import 'package:js_runtime/shared/embedded_names.dart'
     show JsBuiltin, JsGetName;
 import '../constants/values.dart';
-import 'type_mask_system.dart' show
-    TypeMaskSystem;
+import 'type_mask_system.dart' show TypeMaskSystem;
 
 typedef void IrBuilderCallback(Element element, ir.FunctionDefinition irNode);
 
 class ExplicitReceiverParameter implements Local {
   final ExecutableElement executableContext;
 
   ExplicitReceiverParameter(this.executableContext);
 
   String get name => 'receiver';
   String toString() => 'ExplicitReceiverParameter($executableContext)';
@@ skipping 12 matching lines @@
   /// If not null, this function will be called with for each
   /// [ir.FunctionDefinition] node that has been built.
   IrBuilderCallback builderCallback;
 
   IrBuilderTask(Compiler compiler, this.sourceInformationStrategy,
       [this.builderCallback])
       : super(compiler);
 
   String get name => 'CPS builder';
 
-  ir.FunctionDefinition buildNode(AstElement element,
-                                  TypeMaskSystem typeMaskSystem) {
+  ir.FunctionDefinition buildNode(
+      AstElement element, TypeMaskSystem typeMaskSystem) {
     return measure(() {
       bailoutMessage = null;
 
       TreeElements elementsMapping = element.resolvedAst.elements;
       element = element.implementation;
       return reporter.withCurrentElement(element, () {
         SourceInformationBuilder sourceInformationBuilder =
             sourceInformationStrategy.createBuilderForContext(element);
 
-        IrBuilderVisitor builder =
-            new IrBuilderVisitor(
-                elementsMapping, compiler, sourceInformationBuilder,
-                typeMaskSystem);
+        IrBuilderVisitor builder = new IrBuilderVisitor(elementsMapping,
+            compiler, sourceInformationBuilder, typeMaskSystem);
         ir.FunctionDefinition irNode = builder.buildExecutable(element);
         if (irNode == null) {
           bailoutMessage = builder.bailoutMessage;
         } else if (builderCallback != null) {
           builderCallback(element, irNode);
         }
         return irNode;
       });
     });
   }
 }
 
 /// Translates the frontend AST of a method to its CPS IR.
 ///
 /// The visitor has an [IrBuilder] which contains an IR fragment to build upon
 /// and the current reaching definition of local variables.
 ///
 /// Visiting a statement or expression extends the IR builder's fragment.
 /// For expressions, the primitive holding the resulting value is returned.
 /// For statements, `null` is returned.
 // TODO(johnniwinther): Implement [SemanticDeclVisitor].
 class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
-    with IrBuilderMixin<ast.Node>,
-         SemanticSendResolvedMixin<ir.Primitive, dynamic>,
-         ErrorBulkMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfSetIfNullsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfSuperIndexSetIfNullMixin<ir.Primitive, dynamic>
+    with
+        IrBuilderMixin<ast.Node>,
+        SemanticSendResolvedMixin<ir.Primitive, dynamic>,
+        ErrorBulkMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfSetIfNullsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>,
+        BaseImplementationOfSuperIndexSetIfNullMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
   final TypeMaskSystem typeMaskSystem;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
@@ skipping 13 matching lines @@
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
-  IrBuilderVisitor(this.elements,
-                   this.compiler,
-                   this.sourceInformationBuilder,
-                   this.typeMaskSystem);
+  IrBuilderVisitor(this.elements, this.compiler, this.sourceInformationBuilder,
+      this.typeMaskSystem);
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   DiagnosticReporter get reporter => compiler.reporter;
 
   String bailoutMessage = null;
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   @override
@@ skipping 15 matching lines @@
   ClosureScope getClosureScopeForNode(ast.Node node) {
     // We translate a ClosureScope from closure.dart into IR builder's variant
     // because the IR builder should not depend on the synthetic elements
     // created in closure.dart.
     return new ClosureScope(closureClassMap.capturingScopes[node]);
   }
 
   /// Returns the [ClosureScope] for any function, possibly different from the
   /// one currently being built.
   ClosureScope getClosureScopeForFunction(FunctionElement function) {
-    closure.ClosureClassMap map =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            function,
-            function.node,
-            elements);
+    closure.ClosureClassMap map = compiler.closureToClassMapper
+        .computeClosureToClassMapping(function, function.node, elements);
     return new ClosureScope(map.capturingScopes[function.node]);
   }
 
   /// If the current function is a nested function with free variables (or a
   /// captured reference to `this`), returns a [ClosureEnvironment]
   /// indicating how to access these.
   ClosureEnvironment getClosureEnvironment() {
     return new ClosureEnvironment(closureClassMap);
   }
 
   IrBuilder getBuilderFor(Element element) {
     return new IrBuilder(
-        new GlobalProgramInformation(compiler),
-        backend.constants,
-        element);
+        new GlobalProgramInformation(compiler), backend.constants, element);
   }
 
   /// Builds the [ir.FunctionDefinition] for an executable element. In case the
   /// function uses features that cannot be expressed in the IR, this element
   /// returns `null`.
   ir.FunctionDefinition buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
       ir.FunctionDefinition root;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
@@ skipping 48 matching lines @@
     }
   }
 
   /// Loads all type variables for [type] and all of its super classes into
   /// the environment. All type variables mentioned in [type] must already
   /// be in the environment.
   void loadTypeVariablesForType(InterfaceType type) {
     ClassElement clazz = type.element;
     assert(clazz.typeVariables.length == type.typeArguments.length);
     for (int i = 0; i < clazz.typeVariables.length; ++i) {
-      irBuilder.declareTypeVariable(clazz.typeVariables[i],
-          type.typeArguments[i]);
+      irBuilder.declareTypeVariable(
+          clazz.typeVariables[i], type.typeArguments[i]);
     }
     loadTypeVariablesForSuperClasses(clazz);
   }
 
   /// Returns the constructor body associated with the given constructor or
   /// creates a new constructor body, if none can be found.
   ///
   /// Returns `null` if the constructor does not have a body.
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
     // TODO(asgerf): This is largely inherited from the SSA builder.
@@ skipping 19 matching lines @@
       }
     });
     if (bodyElement == null) {
       bodyElement = new ConstructorBodyElementX(constructor);
       classElement.addBackendMember(bodyElement);
 
       if (constructor.isPatch) {
         // Create origin body element for patched constructors.
         ConstructorBodyElementX patch = bodyElement;
         ConstructorBodyElementX origin =
-        new ConstructorBodyElementX(constructor.origin);
+            new ConstructorBodyElementX(constructor.origin);
         origin.applyPatch(patch);
         classElement.origin.addBackendMember(bodyElement.origin);
       }
     }
     assert(bodyElement.isGenerativeConstructorBody);
     return bodyElement;
   }
 
   /// The list of parameters to send from the generative constructor
   /// to the generative constructor body.
@@ skipping 43 matching lines @@
     final bool requiresTypeInformation =
         builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
       List<Local> parameters = <Local>[];
       if (constructor.isGenerativeConstructor &&
           backend.isNativeOrExtendsNative(classElement)) {
         parameters.add(new ExplicitReceiverParameter(constructor));
       }
-      constructor.functionSignature.orderedForEachParameter(
-          (ParameterElement p) => parameters.add(p));
+      constructor.functionSignature
+          .orderedForEachParameter((ParameterElement p) => parameters.add(p));
 
       int firstTypeArgumentParameterIndex;
 
       // If instances of the class may need runtime type information, we add a
       // synthetic parameter for each type parameter.
       if (requiresTypeInformation) {
         firstTypeArgumentParameterIndex = parameters.length;
         classElement.typeVariables.forEach((TypeVariableType variable) {
           parameters.add(new closure.TypeVariableLocal(variable, constructor));
         });
@@ skipping 62 matching lines @@
         instance.type =
             new TypeMask.exact(classElement, typeMaskSystem.classWorld);
         irBuilder.addPrimitive(new ir.ReceiverCheck.nullCheck(
             instance, Selectors.toString_, null));
         for (int i = 0; i < fields.length; i++) {
           irBuilder.addPrimitive(
               new ir.SetField(instance, fields[i], instanceArguments[i]));
         }
       } else {
         instance = new ir.CreateInstance(
-          classElement,
-          instanceArguments,
-          typeInformation,
-          constructor.hasNode
-              ? sourceInformationBuilder.buildCreate(constructor.node)
-              // TODO(johnniwinther): Provide source information for creation
-              // through synthetic constructors.
-              : null);
+            classElement,
+            instanceArguments,
+            typeInformation,
+            constructor.hasNode
+                ? sourceInformationBuilder.buildCreate(constructor.node)
+                // TODO(johnniwinther): Provide source information for creation
+                // through synthetic constructors.
+                : null);
         irBuilder.add(new ir.LetPrim(instance));
       }
 
       // --- Call constructor bodies ---
       for (ConstructorElement target in constructorList) {
         ConstructorBodyElement bodyElement = getConstructorBody(target);
         if (bodyElement == null) continue; // Skip if constructor has no body.
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
-        Selector selector = new Selector.call(target.memberName,
-            new CallStructure(bodyArguments.length));
+        Selector selector = new Selector.call(
+            target.memberName, new CallStructure(bodyArguments.length));
         irBuilder.addPrimitive(new ir.InvokeMethodDirectly(
             instance, bodyElement, selector, bodyArguments, null));
       }
 
       // --- step 4: return the created object ----
       irBuilder.buildReturn(
           value: instance,
           sourceInformation:
-          sourceInformationBuilder.buildImplicitReturn(constructor));
+              sourceInformationBuilder.buildImplicitReturn(constructor));
 
       return irBuilder.makeFunctionDefinition(
           sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   /// Make a visitor suitable for translating ASTs taken from [context].
   ///
   /// Every visitor can only be applied to nodes in one context, because
   /// the [elements] field is specific to that context.
   IrBuilderVisitor makeVisitorForContext(AstElement context) {
-    return new IrBuilderVisitor(
-        context.resolvedAst.elements,
-        compiler,
-        sourceInformationBuilder.forContext(context),
-        typeMaskSystem);
+    return new IrBuilderVisitor(context.resolvedAst.elements, compiler,
+        sourceInformationBuilder.forContext(context), typeMaskSystem);
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     IrBuilderVisitor visitor = makeVisitorForContext(context);
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
   }
 
   /// Evaluate the implicit super call in the given mixin constructor.
   void forwardSynthesizedMixinConstructor(
       ConstructorElement constructor,
       List<ConstructorElement> supers,
       Map<FieldElement, ir.Primitive> fieldValues) {
     assert(constructor.enclosingClass.implementation.isMixinApplication);
     assert(constructor.isSynthesized);
-    ConstructorElement target =
-        constructor.definingConstructor.implementation;
+    ConstructorElement target = constructor.definingConstructor.implementation;
     // The resolver gives us the exact same FunctionSignature for the two
     // constructors. The parameters for the synthesized constructor
     // are already in the environment, so the target constructor's parameters
     // are also in the environment since their elements are the same.
     assert(constructor.functionSignature == target.functionSignature);
     IrBuilderVisitor visitor = makeVisitorForContext(target);
     visitor.withBuilder(irBuilder, () {
       visitor.evaluateConstructorFieldInitializers(target, supers, fieldValues);
     });
   }
 
   /// In preparation of inlining (part of) [target], the [arguments] are moved
   /// into the environment bindings for the corresponding parameters.
   ///
   /// Defaults for optional arguments are evaluated in order to ensure
   /// all parameters are available in the environment.
-  void loadArguments(ConstructorElement target,
-      CallStructure call,
+  void loadArguments(ConstructorElement target, CallStructure call,
       List<ir.Primitive> arguments) {
     assert(target.isImplementation);
     assert(target == elements.analyzedElement);
     FunctionSignature signature = target.functionSignature;
 
     // Establish a scope in case parameters are captured.
     ClosureScope scope = getClosureScopeForFunction(target);
     irBuilder.enterScope(scope);
 
     // Load required parameters
@@ skipping 86 matching lines @@
     }
     // If this is a mixin constructor, it does not have its own parameter list
     // or initializer list. Directly forward to the super constructor.
     // Note that the declaration-site initializers originating from the
     // mixed-in class were handled above.
     if (enclosingClass.isMixinApplication) {
       forwardSynthesizedMixinConstructor(constructor, supers, fieldValues);
       return;
     }
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
-    constructor.functionSignature.orderedForEachParameter(
-        (ParameterElement parameter) {
+    constructor.functionSignature
+        .orderedForEachParameter((ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
             irBuilder.buildLocalGet(parameter);
       }
     });
     // Evaluate constructor initializers, e.g. `Foo() : x = 50`.
     ast.FunctionExpression node = constructor.node;
     bool hasConstructorCall = false; // Has this() or super() initializer?
     if (node != null && node.initializers != null) {
-      for(ast.Node initializer in node.initializers) {
+      for (ast.Node initializer in node.initializers) {
         if (initializer is ast.SendSet) {
           // Field initializer.
           FieldElement field = elements[initializer];
           fieldValues[field] = visit(initializer.arguments.head);
         } else if (initializer is ast.Send) {
           // Super or this initializer.
           ConstructorElement target = elements[initializer].implementation;
           Selector selector = elements.getSelector(initializer);
           List<ir.Primitive> arguments = initializer.arguments.mapToList(visit);
           evaluateConstructorCallFromInitializer(
-              target,
-              selector.callStructure,
-              arguments,
-              supers,
-              fieldValues);
+              target, selector.callStructure, arguments, supers, fieldValues);
           hasConstructorCall = true;
         } else {
-          reporter.internalError(initializer,
-              "Unexpected initializer type $initializer");
+          reporter.internalError(
+              initializer, "Unexpected initializer type $initializer");
         }
       }
     }
     // If no super() or this() was found, also call default superconstructor.
     if (!hasConstructorCall && !enclosingClass.isObject) {
       ClassElement superClass = enclosingClass.superclass;
       FunctionElement target = superClass.lookupDefaultConstructor();
       if (target == null) {
         reporter.internalError(superClass, "No default constructor available.");
       }
       target = target.implementation;
       evaluateConstructorCallFromInitializer(
-          target,
-          CallStructure.NO_ARGS,
-          const [],
-          supers,
-          fieldValues);
+          target, CallStructure.NO_ARGS, const [], supers, fieldValues);
     }
     // Add this constructor after the superconstructors.
     supers.add(constructor);
   }
 
   TryBoxedVariables _analyzeTryBoxedVariables(ast.Node node) {
     TryBoxedVariables variables = new TryBoxedVariables(elements);
     try {
       variables.analyze(node);
     } catch (e) {
       bailoutMessage = variables.bailoutMessage;
       rethrow;
     }
     return variables;
   }
 
   /// Builds the IR for the body of a constructor.
   ///
   /// This function is invoked from one or more "factory" constructors built by
   /// [buildConstructor].
   ir.FunctionDefinition buildConstructorBody(ConstructorBodyElement body) {
     ConstructorElement constructor = body.constructor;
     ast.FunctionExpression node = constructor.node;
-    closureClassMap =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            constructor,
-            node,
-            elements);
+    closureClassMap = compiler.closureToClassMapper
+        .computeClosureToClassMapping(constructor, node, elements);
 
     // We compute variables boxed in mutable variables on entry to each try
     // block, not including variables captured by a closure (which are boxed
     // in the heap).  This duplicates some of the work of closure conversion
     // without directly using the results.  This duplication is wasteful and
     // error-prone.
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
     TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
-      irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
-          getClosureScopeForNode(node));
+      irBuilder.buildConstructorBodyHeader(
+          getConstructorBodyParameters(body), getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition(
           sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
-    closureClassMap =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            element,
-            node,
-            elements);
+    closureClassMap = compiler.closureToClassMapper
+        .computeClosureToClassMapping(element, node, elements);
     TryBoxedVariables variables = _analyzeTryBoxedVariables(node);
     tryStatements = variables.tryStatements;
     IrBuilder builder = getBuilderFor(element);
-    return withBuilder(builder,
-        () => _makeFunctionBody(builder, element, node));
+    return withBuilder(
+        builder, () => _makeFunctionBody(builder, element, node));
   }
 
   ir.FunctionDefinition buildStaticFieldInitializer(FieldElement element) {
     if (!backend.constants.lazyStatics.contains(element)) {
       return null; // Nothing to do.
     }
-    closureClassMap =
-        compiler.closureToClassMapper.computeClosureToClassMapping(
-            element,
-            element.node,
-            elements);
+    closureClassMap = compiler.closureToClassMapper
+        .computeClosureToClassMapping(element, element.node, elements);
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () {
       irBuilder.buildFunctionHeader(<Local>[]);
       ir.Primitive initialValue = visit(element.initializer);
       ast.VariableDefinitions node = element.node;
       ast.SendSet sendSet = node.definitions.nodes.head;
       irBuilder.buildReturn(
           value: initialValue,
           sourceInformation:
-          sourceInformationBuilder.buildReturn(sendSet.assignmentOperator));
+              sourceInformationBuilder.buildReturn(sendSet.assignmentOperator));
       return irBuilder.makeFunctionDefinition(
           sourceInformationBuilder.buildVariableDeclaration());
     });
   }
 
   /// Builds the IR for a constant taken from a different [context].
   ///
   /// Such constants need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
@@ skipping 14 matching lines @@
   }
 
   /// Normalizes the argument list of a static invocation.
   ///
   /// A static invocation is one where the target is known.  The argument list
   /// [arguments] is normalized by adding default values for optional arguments
   /// that are not passed, and by sorting it in place so that named arguments
   /// appear in a canonical order.  A [CallStructure] reflecting this order
   /// is returned.
   CallStructure normalizeStaticArguments(CallStructure callStructure,
-      FunctionElement target,
-      List<ir.Primitive> arguments) {
+      FunctionElement target, List<ir.Primitive> arguments) {
     target = target.implementation;
     FunctionSignature signature = target.functionSignature;
     if (!signature.optionalParametersAreNamed &&
         signature.parameterCount == arguments.length) {
       return callStructure;
     }
 
     if (!signature.optionalParametersAreNamed) {
       int i = signature.requiredParameterCount;
       signature.forEachOptionalParameter((ParameterElement element) {
         if (i < callStructure.positionalArgumentCount) {
           ++i;
         } else {
           arguments.add(translateDefaultValue(element));
         }
       });
       return new CallStructure(signature.parameterCount);
     }
 
     int offset = signature.requiredParameterCount;
     List<ir.Primitive> namedArguments = arguments.sublist(offset);
     arguments.length = offset;
     List<String> normalizedNames = <String>[];
     // Iterate over the optional parameters of the signature, and try to
     // find them in the callStructure's named arguments. If found, we use the
     // value in the temporary list, otherwise the default value.
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       int nameIndex = callStructure.namedArguments.indexOf(element.name);
-      arguments.add(nameIndex == -1 ? translateDefaultValue(element)
+      arguments.add(nameIndex == -1
+          ? translateDefaultValue(element)
           : namedArguments[nameIndex]);
       normalizedNames.add(element.name);
     });
     return new CallStructure(signature.parameterCount, normalizedNames);
   }
 
   /// Normalizes the argument list of a dynamic invocation.
   ///
   /// A dynamic invocation is one where the target is not known.  The argument
   /// list [arguments] is normalized by sorting it in place so that the named
   /// arguments appear in a canonical order.  A [CallStructure] reflecting this
   /// order is returned.
-  CallStructure normalizeDynamicArguments(CallStructure callStructure,
-      List<ir.Primitive> arguments) {
+  CallStructure normalizeDynamicArguments(
+      CallStructure callStructure, List<ir.Primitive> arguments) {
     assert(arguments.length == callStructure.argumentCount);
     if (callStructure.namedArguments.isEmpty) return callStructure;
     int destinationIndex = callStructure.positionalArgumentCount;
     List<ir.Primitive> namedArguments = arguments.sublist(destinationIndex);
     for (String argName in callStructure.getOrderedNamedArguments()) {
       int sourceIndex = callStructure.namedArguments.indexOf(argName);
       arguments[destinationIndex++] = namedArguments[sourceIndex];
     }
-    return new CallStructure(callStructure.argumentCount,
-        callStructure.getOrderedNamedArguments());
+    return new CallStructure(
+        callStructure.argumentCount, callStructure.getOrderedNamedArguments());
   }
 
   /// Read the value of [field].
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
     ConstantValue constant = getConstantForVariable(field);
     if (constant != null && !field.isAssignable) {
       typeMaskSystem.associateConstantValueWithElement(constant, field);
       return irBuilder.buildConstant(constant, sourceInformation: src);
     } else if (backend.constants.lazyStatics.contains(field)) {
       return irBuilder.addPrimitive(new ir.GetLazyStatic(field,
           sourceInformation: src,
           isFinal: compiler.world.fieldNeverChanges(field)));
     } else {
       return irBuilder.addPrimitive(new ir.GetStatic(field,
           sourceInformation: src,
           isFinal: compiler.world.fieldNeverChanges(field)));
     }
   }
 
   ir.FunctionDefinition _makeFunctionBody(
-      IrBuilder builder,
-      FunctionElement element,
-      ast.FunctionExpression node) {
+      IrBuilder builder, FunctionElement element, ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<Local> parameters = <Local>[];
     signature.orderedForEachParameter(
         (LocalParameterElement e) => parameters.add(e));
 
     bool requiresRuntimeTypes = false;
     if (element.isFactoryConstructor) {
       requiresRuntimeTypes =
           builder.program.requiresRuntimeTypesFor(element.enclosingElement);
       if (requiresRuntimeTypes) {
         // Type arguments are passed in as extra parameters.
         for (DartType typeVariable in element.enclosingClass.typeVariables) {
           parameters.add(new closure.TypeVariableLocal(typeVariable, element));
         }
       }
     }
 
     irBuilder.buildFunctionHeader(parameters,
-                                  closureScope: getClosureScopeForNode(node),
-                                  env: getClosureEnvironment());
+        closureScope: getClosureScopeForNode(node),
+        env: getClosureEnvironment());
 
     if (element == helpers.jsArrayTypedConstructor) {
       // Generate a body for JSArray<E>.typed(allocation):
       //
       //    t1 = setRuntimeTypeInfo(allocation, TypeExpression($E));
       //    return Refinement(t1, <JSArray>);
       //
       assert(parameters.length == 1 || parameters.length == 2);
       ir.Primitive allocation = irBuilder.buildLocalGet(parameters[0]);
       ClassElement classElement = element.enclosingElement;
 
       // Only call setRuntimeTypeInfo if JSArray requires the type parameter.
       if (requiresRuntimeTypes) {
         assert(parameters.length == 2);
         closure.TypeVariableLocal typeParameter = parameters[1];
         ir.Primitive typeArgument =
             irBuilder.buildTypeVariableAccess(typeParameter.typeVariable);
 
         ir.Primitive typeInformation = irBuilder.addPrimitive(
             new ir.TypeExpression(ir.TypeExpressionKind.INSTANCE,
-                                  element.enclosingClass.thisType,
-                                  <ir.Primitive>[typeArgument]));
+                element.enclosingClass.thisType, <ir.Primitive>[typeArgument]));
 
         MethodElement helper = helpers.setRuntimeTypeInfo;
         CallStructure callStructure = CallStructure.TWO_ARGS;
         Selector selector = new Selector.call(helper.memberName, callStructure);
         allocation = irBuilder.buildInvokeStatic(
-            helper, selector, <ir.Primitive>[allocation, typeInformation],
+            helper,
+            selector,
+            <ir.Primitive>[allocation, typeInformation],
             sourceInformationBuilder.buildGeneric(node));
       }
 
       ir.Primitive refinement = irBuilder.addPrimitive(
           new ir.Refinement(allocation, typeMaskSystem.arrayType));
 
-      irBuilder.buildReturn(value: refinement,
+      irBuilder.buildReturn(
+          value: refinement,
           sourceInformation:
               sourceInformationBuilder.buildImplicitReturn(element));
     } else {
       visit(node.body);
     }
     return irBuilder.makeFunctionDefinition(
         sourceInformationBuilder.buildVariableDeclaration());
   }
 
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   closure.ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     closure.ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     closure.ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
 
   ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
-    return irBuilder.buildFunctionExpression(makeSubFunction(node),
-        sourceInformationBuilder.buildCreate(node));
+    return irBuilder.buildFunctionExpression(
+        makeSubFunction(node), sourceInformationBuilder.buildCreate(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     Object inner = makeSubFunction(node.function);
-    irBuilder.declareLocalFunction(element, inner,
-        sourceInformationBuilder.buildCreate(node.function));
+    irBuilder.declareLocalFunction(
+        element, inner, sourceInformationBuilder.buildCreate(node.function));
   }
 
   // ## Statements ##
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
     if (!irBuilder.buildBreak(elements.getTargetOf(node))) {
       reporter.internalError(node, "'break' target not found");
@@ skipping 50 matching lines @@
         redirectingConstructor.functionSignature;
     List<String> namedParameters = <String>[];
     redirectingSignature.forEachParameter((ParameterElement parameter) {
       arguments.add(irBuilder.environment.lookup(parameter));
       if (parameter.isNamed) {
         namedParameters.add(parameter.name);
       }
     });
     ClassElement cls = redirectingConstructor.enclosingClass;
     InterfaceType targetType =
-          redirectingConstructor.computeEffectiveTargetType(cls.thisType);
-    CallStructure callStructure = new CallStructure(
-        redirectingSignature.parameterCount,
-        namedParameters);
+        redirectingConstructor.computeEffectiveTargetType(cls.thisType);
+    CallStructure callStructure =
+        new CallStructure(redirectingSignature.parameterCount, namedParameters);
     callStructure =
         normalizeStaticArguments(callStructure, targetConstructor, arguments);
     ir.Primitive instance = irBuilder.buildConstructorInvocation(
         targetConstructor,
         callStructure,
         targetType,
         arguments,
         sourceInformationBuilder.buildNew(node));
     irBuilder.buildReturn(
         value: instance,
@@ skipping 15 matching lines @@
         buildInitializer: subbuild(node.initializer),
         buildCondition: subbuild(node.condition),
         buildBody: subbuild(node.body),
         buildUpdate: subbuildSequence(node.update),
         closureScope: getClosureScopeForNode(node),
         loopVariables: loopVariables,
         target: target);
   }
 
   visitIf(ast.If node) {
-    irBuilder.buildIf(
-        build(node.condition),
-        subbuild(node.thenPart),
-        subbuild(node.elsePart),
-        sourceInformationBuilder.buildIf(node));
+    irBuilder.buildIf(build(node.condition), subbuild(node.thenPart),
+        subbuild(node.elsePart), sourceInformationBuilder.buildIf(node));
   }
 
   visitLabeledStatement(ast.LabeledStatement node) {
     ast.Statement body = node.statement;
     if (body is ast.Loop) {
       visit(body);
     } else {
       JumpTarget target = elements.getTargetDefinition(body);
       irBuilder.buildLabeledStatement(
-          buildBody: subbuild(body),
-          target: target);
+          buildBody: subbuild(body), target: target);
     }
   }
 
   visitDoWhile(ast.DoWhile node) {
     irBuilder.buildDoWhile(
         buildBody: subbuild(node.body),
         buildCondition: subbuild(node.condition),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
@@ skipping 55 matching lines @@
           Element variable = elements.getForInVariable(node);
           SourceInformation sourceInformation =
               sourceInformationBuilder.buildForInSet(node);
           if (Elements.isLocal(variable)) {
             if (node.declaredIdentifier.asVariableDefinitions() != null) {
               irBuilder.declareLocalVariable(variable);
             }
             irBuilder.buildLocalVariableSet(
                 variable, current, sourceInformation);
           } else if (Elements.isError(variable) ||
-                     Elements.isMalformed(variable)) {
+              Elements.isMalformed(variable)) {
             Selector selector =
                 new Selector.setter(new Name(variable.name, variable.library));
             List<ir.Primitive> args = <ir.Primitive>[current];
             // Note the comparison below.  It can be the case that an element
             // isError and isMalformed.
             if (Elements.isError(variable)) {
               irBuilder.buildStaticNoSuchMethod(
                   selector, args, sourceInformation);
             } else {
               irBuilder.buildErroneousInvocation(
@@ skipping 30 matching lines @@
     ir.Node buildFinallyBody(IrBuilder builder) {
       ir.Primitive cancellation = builder.buildDynamicInvocation(
           iterator,
           Selectors.cancel,
           backend.dynamicType,
           <ir.Primitive>[],
           sourceInformationBuilder.buildGeneric(node));
       return builder.addPrimitive(new ir.Await(cancellation));
     }
 
-    irBuilder.buildTryFinally(new TryStatementInfo(), buildTryBody,
-        buildFinallyBody);
+    irBuilder.buildTryFinally(
+        new TryStatementInfo(), buildTryBody, buildFinallyBody);
   }
 
   visitAwait(ast.Await node) {
     assert(irBuilder.isOpen);
     ir.Primitive value = visit(node.expression);
     return irBuilder.addPrimitive(new ir.Await(value));
   }
 
   visitYield(ast.Yield node) {
     assert(irBuilder.isOpen);
@@ skipping 11 matching lines @@
     Element variableElement = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
 
     irBuilder.buildForIn(
         buildExpression: subbuild(node.expression),
         buildVariableDeclaration: subbuild(variableDeclaration),
         variableElement: variableElement,
         variableSelector: selector,
         variableMask: elements.getTypeMask(identifier),
         variableSetSourceInformation:
-          sourceInformationBuilder.buildForInSet(node),
+            sourceInformationBuilder.buildForInSet(node),
         currentMask: elements.getCurrentTypeMask(node),
         currentSourceInformation:
-          sourceInformationBuilder.buildForInCurrent(node),
+            sourceInformationBuilder.buildForInCurrent(node),
         moveNextMask: elements.getMoveNextTypeMask(node),
         moveNextSourceInformation:
-          sourceInformationBuilder.buildForInMoveNext(node),
+            sourceInformationBuilder.buildForInMoveNext(node),
         iteratorMask: elements.getIteratorTypeMask(node),
         iteratorSourceInformation:
-          sourceInformationBuilder.buildForInIterator(node),
+            sourceInformationBuilder.buildForInIterator(node),
         buildBody: subbuild(node.body),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
   /// If compiling with trusted type annotations, assumes that [value] is
   /// now known to be `null` or an instance of [type].
   ///
   /// This is also where we should add type checks in checked mode, but this
   /// is not supported yet.
@@ skipping 37 matching lines @@
   visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     SourceInformation source = sourceInformationBuilder.buildReturn(node);
     if (node.beginToken.value == 'native') {
       FunctionElement function = irBuilder.state.currentElement;
       assert(backend.isNative(function));
       ast.Node nativeBody = node.expression;
       if (nativeBody != null) {
         ast.LiteralString jsCode = nativeBody.asLiteralString();
         String javaScriptCode = jsCode.dartString.slowToString();
-        assert(invariant(nativeBody,
-            !nativeRedirectionRegExp.hasMatch(javaScriptCode),
-          message: "Deprecated syntax, use @JSName('name') instead."));
-        assert(invariant(nativeBody,
-            function.functionSignature.parameterCount == 0,
+        assert(invariant(
+            nativeBody, !nativeRedirectionRegExp.hasMatch(javaScriptCode),
+            message: "Deprecated syntax, use @JSName('name') instead."));
+        assert(invariant(
+            nativeBody, function.functionSignature.parameterCount == 0,
             message: 'native "..." syntax is restricted to '
-              'functions with zero parameters.'));
+                'functions with zero parameters.'));
         irBuilder.buildNativeFunctionBody(function, javaScriptCode,
             sourceInformationBuilder.buildForeignCode(node));
       } else {
         String name = backend.nativeData.getFixedBackendName(function);
         irBuilder.buildRedirectingNativeFunctionBody(function, name, source);
       }
     } else {
       irBuilder.buildReturn(
-          value: build(node.expression),
-          sourceInformation: source);
+          value: build(node.expression), sourceInformation: source);
     }
   }
 
   visitSwitchStatement(ast.SwitchStatement node) {
     // Dart switch cases can be labeled and be the target of continue from
     // within the switch.  Such cases are 'recursive'.  If there are any
     // recursive cases, we implement the switch using a pair of switches with
     // the second one switching over a state variable in a loop.  The first
     // switch contains the non-recursive cases, and the second switch contains
     // the recursive ones.
@@ skipping 75 matching lines @@
     // Use a simple switch for the non-recursive cases.  A break will go to the
     // join-point after the switch.  A continue to a labeled case will assign
     // to the state variable and go to the join-point.
     ir.Primitive value = visit(node.expression);
     JumpCollector join = new ForwardJumpCollector(irBuilder.environment,
         target: elements.getTargetDefinition(node));
     irBuilder.state.breakCollectors.add(join);
     for (int i = 0; i < continueTargets.length; ++i) {
       // The state value is i, the case's position in the list of recursive
       // cases.
-      irBuilder.state.continueCollectors.add(new GotoJumpCollector(
-          continueTargets[i], stateIndex, i, join));
+      irBuilder.state.continueCollectors
+          .add(new GotoJumpCollector(continueTargets[i], stateIndex, i, join));
     }
 
     // For each non-default case use a pair of functions, one to translate the
     // condition and one to translate the body.  For the default case use a
     // function to translate the body.  Use continueTargetIterator as a pointer
     // to the next recursive case.
     Iterator<JumpTarget> continueTargetIterator = continueTargets.iterator;
     continueTargetIterator.moveNext();
     List<SwitchCaseInfo> cases = <SwitchCaseInfo>[];
     SubbuildFunction buildDefaultBody;
@@ skipping 30 matching lines @@
             if (labelOrCase is ast.CaseMatch) {
               ir.Primitive buildComparison() {
                 ir.Primitive constant =
                     translateConstant(labelOrCase.expression);
                 return irBuilder.buildIdentical(value, constant);
               }
 
               if (condition == null) {
                 condition = buildComparison();
               } else {
-                condition = irBuilder.buildLogicalOperator(condition,
+                condition = irBuilder.buildLogicalOperator(
+                    condition,
                     nested(buildComparison),
                     sourceInformationBuilder.buildSwitchCase(switchCase),
                     isLazyOr: true);
               }
             }
           }
           return condition;
         });
       }
 
@@ skipping 45 matching lines @@
     // has not been assigned.
     //
     // 'loop' is the join-point of the exits from the inner switch which will
     // perform another iteration of the loop.  'exit' is the join-point of the
     // breaks from the switch, outside the loop.
     JumpCollector loop = new ForwardJumpCollector(irBuilder.environment);
     JumpCollector exit = new ForwardJumpCollector(irBuilder.environment,
         target: elements.getTargetDefinition(node));
     irBuilder.state.breakCollectors.add(exit);
     for (int i = 0; i < continueTargets.length; ++i) {
-      irBuilder.state.continueCollectors.add(new GotoJumpCollector(
-          continueTargets[i], stateIndex, i, loop));
+      irBuilder.state.continueCollectors
+          .add(new GotoJumpCollector(continueTargets[i], stateIndex, i, loop));
     }
     cases.clear();
     for (int i = 0; i < continueTargets.length; ++i) {
       // The conditions compare to the recursive case index.
       ir.Primitive buildCondition(IrBuilder builder) {
         ir.Primitive constant = builder.buildIntegerConstant(i);
         return builder.buildIdentical(
             builder.environment.index2value[stateIndex], constant);
       }
 
@@ skipping 17 matching lines @@
         });
         return null;
       }
 
       cases.add(new SwitchCaseInfo(buildCondition, buildBody,
           sourceInformationBuilder.buildSwitch(node)));
     }
 
     // A loop with a simple switch in the body.
     IrBuilder whileBuilder = irBuilder.makeDelimitedBuilder();
-    whileBuilder.buildWhile(
-        buildCondition: (IrBuilder builder) {
-          ir.Primitive condition = builder.buildIdentical(
-              builder.environment.index2value[stateIndex], initial);
-          return builder.buildNegation(condition,
-              sourceInformationBuilder.buildSwitch(node));
-        },
-        buildBody: (IrBuilder builder) {
-          builder.buildSimpleSwitch(loop, cases, null);
-        });
+    whileBuilder.buildWhile(buildCondition: (IrBuilder builder) {
+      ir.Primitive condition = builder.buildIdentical(
+          builder.environment.index2value[stateIndex], initial);
+      return builder.buildNegation(
+          condition, sourceInformationBuilder.buildSwitch(node));
+    }, buildBody: (IrBuilder builder) {
+      builder.buildSimpleSwitch(loop, cases, null);
+    });
     // Jump to the exit continuation.  This jump is the body of the loop exit
     // continuation, so the loop exit continuation can be eta-reduced.  The
     // jump is here for simplicity because `buildWhile` does not expose the
     // loop's exit continuation directly and has already emitted all jumps
     // to it anyway.
     whileBuilder.jumpTo(exit);
     irBuilder.add(new ir.LetCont(exit.continuation, whileBuilder.root));
     irBuilder.environment = exit.environment;
-    irBuilder.environment.discard(1);  // Discard the state variable.
+    irBuilder.environment.discard(1); // Discard the state variable.
     irBuilder.state.breakCollectors.removeLast();
     irBuilder.state.continueCollectors.length -= continueTargets.length;
   }
 
   visitTryStatement(ast.TryStatement node) {
     List<CatchClauseInfo> catchClauseInfos = <CatchClauseInfo>[];
     for (ast.CatchBlock catchClause in node.catchBlocks.nodes) {
       LocalVariableElement exceptionVariable;
       if (catchClause.exception != null) {
         exceptionVariable = elements[catchClause.exception];
@@ skipping 16 matching lines @@
 
     assert(!node.catchBlocks.isEmpty || node.finallyBlock != null);
     if (!node.catchBlocks.isEmpty && node.finallyBlock != null) {
       // Try/catch/finally is encoded in terms of try/catch and try/finally:
       //
       // try tryBlock catch (ex, st) catchBlock finally finallyBlock
       // ==>
       // try { try tryBlock catch (ex, st) catchBlock } finally finallyBlock
       irBuilder.buildTryFinally(tryStatements[node.finallyBlock],
           (IrBuilder inner) {
-            inner.buildTryCatch(tryStatements[node.catchBlocks],
-                subbuild(node.tryBlock),
-                catchClauseInfos);
-          },
-          subbuild(node.finallyBlock));
+        inner.buildTryCatch(tryStatements[node.catchBlocks],
+            subbuild(node.tryBlock), catchClauseInfos);
+      }, subbuild(node.finallyBlock));
     } else if (!node.catchBlocks.isEmpty) {
       irBuilder.buildTryCatch(tryStatements[node.catchBlocks],
-          subbuild(node.tryBlock),
-          catchClauseInfos);
+          subbuild(node.tryBlock), catchClauseInfos);
     } else {
       irBuilder.buildTryFinally(tryStatements[node.finallyBlock],
-          subbuild(node.tryBlock),
-          subbuild(node.finallyBlock));
+          subbuild(node.tryBlock), subbuild(node.finallyBlock));
     }
   }
 
   // ## Expressions ##
   ir.Primitive visitConditional(ast.Conditional node) {
     return irBuilder.buildConditional(
         build(node.condition),
         subbuild(node.thenExpression),
         subbuild(node.elseExpression),
         sourceInformationBuilder.buildIf(node));
@@ skipping 27 matching lines @@
   }
 
   ConstantValue getConstantForNode(ast.Node node) {
     return irBuilder.state.constants.getConstantValueForNode(node, elements);
   }
 
   ConstantValue getConstantForVariable(VariableElement element) {
     return irBuilder.state.constants.getConstantValueForVariable(element);
   }
 
-  ir.Primitive buildConstantExpression(ConstantExpression expression,
-                                       SourceInformation sourceInformation) {
+  ir.Primitive buildConstantExpression(
+      ConstantExpression expression, SourceInformation sourceInformation) {
     return irBuilder.buildConstant(
         irBuilder.state.constants.getConstantValue(expression),
         sourceInformation: sourceInformation);
   }
 
   /// Returns the allocation site-specific type for a given allocation.
   ///
   /// Currently, it is an error to call this with anything that is not the
   /// allocation site for a List object (a literal list or a call to one
   /// of the List constructors).
   TypeMask getAllocationSiteType(ast.Node node) {
-    return compiler.typesTask.getGuaranteedTypeOfNode(
-        elements.analyzedElement, node);
+    return compiler.typesTask
+        .getGuaranteedTypeOfNode(elements.analyzedElement, node);
   }
 
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     InterfaceType type = elements.getType(node);
     TypeMask allocationSiteType = getAllocationSiteType(node);
     // TODO(sra): In checked mode, the elements must be checked as though
     // operator[]= is called.
     ir.Primitive list = irBuilder.buildListLiteral(type, values,
-          allocationSiteType: allocationSiteType);
+        allocationSiteType: allocationSiteType);
     if (type.treatAsRaw) return list;
     // Call JSArray<E>.typed(allocation) to install the reified type.
     ConstructorElement constructor = helpers.jsArrayTypedConstructor;
     ir.Primitive tagged = irBuilder.buildConstructorInvocation(
         constructor.effectiveTarget,
         CallStructure.ONE_ARG,
         constructor.computeEffectiveTargetType(type),
         <ir.Primitive>[list],
         sourceInformationBuilder.buildNew(node));
 
     if (allocationSiteType == null) return tagged;
 
-    return irBuilder.addPrimitive(
-        new ir.Refinement(tagged, allocationSiteType));
+    return irBuilder
+        .addPrimitive(new ir.Refinement(tagged, allocationSiteType));
   }
 
   ir.Primitive visitLiteralMap(ast.LiteralMap node) {
     assert(irBuilder.isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
 
     InterfaceType type = elements.getType(node);
 
@@ skipping 36 matching lines @@
           <ir.Primitive>[keysAndValuesList],
           sourceInformationBuilder.buildNew(node));
     }
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
-  ir.Primitive visitParenthesizedExpression(
-      ast.ParenthesizedExpression node) {
+  ir.Primitive visitParenthesizedExpression(ast.ParenthesizedExpression node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   // Stores the result of visiting a CascadeReceiver, so we can return it from
   // its enclosing Cascade.
   ir.Primitive _currentCascadeReceiver;
 
   ir.Primitive visitCascadeReceiver(ast.CascadeReceiver node) {
     assert(irBuilder.isOpen);
@@ skipping 44 matching lines @@
         <ir.Primitive>[name, uri],
         sourceInformation);
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
-  ir.Primitive visitExpressionInvoke(ast.Send node,
-                                     ast.Node expression,
-                                     ast.NodeList argumentsNode,
-                                     CallStructure callStructure, _) {
+  ir.Primitive visitExpressionInvoke(ast.Send node, ast.Node expression,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     ir.Primitive receiver = visit(expression);
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     callStructure = normalizeDynamicArguments(callStructure, arguments);
     return irBuilder.buildCallInvocation(receiver, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   /// Returns `true` if [node] is a super call.
   // TODO(johnniwinther): Remove the need for this.
   bool isSuperCall(ast.Send node) {
     return node != null && node.receiver != null && node.receiver.isSuper();
   }
 
   @override
   ir.Primitive handleConstantGet(
-      ast.Node node,
-      ConstantExpression constant, _) {
-    return buildConstantExpression(constant,
-        sourceInformationBuilder.buildGet(node));
+      ast.Node node, ConstantExpression constant, _) {
+    return buildConstantExpression(
+        constant, sourceInformationBuilder.buildGet(node));
   }
 
   /// If [node] is null, returns this.
   /// Otherwise visits [node] and returns the result.
   ir.Primitive translateReceiver(ast.Expression node) {
     return node != null ? visit(node) : irBuilder.buildThis();
   }
 
   @override
   ir.Primitive handleDynamicGet(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      _) {
+      ast.Send node, ast.Node receiver, Name name, _) {
     return irBuilder.buildDynamicGet(
         translateReceiver(receiver),
         new Selector.getter(name),
         elements.getTypeMask(node),
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyGet(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      _) {
+      ast.Send node, ast.Node receiver, Name name, _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicGet(
             target,
             new Selector.getter(name),
             elements.getTypeMask(node),
             sourceInformationBuilder.buildGet(node))),
         sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
-      ast.Send node,
-      ConstantExpression constant,
-      _) {
-    return buildConstantExpression(constant,
-        sourceInformationBuilder.buildGet(node));
+      ast.Send node, ConstantExpression constant, _) {
+    return buildConstantExpression(
+        constant, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
-      ast.Send node,
-      LocalVariableElement element,
-      _) {
+      ast.Send node, LocalVariableElement element, _) {
     return element.isConst
         ? irBuilder.buildConstant(getConstantForVariable(element),
             sourceInformation: sourceInformationBuilder.buildGet(node))
         : irBuilder.buildLocalGet(element);
   }
 
-  ir.Primitive handleLocalGet(
-      ast.Send node,
-      LocalElement element,
-      _) {
+  ir.Primitive handleLocalGet(ast.Send node, LocalElement element, _) {
     return irBuilder.buildLocalGet(element);
   }
 
   @override
   ir.Primitive handleStaticFunctionGet(
-      ast.Send node,
-      MethodElement function,
-      _) {
+      ast.Send node, MethodElement function, _) {
     return irBuilder.addPrimitive(new ir.GetStatic(function, isFinal: true));
   }
 
   @override
-  ir.Primitive handleStaticGetterGet(
-      ast.Send node,
-      FunctionElement getter,
-      _) {
-   return buildStaticGetterGet(
-       getter, node, sourceInformationBuilder.buildGet(node));
+  ir.Primitive handleStaticGetterGet(ast.Send node, FunctionElement getter, _) {
+    return buildStaticGetterGet(
+        getter, node, sourceInformationBuilder.buildGet(node));
   }
 
   /// Create a getter invocation of the static getter [getter]. This also
   /// handles the special case where [getter] is the `loadLibrary`
   /// pseudo-function on library prefixes of deferred imports.
-  ir.Primitive buildStaticGetterGet(
-      MethodElement getter,
-      ast.Send node,
+  ir.Primitive buildStaticGetterGet(MethodElement getter, ast.Send node,
       SourceInformation sourceInformation) {
     if (getter.isDeferredLoaderGetter) {
       PrefixElement prefix = getter.enclosingElement;
       ir.Primitive loadId = irBuilder.buildStringConstant(
           compiler.deferredLoadTask.getImportDeferName(node, prefix));
       return irBuilder.buildStaticFunctionInvocation(
           compiler.loadLibraryFunction,
           <ir.Primitive>[loadId],
           sourceInformation);
     } else {
       return irBuilder.buildStaticGetterGet(getter, sourceInformation);
     }
   }
 
   @override
-  ir.Primitive visitSuperFieldGet(
-      ast.Send node,
-      FieldElement field,
-      _) {
+  ir.Primitive visitSuperFieldGet(ast.Send node, FieldElement field, _) {
     return irBuilder.buildSuperFieldGet(
         field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive visitSuperGetterGet(
-      ast.Send node,
-      FunctionElement getter,
-      _) {
+  ir.Primitive visitSuperGetterGet(ast.Send node, FunctionElement getter, _) {
     return irBuilder.buildSuperGetterGet(
         getter, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive visitSuperMethodGet(
-      ast.Send node,
-      MethodElement method,
-      _) {
+  ir.Primitive visitSuperMethodGet(ast.Send node, MethodElement method, _) {
     return irBuilder.buildSuperMethodGet(
         method, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperGet(
-      ast.Send node,
-      Element element, _) {
+  ir.Primitive visitUnresolvedSuperGet(ast.Send node, Element element, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), [],
+        elements.getSelector(node),
+        elements.getTypeMask(node),
+        [],
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperSet(
-      ast.Send node,
-      Element element,
-      ast.Node rhs, _) {
+      ast.Send node, Element element, ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), [visit(rhs)],
+        elements.getSelector(node),
+        elements.getTypeMask(node),
+        [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     if (irBuilder.state.thisParameter == null) {
       // TODO(asgerf,johnniwinther): Should be in a visitInvalidThis method.
       // 'this' in static context. Just translate to null.
       assert(compiler.compilationFailed);
       return irBuilder.buildNullConstant();
     }
     return irBuilder.buildThis();
   }
 
   ir.Primitive translateTypeVariableTypeLiteral(
-      TypeVariableElement element,
-      SourceInformation sourceInformation) {
+      TypeVariableElement element, SourceInformation sourceInformation) {
     return irBuilder.buildReifyTypeVariable(element.type, sourceInformation);
   }
 
   @override
-  ir.Primitive visitTypeVariableTypeLiteralGet(ast.Send node,
-                                               TypeVariableElement element, _) {
-    return translateTypeVariableTypeLiteral(element,
-        sourceInformationBuilder.buildGet(node));
+  ir.Primitive visitTypeVariableTypeLiteralGet(
+      ast.Send node, TypeVariableElement element, _) {
+    return translateTypeVariableTypeLiteral(
+        element, sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive translateLogicalOperator(ast.Expression left,
-                                        ast.Expression right,
-                                        SourceInformation sourceInformation,
-                                        {bool isLazyOr}) {
+      ast.Expression right, SourceInformation sourceInformation,
+      {bool isLazyOr}) {
     ir.Primitive leftValue = visit(left);
 
     ir.Primitive buildRightValue(IrBuilder rightBuilder) {
       return withBuilder(rightBuilder, () => visit(right));
     }
 
     return irBuilder.buildLogicalOperator(
-        leftValue, buildRightValue, sourceInformation, isLazyOr: isLazyOr);
+        leftValue, buildRightValue, sourceInformation,
+        isLazyOr: isLazyOr);
   }
 
   @override
-  ir.Primitive visitIfNull(
-      ast.Send node, ast.Node left, ast.Node right, _) {
-    return irBuilder.buildIfNull(build(left), subbuild(right),
-        sourceInformationBuilder.buildIf(node));
+  ir.Primitive visitIfNull(ast.Send node, ast.Node left, ast.Node right, _) {
+    return irBuilder.buildIfNull(
+        build(left), subbuild(right), sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitLogicalAnd(
       ast.Send node, ast.Node left, ast.Node right, _) {
-    return translateLogicalOperator(left, right,
-        sourceInformationBuilder.buildIf(node), isLazyOr: false);
+    return translateLogicalOperator(
+        left, right, sourceInformationBuilder.buildIf(node),
+        isLazyOr: false);
   }
 
   @override
-  ir.Primitive visitLogicalOr(
-      ast.Send node, ast.Node left, ast.Node right, _) {
-    return translateLogicalOperator(left, right,
-        sourceInformationBuilder.buildIf(node), isLazyOr: true);
+  ir.Primitive visitLogicalOr(ast.Send node, ast.Node left, ast.Node right, _) {
+    return translateLogicalOperator(
+        left, right, sourceInformationBuilder.buildIf(node),
+        isLazyOr: true);
   }
 
   @override
-  ir.Primitive visitAs(
-      ast.Send node,
-      ast.Node expression,
-      DartType type,
-      _) {
+  ir.Primitive visitAs(ast.Send node, ast.Node expression, DartType type, _) {
     ir.Primitive receiver = visit(expression);
     return irBuilder.buildTypeOperator(
-        receiver,
-        type,
-        sourceInformationBuilder.buildAs(node),
+        receiver, type, sourceInformationBuilder.buildAs(node),
         isTypeTest: false);
   }
 
   @override
-  ir.Primitive visitIs(
-      ast.Send node,
-      ast.Node expression,
-      DartType type,
-      _) {
+  ir.Primitive visitIs(ast.Send node, ast.Node expression, DartType type, _) {
     ir.Primitive value = visit(expression);
     return irBuilder.buildTypeOperator(
-        value,
-        type,
-        sourceInformationBuilder.buildIs(node),
+        value, type, sourceInformationBuilder.buildIs(node),
         isTypeTest: true);
   }
 
   @override
-  ir.Primitive visitIsNot(ast.Send node,
-                          ast.Node expression, DartType type, _) {
+  ir.Primitive visitIsNot(
+      ast.Send node, ast.Node expression, DartType type, _) {
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
-        value,
-        type,
-        sourceInformationBuilder.buildIs(node),
+        value, type, sourceInformationBuilder.buildIs(node),
         isTypeTest: true);
-    return irBuilder.buildNegation(check,
-        sourceInformationBuilder.buildIf(node));
+    return irBuilder.buildNegation(
+        check, sourceInformationBuilder.buildIf(node));
   }
 
-  ir.Primitive translateBinary(ast.Send node,
-                               ast.Node left,
-                               op.BinaryOperator operator,
-                               ast.Node right) {
+  ir.Primitive translateBinary(ast.Send node, ast.Node left,
+      op.BinaryOperator operator, ast.Node right) {
     ir.Primitive receiver = visit(left);
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     CallStructure callStructure =
         normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         receiver,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
-  ir.Primitive visitBinary(ast.Send node,
-                           ast.Node left,
-                           op.BinaryOperator operator,
-                           ast.Node right, _) {
+  ir.Primitive visitBinary(ast.Send node, ast.Node left,
+      op.BinaryOperator operator, ast.Node right, _) {
     return translateBinary(node, left, operator, right);
   }
 
   @override
-  ir.Primitive visitIndex(ast.Send node,
-                          ast.Node receiver,
-                          ast.Node index, _) {
+  ir.Primitive visitIndex(ast.Send node, ast.Node receiver, ast.Node index, _) {
     ir.Primitive target = visit(receiver);
     Selector selector = new Selector.index();
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     CallStructure callStructure =
         normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         target,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
         sourceInformationBuilder.buildCall(receiver, node.selector));
   }
 
-  ir.Primitive translateSuperBinary(FunctionElement function,
-                                    op.BinaryOperator operator,
-                                    ast.Node argument,
-                                    SourceInformation sourceInformation) {
+  ir.Primitive translateSuperBinary(
+      FunctionElement function,
+      op.BinaryOperator operator,
+      ast.Node argument,
+      SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
-    return irBuilder.buildSuperMethodInvocation(function,
-        CallStructure.ONE_ARG, arguments, sourceInformation);
+    return irBuilder.buildSuperMethodInvocation(
+        function, CallStructure.ONE_ARG, arguments, sourceInformation);
   }
 
   @override
-  ir.Primitive visitSuperBinary(
-      ast.Send node,
-      FunctionElement function,
-      op.BinaryOperator operator,
-      ast.Node argument,
-      _) {
+  ir.Primitive visitSuperBinary(ast.Send node, FunctionElement function,
+      op.BinaryOperator operator, ast.Node argument, _) {
     return translateSuperBinary(function, operator, argument,
         sourceInformationBuilder.buildBinary(node));
   }
 
   @override
   ir.Primitive visitSuperIndex(
-      ast.Send node,
-      FunctionElement function,
-      ast.Node index,
-      _) {
-    return irBuilder.buildSuperIndex(function, visit(index),
-        sourceInformationBuilder.buildIndex(node));
+      ast.Send node, FunctionElement function, ast.Node index, _) {
+    return irBuilder.buildSuperIndex(
+        function, visit(index), sourceInformationBuilder.buildIndex(node));
   }
 
   @override
-  ir.Primitive visitEquals(
-      ast.Send node,
-      ast.Node left,
-      ast.Node right,
-      _) {
+  ir.Primitive visitEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     return translateBinary(node, left, op.BinaryOperator.EQ, right);
   }
 
   @override
   ir.Primitive visitSuperEquals(
-      ast.Send node,
-      FunctionElement function,
-      ast.Node argument,
-      _) {
+      ast.Send node, FunctionElement function, ast.Node argument, _) {
     return translateSuperBinary(function, op.BinaryOperator.EQ, argument,
         sourceInformationBuilder.buildBinary(node));
   }
 
   @override
-  ir.Primitive visitNot(
-      ast.Send node,
-      ast.Node expression,
-      _) {
-    return irBuilder.buildNegation(visit(expression),
-        sourceInformationBuilder.buildIf(node));
+  ir.Primitive visitNot(ast.Send node, ast.Node expression, _) {
+    return irBuilder.buildNegation(
+        visit(expression), sourceInformationBuilder.buildIf(node));
   }
 
   @override
-  ir.Primitive visitNotEquals(
-      ast.Send node,
-      ast.Node left,
-      ast.Node right,
-      _) {
+  ir.Primitive visitNotEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     return irBuilder.buildNegation(
         translateBinary(node, left, op.BinaryOperator.NOT_EQ, right),
         sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive visitSuperNotEquals(
-      ast.Send node,
-      FunctionElement function,
-      ast.Node argument,
-      _) {
+      ast.Send node, FunctionElement function, ast.Node argument, _) {
     return irBuilder.buildNegation(
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument,
             sourceInformationBuilder.buildBinary(node)),
         sourceInformationBuilder.buildIf(node));
   }
 
   @override
-  ir.Primitive visitUnary(ast.Send node,
-                          op.UnaryOperator operator, ast.Node expression, _) {
+  ir.Primitive visitUnary(
+      ast.Send node, op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = operator.selector;
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(
-        receiver, selector, elements.getTypeMask(node), const [],
+        receiver,
+        selector,
+        elements.getTypeMask(node),
+        const [],
         sourceInformationBuilder.buildCall(expression, node));
   }
 
   @override
   ir.Primitive visitSuperUnary(
-      ast.Send node,
-      op.UnaryOperator operator,
-      FunctionElement function,
-      _) {
-    return irBuilder.buildSuperMethodInvocation(
-        function, CallStructure.NO_ARGS, const [],
-        sourceInformationBuilder.buildCall(node, node));
+      ast.Send node, op.UnaryOperator operator, FunctionElement function, _) {
+    return irBuilder.buildSuperMethodInvocation(function, CallStructure.NO_ARGS,
+        const [], sourceInformationBuilder.buildCall(node, node));
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   CallStructure translateDynamicArguments(ast.NodeList nodeList,
-                                          CallStructure callStructure,
-                                          List<ir.Primitive> arguments) {
+      CallStructure callStructure, List<ir.Primitive> arguments) {
     assert(arguments.isEmpty);
     for (ast.Node node in nodeList) arguments.add(visit(node));
     return normalizeDynamicArguments(callStructure, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
-  CallStructure translateStaticArguments(ast.NodeList nodeList,
-                                         Element element,
-                                         CallStructure callStructure,
-                                         List<ir.Primitive> arguments) {
+  CallStructure translateStaticArguments(ast.NodeList nodeList, Element element,
+      CallStructure callStructure, List<ir.Primitive> arguments) {
     assert(arguments.isEmpty);
     for (ast.Node node in nodeList) arguments.add(visit(node));
     return normalizeStaticArguments(callStructure, element, arguments);
   }
 
-  ir.Primitive translateCallInvoke(ir.Primitive target,
-                                   ast.NodeList argumentsNode,
-                                   CallStructure callStructure,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive translateCallInvoke(
+      ir.Primitive target,
+      ast.NodeList argumentsNode,
+      CallStructure callStructure,
+      SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target, callStructure, arguments, sourceInformation);
   }
 
   @override
-  ir.Primitive handleConstantInvoke(
-      ast.Send node,
-      ConstantExpression constant,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    ir.Primitive target = buildConstantExpression(constant,
-        sourceInformationBuilder.buildGet(node));
+  ir.Primitive handleConstantInvoke(ast.Send node, ConstantExpression constant,
+      ast.NodeList arguments, CallStructure callStructure, _) {
+    ir.Primitive target = buildConstantExpression(
+        constant, sourceInformationBuilder.buildGet(node));
     return translateCallInvoke(target, arguments, callStructure,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-
     // TODO(sigmund): move these checks down after visiting arguments
     // (see issue #25355)
     ast.Send send = node.send;
     // If an allocation refers to a type using a deferred import prefix (e.g.
     // `new lib.A()`), we must ensure that the deferred import has already been
     // loaded.
-    var prefix = compiler.deferredLoadTask.deferredPrefixElement(
-        send, elements);
+    var prefix =
+        compiler.deferredLoadTask.deferredPrefixElement(send, elements);
     if (prefix != null) buildCheckDeferredIsLoaded(prefix, send);
 
     // We also emit deferred import checks when using redirecting factories that
     // refer to deferred prefixes.
     if (constructor.isRedirectingFactory && !constructor.isCyclicRedirection) {
       ConstructorElement current = constructor;
       while (current.isRedirectingFactory) {
         var prefix = current.redirectionDeferredPrefix;
         if (prefix != null) buildCheckDeferredIsLoaded(prefix, send);
         current = current.immediateRedirectionTarget;
@@ skipping 34 matching lines @@
     return irBuilder.buildConstructorInvocation(
         target,
         callStructure,
         constructorImplementation.computeEffectiveTargetType(type),
         arguments,
         sourceInformationBuilder.buildNew(node),
         allocationSiteType: allocationSiteType);
   }
 
   @override
-  ir.Primitive handleDynamicInvoke(
-      ast.Send node,
-      ast.Node receiver,
-      ast.NodeList argumentsNode,
-      Selector selector,
-      _) {
+  ir.Primitive handleDynamicInvoke(ast.Send node, ast.Node receiver,
+      ast.NodeList argumentsNode, Selector selector, _) {
     ir.Primitive target = translateReceiver(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(
         target,
         new Selector(selector.kind, selector.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
-  ir.Primitive visitIfNotNullDynamicPropertyInvoke(
-      ast.Send node,
-      ast.Node receiver,
-      ast.NodeList argumentsNode,
-      Selector selector,
-      _) {
+  ir.Primitive visitIfNotNullDynamicPropertyInvoke(ast.Send node,
+      ast.Node receiver, ast.NodeList argumentsNode, Selector selector, _) {
     ir.Primitive target = visit(receiver);
-    return irBuilder.buildIfNotNullSend(
-        target,
-        nested(() {
-          List<ir.Primitive> arguments = <ir.Primitive>[];
-          CallStructure callStructure = translateDynamicArguments(
-              argumentsNode, selector.callStructure, arguments);
-          return irBuilder.buildDynamicInvocation(
-              target,
-              new Selector(selector.kind, selector.memberName, callStructure),
-              elements.getTypeMask(node),
-              arguments,
-              sourceInformationBuilder.buildCall(node, node.selector));
-        }),
-        sourceInformationBuilder.buildIf(node));
+    return irBuilder.buildIfNotNullSend(target, nested(() {
+      List<ir.Primitive> arguments = <ir.Primitive>[];
+      CallStructure callStructure = translateDynamicArguments(
+          argumentsNode, selector.callStructure, arguments);
+      return irBuilder.buildDynamicInvocation(
+          target,
+          new Selector(selector.kind, selector.memberName, callStructure),
+          elements.getTypeMask(node),
+          arguments,
+          sourceInformationBuilder.buildCall(node, node.selector));
+    }), sourceInformationBuilder.buildIf(node));
   }
 
-  ir.Primitive handleLocalInvoke(
-      ast.Send node,
-      LocalElement element,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive handleLocalInvoke(ast.Send node, LocalElement element,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     ir.Primitive function = irBuilder.buildLocalGet(element);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(function, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive handleStaticFieldInvoke(
-      ast.Send node,
-      FieldElement field,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive handleStaticFieldInvoke(ast.Send node, FieldElement field,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
     ir.Primitive target = buildStaticFieldGet(field, src);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildCallInvocation(
-        target,
-        callStructure,
-        arguments,
+    return irBuilder.buildCallInvocation(target, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
-  ir.Primitive handleStaticFunctionInvoke(ast.Send node,
-      MethodElement function,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive handleStaticFunctionInvoke(ast.Send node, MethodElement function,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     if (compiler.backend.isForeign(function)) {
-      return handleForeignCode(
-          node,
-          function,
-          argumentsNode,
-          callStructure);
+      return handleForeignCode(node, function, argumentsNode, callStructure);
     } else {
       List<ir.Primitive> arguments = <ir.Primitive>[];
-      callStructure = translateStaticArguments(argumentsNode, function,
-          callStructure, arguments);
+      callStructure = translateStaticArguments(
+          argumentsNode, function, callStructure, arguments);
       Selector selector = new Selector.call(function.memberName, callStructure);
       return irBuilder.buildInvokeStatic(function, selector, arguments,
           sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
-      CallStructure callStructure, _) {
+      CallStructure callStructure,
+      _) {
     return irBuilder.buildStaticNoSuchMethod(
         elements.getSelector(node),
         arguments.nodes.mapToList(visit),
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
-  ir.Primitive handleStaticGetterInvoke(
-      ast.Send node,
-      FunctionElement getter,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive handleStaticGetterInvoke(ast.Send node, FunctionElement getter,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     ir.Primitive target = buildStaticGetterGet(
         getter, node, sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildCallInvocation(
-        target,
-        callStructure,
-        arguments,
+    return irBuilder.buildCallInvocation(target, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
-  ir.Primitive visitSuperFieldInvoke(
-      ast.Send node,
-      FieldElement field,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive visitSuperFieldInvoke(ast.Send node, FieldElement field,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     ir.Primitive target = irBuilder.buildSuperFieldGet(
         field, sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildCallInvocation(
-        target,
-        callStructure,
-        arguments,
+    return irBuilder.buildCallInvocation(target, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
-  ir.Primitive visitSuperGetterInvoke(
-      ast.Send node,
-      FunctionElement getter,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
-    ir.Primitive target = irBuilder.buildSuperGetterGet(getter,
-        sourceInformationBuilder.buildGet(node));
+  ir.Primitive visitSuperGetterInvoke(ast.Send node, FunctionElement getter,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
+    ir.Primitive target = irBuilder.buildSuperGetterGet(
+        getter, sourceInformationBuilder.buildGet(node));
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildCallInvocation(
-        target,
-        callStructure,
-        arguments,
+    return irBuilder.buildCallInvocation(target, callStructure, arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
-  ir.Primitive visitSuperMethodInvoke(
-      ast.Send node,
-      MethodElement method,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
+  ir.Primitive visitSuperMethodInvoke(ast.Send node, MethodElement method,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
-    callStructure = translateStaticArguments(argumentsNode, method,
-        callStructure, arguments);
-    return irBuilder.buildSuperMethodInvocation(
-        method,
-        callStructure,
-        arguments,
-        sourceInformationBuilder.buildCall(node, node.selector));
+    callStructure = translateStaticArguments(
+        argumentsNode, method, callStructure, arguments);
+    return irBuilder.buildSuperMethodInvocation(method, callStructure,
+        arguments, sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
-      CallStructure callStructure, _) {
+      CallStructure callStructure,
+      _) {
     List<ir.Primitive> normalizedArguments = <ir.Primitive>[];
-    CallStructure normalizedCallStructure =
-      translateDynamicArguments(arguments, callStructure, normalizedArguments);
+    CallStructure normalizedCallStructure = translateDynamicArguments(
+        arguments, callStructure, normalizedArguments);
     return buildSuperNoSuchMethod(
         new Selector.call(method.memberName, normalizedCallStructure),
         elements.getTypeMask(node),
         normalizedArguments,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperInvoke(
-      ast.Send node,
-      Element element,
-      ast.NodeList argumentsNode,
-      Selector selector, _) {
+  ir.Primitive visitUnresolvedSuperInvoke(ast.Send node, Element element,
+      ast.NodeList argumentsNode, Selector selector, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     // TODO(johnniwinther): Supply a member name to the visit function instead
     // of looking it up in elements.
     return buildSuperNoSuchMethod(
         new Selector.call(elements.getSelector(node).memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitThisInvoke(
-      ast.Send node,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
-    return translateCallInvoke(
-        irBuilder.buildThis(),
-        arguments,
-        callStructure,
+      ast.Send node, ast.NodeList arguments, CallStructure callStructure, _) {
+    return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralInvoke(
       ast.Send node,
       TypeVariableElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(
         translateTypeVariableTypeLiteral(
             element, sourceInformationBuilder.buildGet(node)),
         arguments,
         callStructure,
         sourceInformationBuilder.buildCall(node, arguments));
   }
 
   @override
   ir.Primitive 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, _) {
     return irBuilder.buildDynamicIndexSet(
         visit(receiver),
         elements.getTypeMask(node),
         visit(index),
         visit(rhs),
         sourceInformationBuilder.buildIndexSet(node));
   }
 
   @override
-  ir.Primitive visitSuperIndexSet(
-      ast.SendSet node,
-      FunctionElement function,
-      ast.Node index,
-      ast.Node rhs,
-      _) {
-    return irBuilder.buildSuperIndexSet(
-        function,
-        visit(index),
-        visit(rhs),
+  ir.Primitive visitSuperIndexSet(ast.SendSet node, FunctionElement function,
+      ast.Node index, ast.Node rhs, _) {
+    return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs),
         sourceInformationBuilder.buildIndexSet(node));
   }
 
-  ir.Primitive translateIfNull(
-       ast.SendSet node,
-       ir.Primitive getValue(),
-       ast.Node rhs,
-       void setValue(ir.Primitive value)) {
+  ir.Primitive translateIfNull(ast.SendSet node, ir.Primitive getValue(),
+      ast.Node rhs, void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     // Unlike other compound operators if-null conditionally will not do the
     // assignment operation.
     return irBuilder.buildIfNull(value, nested(() {
       ir.Primitive newValue = build(rhs);
       setValue(newValue);
       return newValue;
-    }),
-    sourceInformationBuilder.buildIf(node));
+    }), sourceInformationBuilder.buildIf(node));
   }
 
-  ir.Primitive translateCompounds(
-      ast.SendSet node,
-      ir.Primitive getValue(),
-      CompoundRhs rhs,
-      void setValue(ir.Primitive value)) {
+  ir.Primitive translateCompounds(ast.SendSet node, ir.Primitive getValue(),
+      CompoundRhs rhs, void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
     assert(operator.kind != op.BinaryOperatorKind.IF_NULL);
 
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
     CallStructure callStructure =
         normalizeDynamicArguments(operatorSelector.callStructure, arguments);
     TypeMask operatorTypeMask =
         elements.getOperatorTypeMaskInComplexSendSet(node);
     SourceInformation operatorSourceInformation =
         sourceInformationBuilder.buildCall(node, node.assignmentOperator);
     ir.Primitive result = irBuilder.buildDynamicInvocation(
         value,
-        new Selector(operatorSelector.kind, operatorSelector.memberName,
-            callStructure),
+        new Selector(
+            operatorSelector.kind, operatorSelector.memberName, callStructure),
         operatorTypeMask,
         arguments,
         operatorSourceInformation);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
-  ir.Primitive translateSetIfNull(
-      ast.SendSet node,
-      ir.Primitive getValue(),
-      ast.Node rhs,
-      void setValue(ir.Primitive value)) {
+  ir.Primitive translateSetIfNull(ast.SendSet node, ir.Primitive getValue(),
+      ast.Node rhs, void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     // Unlike other compound operators if-null conditionally will not do the
     // assignment operation.
     return irBuilder.buildIfNull(value, nested(() {
       ir.Primitive newValue = build(rhs);
       setValue(newValue);
       return newValue;
-    }),
-    sourceInformationBuilder.buildIf(node));
+    }), sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive handleSuperIndexSetIfNull(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       ast.Node rhs,
       arg,
       {bool isGetterValid,
-       bool isSetterValid}) {
-    return translateSetIfNull(node, () {
-      if (isGetterValid) {
-        return irBuilder.buildSuperMethodGet(
-            indexFunction, sourceInformationBuilder.buildIndex(node));
-      } else {
-        return buildSuperNoSuchGetter(
-            indexFunction,
-            elements.getGetterTypeMaskInComplexSendSet(node),
-            sourceInformationBuilder.buildIndex(node));
-      }
-    }, rhs, (ir.Primitive result) {
-      if (isSetterValid) {
-        return irBuilder.buildSuperMethodGet(
-            indexSetFunction, sourceInformationBuilder.buildIndexSet(node));
-      } else {
-        return buildSuperNoSuchSetter(
-            indexSetFunction, elements.getTypeMask(node), result,
-            sourceInformationBuilder.buildIndexSet(node));
-      }
-    });
+      bool isSetterValid}) {
+    return translateSetIfNull(
+        node,
+        () {
+          if (isGetterValid) {
+            return irBuilder.buildSuperMethodGet(
+                indexFunction, sourceInformationBuilder.buildIndex(node));
+          } else {
+            return buildSuperNoSuchGetter(
+                indexFunction,
+                elements.getGetterTypeMaskInComplexSendSet(node),
+                sourceInformationBuilder.buildIndex(node));
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          if (isSetterValid) {
+            return irBuilder.buildSuperMethodGet(
+                indexSetFunction, sourceInformationBuilder.buildIndexSet(node));
+          } else {
+            return buildSuperNoSuchSetter(
+                indexSetFunction,
+                elements.getTypeMask(node),
+                result,
+                sourceInformationBuilder.buildIndexSet(node));
+          }
+        });
   }
 
   @override
   ir.Primitive visitIndexSetIfNull(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      ast.Node rhs,
-      arg) {
+      ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
-    return translateSetIfNull(node, () {
-      Selector selector = new Selector.index();
-      List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-      CallStructure callStructure =
-          normalizeDynamicArguments(selector.callStructure, arguments);
-      return irBuilder.buildDynamicInvocation(
-          target,
-          new Selector(selector.kind, selector.memberName, callStructure),
-          elements.getGetterTypeMaskInComplexSendSet(node),
-          arguments,
-          sourceInformationBuilder.buildCall(receiver, node));
-    }, rhs, (ir.Primitive result) {
-      irBuilder.buildDynamicIndexSet(
-          target,
-          elements.getTypeMask(node),
-          indexValue,
-          result,
-          sourceInformationBuilder.buildIndexSet(node));
-    });
+    return translateSetIfNull(
+        node,
+        () {
+          Selector selector = new Selector.index();
+          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
+          CallStructure callStructure =
+              normalizeDynamicArguments(selector.callStructure, arguments);
+          return irBuilder.buildDynamicInvocation(
+              target,
+              new Selector(selector.kind, selector.memberName, callStructure),
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              arguments,
+              sourceInformationBuilder.buildCall(receiver, node));
+        },
+        rhs,
+        (ir.Primitive result) {
+          irBuilder.buildDynamicIndexSet(target, elements.getTypeMask(node),
+              indexValue, result, sourceInformationBuilder.buildIndexSet(node));
+        });
   }
 
   @override
   ir.Primitive handleDynamicSet(
-      ast.SendSet node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         new Selector.setter(name),
         elements.getTypeMask(node),
         visit(rhs),
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertySet(
-      ast.SendSet node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ast.Node receiver, Name name, ast.Node rhs, _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicSet(
             target,
             new Selector.setter(name),
             elements.getTypeMask(node),
             visit(rhs),
             sourceInformationBuilder.buildAssignment(node))),
         sourceInformationBuilder.buildIf(node));
   }
 
   @override
   ir.Primitive handleLocalSet(
-      ast.SendSet node,
-      LocalElement element,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, LocalElement element, ast.Node rhs, _) {
     ir.Primitive value = visit(rhs);
     value = checkTypeVsElement(value, element);
-    return irBuilder.buildLocalVariableSet(element, value,
-        sourceInformationBuilder.buildAssignment(node));
+    return irBuilder.buildLocalVariableSet(
+        element, value, sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     ir.Primitive value = visit(rhs);
-    irBuilder.addPrimitive(new ir.SetStatic(field, value,
-        sourceInformationBuilder.buildAssignment(node)));
+    irBuilder.addPrimitive(new ir.SetStatic(
+        field, value, sourceInformationBuilder.buildAssignment(node)));
     return value;
   }
 
   @override
   ir.Primitive visitSuperFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs,
-      _) {
-    return irBuilder.buildSuperFieldSet(field, visit(rhs),
-        sourceInformationBuilder.buildAssignment(node));
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
+    return irBuilder.buildSuperFieldSet(
+        field, visit(rhs), sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitSuperSetterSet(
-      ast.SendSet node,
-      FunctionElement setter,
-      ast.Node rhs,
-      _) {
-    return irBuilder.buildSuperSetterSet(setter, visit(rhs),
-        sourceInformationBuilder.buildAssignment(node));
+      ast.SendSet node, FunctionElement setter, ast.Node rhs, _) {
+    return irBuilder.buildSuperSetterSet(
+        setter, visit(rhs), sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndexSet(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      ast.Node rhs,
-      arg) {
+      ast.Send node, Element element, ast.Node index, ast.Node rhs, arg) {
     return giveup(node, 'visitUnresolvedSuperIndexSet');
   }
 
   @override
   ir.Primitive handleStaticSetterSet(
-      ast.SendSet node,
-      FunctionElement setter,
-      ast.Node rhs,
-      _) {
-    return irBuilder.buildStaticSetterSet(setter, visit(rhs),
-        sourceInformationBuilder.buildAssignment(node));
+      ast.SendSet node, FunctionElement setter, ast.Node rhs, _) {
+    return irBuilder.buildStaticSetterSet(
+        setter, visit(rhs), sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
-      ast.SendSet node,
-      ConstantExpression constant,
-      CompoundRhs rhs,
-      arg) {
+      ast.SendSet node, ConstantExpression constant, CompoundRhs rhs, arg) {
     SourceInformation src = sourceInformationBuilder.buildGet(node);
-    return translateCompounds(node, () {
-      return buildConstantExpression(constant, src);
-    }, rhs, (ir.Primitive value) {
-      // The binary operator will throw before this.
-    });
+    return translateCompounds(
+        node,
+        () {
+          return buildConstantExpression(constant, src);
+        },
+        rhs,
+        (ir.Primitive value) {
+          // The binary operator will throw before this.
+        });
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantSetIfNulls(
-      ast.SendSet node,
-      ConstantExpression constant,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, ConstantExpression constant, ast.Node rhs, _) {
     // The type literal is never `null`.
-    return buildConstantExpression(constant,
-        sourceInformationBuilder.buildGet(node));
+    return buildConstantExpression(
+        constant, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
-      ast.SendSet node,
-      ast.Node receiver,
-      Name name,
-      CompoundRhs rhs,
-      arg) {
+      ast.SendSet node, ast.Node receiver, Name name, CompoundRhs rhs, arg) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
-      return translateCompounds(node, () {
-        return irBuilder.buildDynamicGet(
-            target,
-            new Selector.getter(name),
-            elements.getGetterTypeMaskInComplexSendSet(node),
-            sourceInformationBuilder.buildGet(node));
-      }, rhs, (ir.Primitive result) {
-        irBuilder.buildDynamicSet(
-            target,
-            new Selector.setter(name),
-            elements.getTypeMask(node),
-            result,
-            sourceInformationBuilder.buildAssignment(node));
-      });
+      return translateCompounds(
+          node,
+          () {
+            return irBuilder.buildDynamicGet(
+                target,
+                new Selector.getter(name),
+                elements.getGetterTypeMaskInComplexSendSet(node),
+                sourceInformationBuilder.buildGet(node));
+          },
+          rhs,
+          (ir.Primitive result) {
+            irBuilder.buildDynamicSet(
+                target,
+                new Selector.setter(name),
+                elements.getTypeMask(node),
+                result,
+                sourceInformationBuilder.buildAssignment(node));
+          });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(
             target, nested(helper), sourceInformationBuilder.buildIf(node))
         : helper();
   }
 
   @override
   ir.Primitive handleDynamicSetIfNulls(
-      ast.Send node,
-      ast.Node receiver,
-      Name name,
-      ast.Node rhs,
-      _) {
+      ast.Send node, ast.Node receiver, Name name, ast.Node rhs, _) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
-      return translateSetIfNull(node, () {
-        return irBuilder.buildDynamicGet(
-            target,
-            new Selector.getter(name),
-            elements.getGetterTypeMaskInComplexSendSet(node),
-            sourceInformationBuilder.buildGet(node));
-      }, rhs, (ir.Primitive result) {
-        irBuilder.buildDynamicSet(
-            target,
-            new Selector.setter(name),
-            elements.getTypeMask(node),
-            result,
-            sourceInformationBuilder.buildAssignment(node));
-      });
+      return translateSetIfNull(
+          node,
+          () {
+            return irBuilder.buildDynamicGet(
+                target,
+                new Selector.getter(name),
+                elements.getGetterTypeMaskInComplexSendSet(node),
+                sourceInformationBuilder.buildGet(node));
+          },
+          rhs,
+          (ir.Primitive result) {
+            irBuilder.buildDynamicSet(
+                target,
+                new Selector.setter(name),
+                elements.getTypeMask(node),
+                result,
+                sourceInformationBuilder.buildAssignment(node));
+          });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(
             target, nested(helper), sourceInformationBuilder.buildIf(node))
         : helper();
   }
 
-  ir.Primitive buildLocalNoSuchSetter(
-      LocalElement local,
-      ir.Primitive value,
+  ir.Primitive buildLocalNoSuchSetter(LocalElement local, ir.Primitive value,
       SourceInformation sourceInformation) {
     Selector selector = new Selector.setter(
         new Name(local.name, local.library, isSetter: true));
     return irBuilder.buildStaticNoSuchMethod(
         selector, [value], sourceInformation);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
-      ast.SendSet node,
-      LocalElement local,
-      CompoundRhs rhs,
-      arg,
+      ast.SendSet node, LocalElement local, CompoundRhs rhs, arg,
       {bool isSetterValid}) {
-    return translateCompounds(node, () {
-      return irBuilder.buildLocalGet(local);
-    }, rhs, (ir.Primitive result) {
-      if (isSetterValid) {
-        irBuilder.buildLocalVariableSet(
-            local, result,
-            sourceInformationBuilder.buildAssignment(node));
-      } else {
-        Selector selector = new Selector.setter(
-            new Name(local.name, local.library, isSetter: true));
-        irBuilder.buildStaticNoSuchMethod(
-            selector, <ir.Primitive>[result],
-            sourceInformationBuilder.buildAssignment(node));
-      }
-    });
+    return translateCompounds(
+        node,
+        () {
+          return irBuilder.buildLocalGet(local);
+        },
+        rhs,
+        (ir.Primitive result) {
+          if (isSetterValid) {
+            irBuilder.buildLocalVariableSet(
+                local, result, sourceInformationBuilder.buildAssignment(node));
+          } else {
+            Selector selector = new Selector.setter(
+                new Name(local.name, local.library, isSetter: true));
+            irBuilder.buildStaticNoSuchMethod(selector, <ir.Primitive>[result],
+                sourceInformationBuilder.buildAssignment(node));
+          }
+        });
   }
 
   @override
   ir.Primitive handleLocalSetIfNulls(
-      ast.SendSet node,
-      LocalElement local,
-      ast.Node rhs,
-      _,
+      ast.SendSet node, LocalElement local, ast.Node rhs, _,
       {bool isSetterValid}) {
-    return translateSetIfNull(node, () {
-      return irBuilder.buildLocalGet(
-          local, sourceInformation: sourceInformationBuilder.buildGet(node));
-    }, rhs, (ir.Primitive result) {
-      SourceInformation sourceInformation =
-          sourceInformationBuilder.buildAssignment(node);
-      if (isSetterValid) {
-        irBuilder.buildLocalVariableSet(
-            local, result, sourceInformation);
-      } else {
-        Selector selector = new Selector.setter(
-            new Name(local.name, local.library, isSetter: true));
-        irBuilder.buildStaticNoSuchMethod(
-            selector, <ir.Primitive>[result], sourceInformation);
-      }
-    });
+    return translateSetIfNull(
+        node,
+        () {
+          return irBuilder.buildLocalGet(local,
+              sourceInformation: sourceInformationBuilder.buildGet(node));
+        },
+        rhs,
+        (ir.Primitive result) {
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildAssignment(node);
+          if (isSetterValid) {
+            irBuilder.buildLocalVariableSet(local, result, sourceInformation);
+          } else {
+            Selector selector = new Selector.setter(
+                new Name(local.name, local.library, isSetter: true));
+            irBuilder.buildStaticNoSuchMethod(
+                selector, <ir.Primitive>[result], sourceInformation);
+          }
+        });
   }
 
   @override
   ir.Primitive handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(node, () {
-      SourceInformation sourceInformation =
-          sourceInformationBuilder.buildGet(node);
-      switch (getterKind) {
-        case CompoundGetter.FIELD:
-          return buildStaticFieldGet(getter, sourceInformation);
-        case CompoundGetter.GETTER:
-          return buildStaticGetterGet(getter, node, sourceInformation);
-        case CompoundGetter.METHOD:
-          return irBuilder.addPrimitive(new ir.GetStatic(getter,
-              sourceInformation: sourceInformation, isFinal: true));
-        case CompoundGetter.UNRESOLVED:
-          return irBuilder.buildStaticNoSuchMethod(
-              new Selector.getter(new Name(getter.name, getter.library)),
-              <ir.Primitive>[],
-              sourceInformation);
-      }
-    }, rhs, (ir.Primitive result) {
-      SourceInformation sourceInformation =
-          sourceInformationBuilder.buildAssignment(node);
-      switch (setterKind) {
-        case CompoundSetter.FIELD:
-          irBuilder.addPrimitive(
-              new ir.SetStatic(setter, result, sourceInformation));
-          return;
-        case CompoundSetter.SETTER:
-          irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
-          return;
-        case CompoundSetter.INVALID:
-          irBuilder.buildStaticNoSuchMethod(
-              new Selector.setter(new Name(setter.name, setter.library)),
-              <ir.Primitive>[result],
-              sourceInformation);
-          return;
-      }
-    });
+    return translateCompounds(
+        node,
+        () {
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildGet(node);
+          switch (getterKind) {
+            case CompoundGetter.FIELD:
+              return buildStaticFieldGet(getter, sourceInformation);
+            case CompoundGetter.GETTER:
+              return buildStaticGetterGet(getter, node, sourceInformation);
+            case CompoundGetter.METHOD:
+              return irBuilder.addPrimitive(new ir.GetStatic(getter,
+                  sourceInformation: sourceInformation, isFinal: true));
+            case CompoundGetter.UNRESOLVED:
+              return irBuilder.buildStaticNoSuchMethod(
+                  new Selector.getter(new Name(getter.name, getter.library)),
+                  <ir.Primitive>[],
+                  sourceInformation);
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildAssignment(node);
+          switch (setterKind) {
+            case CompoundSetter.FIELD:
+              irBuilder.addPrimitive(
+                  new ir.SetStatic(setter, result, sourceInformation));
+              return;
+            case CompoundSetter.SETTER:
+              irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
+              return;
+            case CompoundSetter.INVALID:
+              irBuilder.buildStaticNoSuchMethod(
+                  new Selector.setter(new Name(setter.name, setter.library)),
+                  <ir.Primitive>[result],
+                  sourceInformation);
+              return;
+          }
+        });
   }
 
   @override
   ir.Primitive handleStaticSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
-    return translateSetIfNull(node, () {
-      SourceInformation sourceInformation =
-          sourceInformationBuilder.buildGet(node);
-      switch (getterKind) {
-        case CompoundGetter.FIELD:
-          return buildStaticFieldGet(getter, sourceInformation);
-        case CompoundGetter.GETTER:
-          return buildStaticGetterGet(getter, node, sourceInformation);
-        case CompoundGetter.METHOD:
-          return irBuilder.addPrimitive(new ir.GetStatic(getter,
-              sourceInformation: sourceInformation,
-              isFinal: true));
-        case CompoundGetter.UNRESOLVED:
-          return irBuilder.buildStaticNoSuchMethod(
-              new Selector.getter(new Name(getter.name, getter.library)),
-              <ir.Primitive>[],
-              sourceInformation);
-      }
-    }, rhs, (ir.Primitive result) {
-      SourceInformation sourceInformation =
-          sourceInformationBuilder.buildAssignment(node);
-      switch (setterKind) {
-        case CompoundSetter.FIELD:
-          irBuilder.addPrimitive(new ir.SetStatic(
-              setter, result, sourceInformation));
-          return;
-        case CompoundSetter.SETTER:
-          irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
-          return;
-        case CompoundSetter.INVALID:
-          irBuilder.buildStaticNoSuchMethod(
-              new Selector.setter(new Name(setter.name, setter.library)),
-              <ir.Primitive>[result],
-              sourceInformation);
-          return;
-      }
-    });
+    return translateSetIfNull(
+        node,
+        () {
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildGet(node);
+          switch (getterKind) {
+            case CompoundGetter.FIELD:
+              return buildStaticFieldGet(getter, sourceInformation);
+            case CompoundGetter.GETTER:
+              return buildStaticGetterGet(getter, node, sourceInformation);
+            case CompoundGetter.METHOD:
+              return irBuilder.addPrimitive(new ir.GetStatic(getter,
+                  sourceInformation: sourceInformation, isFinal: true));
+            case CompoundGetter.UNRESOLVED:
+              return irBuilder.buildStaticNoSuchMethod(
+                  new Selector.getter(new Name(getter.name, getter.library)),
+                  <ir.Primitive>[],
+                  sourceInformation);
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          SourceInformation sourceInformation =
+              sourceInformationBuilder.buildAssignment(node);
+          switch (setterKind) {
+            case CompoundSetter.FIELD:
+              irBuilder.addPrimitive(
+                  new ir.SetStatic(setter, result, sourceInformation));
+              return;
+            case CompoundSetter.SETTER:
+              irBuilder.buildStaticSetterSet(setter, result, sourceInformation);
+              return;
+            case CompoundSetter.INVALID:
+              irBuilder.buildStaticNoSuchMethod(
+                  new Selector.setter(new Name(setter.name, setter.library)),
+                  <ir.Primitive>[result],
+                  sourceInformation);
+              return;
+          }
+        });
   }
 
   ir.Primitive buildSuperNoSuchGetter(
-      Element element,
-      TypeMask mask,
-      SourceInformation sourceInformation) {
+      Element element, TypeMask mask, SourceInformation sourceInformation) {
     return buildSuperNoSuchMethod(
         new Selector.getter(new Name(element.name, element.library)),
         mask,
         const <ir.Primitive>[],
         sourceInformation);
   }
 
-  ir.Primitive buildSuperNoSuchSetter(
-      Element element,
-      TypeMask mask,
-      ir.Primitive value,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildSuperNoSuchSetter(Element element, TypeMask mask,
+      ir.Primitive value, SourceInformation sourceInformation) {
     return buildSuperNoSuchMethod(
         new Selector.setter(new Name(element.name, element.library)),
         mask,
         <ir.Primitive>[value],
         sourceInformation);
   }
 
   @override
   ir.Primitive handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(node, () {
-      switch (getterKind) {
-        case CompoundGetter.FIELD:
-          return irBuilder.buildSuperFieldGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.GETTER:
-          return irBuilder.buildSuperGetterGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.METHOD:
-          return irBuilder.buildSuperMethodGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.UNRESOLVED:
-          return buildSuperNoSuchGetter(
-              getter, elements.getGetterTypeMaskInComplexSendSet(node),
-              sourceInformationBuilder.buildGet(node));
-      }
-    }, rhs, (ir.Primitive result) {
-      switch (setterKind) {
-        case CompoundSetter.FIELD:
-          irBuilder.buildSuperFieldSet(setter, result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-        case CompoundSetter.SETTER:
-          irBuilder.buildSuperSetterSet(setter, result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-        case CompoundSetter.INVALID:
-          buildSuperNoSuchSetter(
-              setter, elements.getTypeMask(node), result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-      }
-    });
+    return translateCompounds(
+        node,
+        () {
+          switch (getterKind) {
+            case CompoundGetter.FIELD:
+              return irBuilder.buildSuperFieldGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.GETTER:
+              return irBuilder.buildSuperGetterGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.METHOD:
+              return irBuilder.buildSuperMethodGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.UNRESOLVED:
+              return buildSuperNoSuchGetter(
+                  getter,
+                  elements.getGetterTypeMaskInComplexSendSet(node),
+                  sourceInformationBuilder.buildGet(node));
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          switch (setterKind) {
+            case CompoundSetter.FIELD:
+              irBuilder.buildSuperFieldSet(setter, result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+            case CompoundSetter.SETTER:
+              irBuilder.buildSuperSetterSet(setter, result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+            case CompoundSetter.INVALID:
+              buildSuperNoSuchSetter(setter, elements.getTypeMask(node), result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+          }
+        });
   }
 
   @override
   ir.Primitive handleSuperSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
-    return translateSetIfNull(node, () {
-      switch (getterKind) {
-        case CompoundGetter.FIELD:
-          return irBuilder.buildSuperFieldGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.GETTER:
-          return irBuilder.buildSuperGetterGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.METHOD:
-          return irBuilder.buildSuperMethodGet(
-              getter, sourceInformationBuilder.buildGet(node));
-        case CompoundGetter.UNRESOLVED:
-          return buildSuperNoSuchGetter(
-              getter,
-              elements.getGetterTypeMaskInComplexSendSet(node),
-              sourceInformationBuilder.buildGet(node));
-      }
-    }, rhs, (ir.Primitive result) {
-      switch (setterKind) {
-        case CompoundSetter.FIELD:
-          irBuilder.buildSuperFieldSet(
-              setter, result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-        case CompoundSetter.SETTER:
-          irBuilder.buildSuperSetterSet(
-              setter, result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-        case CompoundSetter.INVALID:
-          buildSuperNoSuchSetter(
-              setter, elements.getTypeMask(node), result,
-              sourceInformationBuilder.buildAssignment(node));
-          return;
-      }
-    });
+    return translateSetIfNull(
+        node,
+        () {
+          switch (getterKind) {
+            case CompoundGetter.FIELD:
+              return irBuilder.buildSuperFieldGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.GETTER:
+              return irBuilder.buildSuperGetterGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.METHOD:
+              return irBuilder.buildSuperMethodGet(
+                  getter, sourceInformationBuilder.buildGet(node));
+            case CompoundGetter.UNRESOLVED:
+              return buildSuperNoSuchGetter(
+                  getter,
+                  elements.getGetterTypeMaskInComplexSendSet(node),
+                  sourceInformationBuilder.buildGet(node));
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          switch (setterKind) {
+            case CompoundSetter.FIELD:
+              irBuilder.buildSuperFieldSet(setter, result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+            case CompoundSetter.SETTER:
+              irBuilder.buildSuperSetterSet(setter, result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+            case CompoundSetter.INVALID:
+              buildSuperNoSuchSetter(setter, elements.getTypeMask(node), result,
+                  sourceInformationBuilder.buildAssignment(node));
+              return;
+          }
+        });
   }
 
   @override
-  ir.Primitive handleTypeVariableTypeLiteralCompounds(
-      ast.SendSet node,
-      TypeVariableElement typeVariable,
-      CompoundRhs rhs,
-      arg) {
-    return translateCompounds(node, () {
-      return irBuilder.buildReifyTypeVariable(
-          typeVariable.type,
-          sourceInformationBuilder.buildGet(node));
-    }, rhs, (ir.Primitive value) {
-      // The binary operator will throw before this.
-    });
+  ir.Primitive handleTypeVariableTypeLiteralCompounds(ast.SendSet node,
+      TypeVariableElement typeVariable, CompoundRhs rhs, arg) {
+    return translateCompounds(
+        node,
+        () {
+          return irBuilder.buildReifyTypeVariable(
+              typeVariable.type, sourceInformationBuilder.buildGet(node));
+        },
+        rhs,
+        (ir.Primitive value) {
+          // The binary operator will throw before this.
+        });
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralSetIfNull(
-      ast.Send node,
-      TypeVariableElement element,
-      ast.Node rhs,
-      _) {
+      ast.Send node, TypeVariableElement element, ast.Node rhs, _) {
     // The type variable is never `null`.
-    return translateTypeVariableTypeLiteral(element,
-        sourceInformationBuilder.buildGet(node));
+    return translateTypeVariableTypeLiteral(
+        element, sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive handleIndexCompounds(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      CompoundRhs rhs,
-      arg) {
+  ir.Primitive handleIndexCompounds(ast.SendSet node, ast.Node receiver,
+      ast.Node index, CompoundRhs rhs, arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
-    return translateCompounds(node, () {
-      Selector selector = new Selector.index();
-      List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-      CallStructure callStructure =
-          normalizeDynamicArguments(selector.callStructure, arguments);
-      return irBuilder.buildDynamicInvocation(
-          target,
-          new Selector(selector.kind, selector.memberName, callStructure),
-          elements.getGetterTypeMaskInComplexSendSet(node),
-          arguments,
-          sourceInformationBuilder.buildCall(receiver, node));
-    }, rhs, (ir.Primitive result) {
-      irBuilder.buildDynamicIndexSet(
-          target,
-          elements.getTypeMask(node),
-          indexValue,
-          result,
-          sourceInformationBuilder.buildIndexSet(node));
-    });
+    return translateCompounds(
+        node,
+        () {
+          Selector selector = new Selector.index();
+          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
+          CallStructure callStructure =
+              normalizeDynamicArguments(selector.callStructure, arguments);
+          return irBuilder.buildDynamicInvocation(
+              target,
+              new Selector(selector.kind, selector.memberName, callStructure),
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              arguments,
+              sourceInformationBuilder.buildCall(receiver, node));
+        },
+        rhs,
+        (ir.Primitive result) {
+          irBuilder.buildDynamicIndexSet(target, elements.getTypeMask(node),
+              indexValue, result, sourceInformationBuilder.buildIndexSet(node));
+        });
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
       {bool isGetterValid,
-       bool isSetterValid}) {
+      bool isSetterValid}) {
     ir.Primitive indexValue = visit(index);
-    return translateCompounds(node, () {
-      if (isGetterValid) {
-        return irBuilder.buildSuperIndex(
-            indexFunction,
-            indexValue,
-            sourceInformationBuilder.buildIndex(node));
-      } else {
-        return buildSuperNoSuchMethod(
-            new Selector.index(),
-            elements.getGetterTypeMaskInComplexSendSet(node),
-            <ir.Primitive>[indexValue],
-            sourceInformationBuilder.buildIndex(node));
-      }
-    }, rhs, (ir.Primitive result) {
-      if (isSetterValid) {
-        irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result,
-            sourceInformationBuilder.buildIndexSet(node));
-      } else {
-        buildSuperNoSuchMethod(
-            new Selector.indexSet(),
-            elements.getTypeMask(node),
-            <ir.Primitive>[indexValue, result],
-            sourceInformationBuilder.buildIndexSet(node));
-      }
-    });
+    return translateCompounds(
+        node,
+        () {
+          if (isGetterValid) {
+            return irBuilder.buildSuperIndex(indexFunction, indexValue,
+                sourceInformationBuilder.buildIndex(node));
+          } else {
+            return buildSuperNoSuchMethod(
+                new Selector.index(),
+                elements.getGetterTypeMaskInComplexSendSet(node),
+                <ir.Primitive>[indexValue],
+                sourceInformationBuilder.buildIndex(node));
+          }
+        },
+        rhs,
+        (ir.Primitive result) {
+          if (isSetterValid) {
+            irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result,
+                sourceInformationBuilder.buildIndexSet(node));
+          } else {
+            buildSuperNoSuchMethod(
+                new Selector.indexSet(),
+                elements.getTypeMask(node),
+                <ir.Primitive>[indexValue, result],
+                sourceInformationBuilder.buildIndexSet(node));
+          }
+        });
   }
 
   /// Build code to handle foreign code, that is, native JavaScript code, or
   /// builtin values and operations of the backend.
-  ir.Primitive handleForeignCode(ast.Send node,
-      MethodElement function,
-      ast.NodeList argumentList,
-      CallStructure callStructure) {
-
+  ir.Primitive handleForeignCode(ast.Send node, MethodElement function,
+      ast.NodeList argumentList, CallStructure callStructure) {
     void validateArgumentCount({int minimum, int exactly}) {
       assert((minimum == null) != (exactly == null));
       int count = 0;
       int maximum;
       if (exactly != null) {
         minimum = exactly;
         maximum = exactly;
       }
       for (ast.Node argument in argumentList) {
         count++;
         if (maximum != null && count > maximum) {
           internalError(argument, 'Additional argument.');
         }
       }
       if (count < minimum) {
         internalError(node, 'Expected at least $minimum arguments.');
       }
     }
 
     /// Call a helper method from the isolate library. The isolate library uses
     /// its own isolate structure, that encapsulates dart2js's isolate.
-    ir.Primitive buildIsolateHelperInvocation(MethodElement element,
-        CallStructure callStructure) {
+    ir.Primitive buildIsolateHelperInvocation(
+        MethodElement element, CallStructure callStructure) {
       if (element == null) {
-        reporter.internalError(node,
-            'Isolate library and compiler mismatch.');
+        reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       List<ir.Primitive> arguments = <ir.Primitive>[];
-      callStructure = translateStaticArguments(argumentList, element,
-          callStructure, arguments);
+      callStructure = translateStaticArguments(
+          argumentList, element, callStructure, arguments);
       Selector selector = new Selector.call(element.memberName, callStructure);
       return irBuilder.buildInvokeStatic(element, selector, arguments,
           sourceInformationBuilder.buildCall(node, node.selector));
     }
 
     /// Lookup the value of the enum described by [node].
     getEnumValue(ast.Node node, EnumClassElement enumClass, List values) {
       Element element = elements[node];
       if (element is! FieldElement || element.enclosingClass != enumClass) {
         internalError(node, 'expected a JsBuiltin enum value');
       }
 
       int index = enumClass.enumValues.indexOf(element);
       return values[index];
     }
 
     /// Returns the String the node evaluates to, or throws an error if the
     /// result is not a string constant.
     String expectStringConstant(ast.Node node) {
       ir.Primitive nameValue = visit(node);
       if (nameValue is ir.Constant && nameValue.value.isString) {
         StringConstantValue constantValue = nameValue.value;
         return constantValue.primitiveValue.slowToString();
       } else {
         return internalError(node, 'expected a literal string');
       }
     }
 
-    Link<ast.Node> argumentNodes  = argumentList.nodes;
+    Link<ast.Node> argumentNodes = argumentList.nodes;
     NativeBehavior behavior =
-    compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
+        compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
     switch (function.name) {
       case 'JS':
         validateArgumentCount(minimum: 2);
         // The first two arguments are the type and the foreign code template,
         // which already have been analyzed by the resolver and can be retrieved
         // using [NativeBehavior]. We can ignore these arguments in the backend.
         List<ir.Primitive> arguments =
-        argumentNodes.skip(2).mapToList(visit, growable: false);
+            argumentNodes.skip(2).mapToList(visit, growable: false);
         if (behavior.codeTemplate.positionalArgumentCount != arguments.length) {
-          reporter.reportErrorMessage(
-              node, MessageKind.GENERIC,
-              {'text':
-              'Mismatch between number of placeholders'
-                  ' and number of arguments.'});
+          reporter.reportErrorMessage(node, MessageKind.GENERIC, {
+            'text': 'Mismatch between number of placeholders'
+                ' and number of arguments.'
+          });
           return irBuilder.buildNullConstant();
         }
 
         if (HasCapturedPlaceholders.check(behavior.codeTemplate.ast)) {
           reporter.reportErrorMessage(node, MessageKind.JS_PLACEHOLDER_CAPTURE);
           return irBuilder.buildNullConstant();
         }
 
         return irBuilder.buildForeignCode(behavior.codeTemplate, arguments,
             behavior, sourceInformationBuilder.buildForeignCode(node));
 
       case 'DART_CLOSURE_TO_JS':
       // TODO(ahe): This should probably take care to wrap the closure in
       // another closure that saves the current isolate.
       case 'RAW_DART_FUNCTION_REF':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = node.arguments.single;
         FunctionElement closure = elements[argument].implementation;
         if (!Elements.isStaticOrTopLevelFunction(closure)) {
-          internalError(argument,
-              'only static or toplevel function supported');
+          internalError(argument, 'only static or toplevel function supported');
         }
         if (closure.functionSignature.hasOptionalParameters) {
-          internalError(argument,
-              'closures with optional parameters not supported');
+          internalError(
+              argument, 'closures with optional parameters not supported');
         }
         return irBuilder.buildForeignCode(
             js.js.expressionTemplateYielding(
                 backend.emitter.staticFunctionAccess(closure)),
             <ir.Primitive>[],
             NativeBehavior.PURE,
             sourceInformationBuilder.buildForeignCode(node),
             dependency: closure);
 
       case 'JS_BUILTIN':
-      // The first argument is a description of the type and effect of the
-      // builtin, which has already been analyzed in the frontend.  The second
-      // argument must be a [JsBuiltin] value.  All other arguments are
-      // values used by the JavaScript template that is associated with the
-      // builtin.
+        // The first argument is a description of the type and effect of the
+        // builtin, which has already been analyzed in the frontend.  The second
+        // argument must be a [JsBuiltin] value.  All other arguments are
+        // values used by the JavaScript template that is associated with the
+        // builtin.
         validateArgumentCount(minimum: 2);
 
         ast.Node builtin = argumentNodes.tail.head;
-        JsBuiltin value = getEnumValue(builtin, helpers.jsBuiltinEnum,
-            JsBuiltin.values);
+        JsBuiltin value =
+            getEnumValue(builtin, helpers.jsBuiltinEnum, JsBuiltin.values);
         js.Template template = backend.emitter.builtinTemplateFor(value);
         List<ir.Primitive> arguments =
-        argumentNodes.skip(2).mapToList(visit, growable: false);
+            argumentNodes.skip(2).mapToList(visit, growable: false);
         return irBuilder.buildForeignCode(template, arguments, behavior,
             sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_EMBEDDED_GLOBAL':
         validateArgumentCount(exactly: 2);
 
         String name = expectStringConstant(argumentNodes.tail.head);
         js.Expression access =
-        backend.emitter.generateEmbeddedGlobalAccess(name);
+            backend.emitter.generateEmbeddedGlobalAccess(name);
         js.Template template = js.js.expressionTemplateYielding(access);
         return irBuilder.buildForeignCode(template, <ir.Primitive>[], behavior,
             sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_INTERCEPTOR_CONSTANT':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
         ir.Primitive argumentValue = visit(argument);
         if (argumentValue is ir.Constant && argumentValue.value.isType) {
           TypeConstantValue constant = argumentValue.value;
           ConstantValue interceptorValue =
-          new InterceptorConstantValue(constant.representedType);
+              new InterceptorConstantValue(constant.representedType);
           return irBuilder.buildConstant(interceptorValue);
         }
         return internalError(argument, 'expected Type as argument');
 
       case 'JS_EFFECT':
         return irBuilder.buildNullConstant();
 
       case 'JS_GET_NAME':
         validateArgumentCount(exactly: 1);
 
         ast.Node argument = argumentNodes.head;
-        JsGetName id = getEnumValue(argument, helpers.jsGetNameEnum,
-            JsGetName.values);
+        JsGetName id =
+            getEnumValue(argument, helpers.jsGetNameEnum, JsGetName.values);
         js.Name name = backend.namer.getNameForJsGetName(argument, id);
-        ConstantValue nameConstant =
-        new SyntheticConstantValue(SyntheticConstantKind.NAME,
-            js.js.quoteName(name));
+        ConstantValue nameConstant = new SyntheticConstantValue(
+            SyntheticConstantKind.NAME, js.js.quoteName(name));
 
         return irBuilder.buildConstant(nameConstant);
 
       case 'JS_GET_FLAG':
         validateArgumentCount(exactly: 1);
 
         String name = expectStringConstant(argumentNodes.first);
         bool value = false;
         switch (name) {
           case 'MUST_RETAIN_METADATA':
             value = backend.mustRetainMetadata;
             break;
           case 'USE_CONTENT_SECURITY_POLICY':
             value = compiler.options.useContentSecurityPolicy;
             break;
           default:
             internalError(node, 'Unknown internal flag "$name".');
         }
         return irBuilder.buildBooleanConstant(value);
 
       case 'JS_STRING_CONCAT':
         validateArgumentCount(exactly: 2);
         List<ir.Primitive> arguments = argumentNodes.mapToList(visit);
-        return irBuilder.buildStringConcatenation(arguments,
-            sourceInformationBuilder.buildForeignCode(node));
+        return irBuilder.buildStringConcatenation(
+            arguments, sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_CURRENT_ISOLATE_CONTEXT':
         validateArgumentCount(exactly: 0);
 
         if (!compiler.hasIsolateSupport) {
           // If the isolate library is not used, we just generate code
           // to fetch the current isolate.
           continue getStaticState;
         }
-        return buildIsolateHelperInvocation(helpers.currentIsolate,
-            CallStructure.NO_ARGS);
+        return buildIsolateHelperInvocation(
+            helpers.currentIsolate, CallStructure.NO_ARGS);
 
       getStaticState: case 'JS_GET_STATIC_STATE':
         validateArgumentCount(exactly: 0);
 
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS(backend.namer.staticStateHolder),
             const <ir.Primitive>[],
             NativeBehavior.DEPENDS_OTHER,
             sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_SET_STATIC_STATE':
         validateArgumentCount(exactly: 1);
 
         ir.Primitive value = visit(argumentNodes.single);
         String isolateName = backend.namer.staticStateHolder;
         return irBuilder.buildForeignCode(
             js.js.parseForeignJS("$isolateName = #"),
             <ir.Primitive>[value],
             NativeBehavior.CHANGES_OTHER,
             sourceInformationBuilder.buildForeignCode(node));
 
       case 'JS_CALL_IN_ISOLATE':
         validateArgumentCount(exactly: 2);
 
         if (!compiler.hasIsolateSupport) {
           ir.Primitive closure = visit(argumentNodes.tail.head);
-          return irBuilder.buildCallInvocation(closure, CallStructure.NO_ARGS,
+          return irBuilder.buildCallInvocation(
+              closure,
+              CallStructure.NO_ARGS,
               const <ir.Primitive>[],
               sourceInformationBuilder.buildForeignCode(node));
         }
-        return buildIsolateHelperInvocation(helpers.callInIsolate,
-            CallStructure.TWO_ARGS);
+        return buildIsolateHelperInvocation(
+            helpers.callInIsolate, CallStructure.TWO_ARGS);
 
       default:
         return giveup(node, 'unplemented native construct: ${function.name}');
     }
   }
 
   /// Evaluates a string interpolation and appends each part to [accumulator]
   /// (after stringify conversion).
   void buildStringParts(ast.Node node, List<ir.Primitive> accumulator) {
     if (node is ast.StringJuxtaposition) {
@@ skipping 19 matching lines @@
           helpers.stringInterpolationHelper,
           <ir.Primitive>[value],
           sourceInformationBuilder.buildStringInterpolation(node)));
     }
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
-    return irBuilder.buildStringConcatenation(parts,
-        sourceInformationBuilder.buildStringInterpolation(node));
+    return irBuilder.buildStringConcatenation(
+        parts, sourceInformationBuilder.buildStringInterpolation(node));
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
-    return irBuilder.buildStringConcatenation(parts,
-        sourceInformationBuilder.buildStringInterpolation(node));
+    return irBuilder.buildStringConcatenation(
+        parts, sourceInformationBuilder.buildStringInterpolation(node));
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
-    return irBuilder.buildConstant(
-        getConstantForNode(node),
+    return irBuilder.buildConstant(getConstantForNode(node),
         sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   ir.Primitive visitThrow(ast.Throw node) {
     assert(irBuilder.isOpen);
     // This function is not called for throw expressions occurring as
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
-  ir.Primitive buildSuperNoSuchMethod(
-      Selector selector,
-      TypeMask mask,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildSuperNoSuchMethod(Selector selector, TypeMask mask,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     ClassElement cls = elements.analyzedElement.enclosingClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
-      element = compiler.coreClasses.objectClass.lookupMember(
-          Identifiers.noSuchMethod_);
+      element = compiler.coreClasses.objectClass
+          .lookupMember(Identifiers.noSuchMethod_);
     }
     return irBuilder.buildSuperMethodInvocation(
         element,
         Selectors.noSuchMethod_.callStructure,
         [irBuilder.buildInvocationMirror(selector, arguments)],
         sourceInformation);
   }
 
   @override
-  ir.Primitive visitUnresolvedCompound(
-      ast.Send node,
-      Element element,
-      op.AssignmentOperator operator,
-      ast.Node rhs, _) {
+  ir.Primitive visitUnresolvedCompound(ast.Send node, Element element,
+      op.AssignmentOperator operator, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.getter(new Name(element.name, element.library)),
         [],
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive visitUnresolvedClassConstructorInvoke(
       ast.NewExpression node,
       Element element,
       DartType type,
       ast.NodeList arguments,
-      Selector selector, _) {
+      Selector selector,
+      _) {
     // If the class is missing it's a runtime error.
     ir.Primitive message =
         irBuilder.buildStringConstant("Unresolved class: '${element.name}'");
-    return irBuilder.buildStaticFunctionInvocation(
-        helpers.throwRuntimeError,
-        <ir.Primitive>[message],
-        sourceInformationBuilder.buildNew(node));
+    return irBuilder.buildStaticFunctionInvocation(helpers.throwRuntimeError,
+        <ir.Primitive>[message], sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList argumentsNode,
-      Selector selector, _) {
+      Selector selector,
+      _) {
     // If the class is there but the constructor is missing, it's an NSM error.
     List<ir.Primitive> arguments = <ir.Primitive>[];
     CallStructure callStructure = translateDynamicArguments(
         argumentsNode, selector.callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector(selector.kind, selector.memberName, callStructure),
         arguments,
         sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitConstructorIncompatibleInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList argumentsNode,
-      CallStructure callStructure, _) {
+      CallStructure callStructure,
+      _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.call(constructor.memberName, callStructure), arguments,
+        new Selector.call(constructor.memberName, callStructure),
+        arguments,
         sourceInformationBuilder.buildNew(node));
   }
 
   @override
-  ir.Primitive visitUnresolvedGet(
-      ast.Send node,
-      Element element, _) {
-    return irBuilder.buildStaticNoSuchMethod(
-        elements.getSelector(node), [],
+  ir.Primitive visitUnresolvedGet(ast.Send node, Element element, _) {
+    return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), [],
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive visitUnresolvedInvoke(
-      ast.Send node,
-      Element element,
-      ast.NodeList arguments,
-      Selector selector, _) {
+  ir.Primitive visitUnresolvedInvoke(ast.Send node, Element element,
+      ast.NodeList arguments, Selector selector, _) {
     return irBuilder.buildStaticNoSuchMethod(
         elements.getSelector(node),
         arguments.nodes.mapToList(visit),
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
-       ast.NewExpression node,
-       ConstructorElement constructor,
-       InterfaceType type,
-       ast.NodeList argumentsNode,
-       CallStructure callStructure, _) {
+      ast.NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ast.NodeList argumentsNode,
+      CallStructure callStructure,
+      _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(name, callStructure),
         arguments,
         sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSet(
-      ast.Send node,
-      Element element,
-      ast.Node rhs, _) {
+      ast.Send node, Element element, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node),
-        [visit(rhs)],
-        sourceInformationBuilder.buildAssignment(node));
+        [visit(rhs)], sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndex(
-      ast.Send node,
-      Element function,
-      ast.Node index, _) {
+      ast.Send node, Element function, ast.Node index, _) {
     // Assume the index getter is missing.
     return buildSuperNoSuchMethod(
-        new Selector.index(), elements.getTypeMask(node), [visit(index)],
+        new Selector.index(),
+        elements.getTypeMask(node),
+        [visit(index)],
         sourceInformationBuilder.buildIndex(node));
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperBinary(
-      ast.Send node,
-      Element element,
-      op.BinaryOperator operator,
-      ast.Node argument, _) {
+  ir.Primitive visitUnresolvedSuperBinary(ast.Send node, Element element,
+      op.BinaryOperator operator, ast.Node argument, _) {
     return buildSuperNoSuchMethod(
         elements.getSelector(node),
         elements.getTypeMask(node),
         [visit(argument)],
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperUnary(
-      ast.Send node,
-      op.UnaryOperator operator,
-      Element element, _) {
+      ast.Send node, op.UnaryOperator operator, Element element, _) {
     return buildSuperNoSuchMethod(
-        elements.getSelector(node), elements.getTypeMask(node), [],
+        elements.getSelector(node),
+        elements.getTypeMask(node),
+        [],
         sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   @override
   ir.Primitive bulkHandleNode(ast.Node node, String message, _) {
     return giveup(node, "Unhandled node: ${message.replaceAll('#', '$node')}");
   }
 
   @override
   ir.Primitive bulkHandleError(ast.Node node, ErroneousElement error, _) {
     return irBuilder.buildNullConstant();
   }
 
   @override
   ir.Primitive visitClassTypeLiteralSet(
-      ast.SendSet node,
-      TypeConstantExpression constant,
-      ast.Node rhs, _) {
+      ast.SendSet node, TypeConstantExpression constant, ast.Node rhs, _) {
     InterfaceType type = constant.type;
     ClassElement element = type.element;
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitTypedefTypeLiteralSet(
-      ast.SendSet node,
-      TypeConstantExpression constant,
-      ast.Node rhs, _) {
+      ast.SendSet node, TypeConstantExpression constant, ast.Node rhs, _) {
     TypedefType type = constant.type;
     TypedefElement element = type.element;
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(element.memberName),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralSet(
-      ast.SendSet node,
-      TypeVariableElement element,
-      ast.Node rhs, _) {
+      ast.SendSet node, TypeVariableElement element, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.setter(element.memberName), [visit(rhs)],
+        new Selector.setter(element.memberName),
+        [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralSet(
-      ast.SendSet node,
-      ConstantExpression constant,
-      ast.Node rhs, _) {
+      ast.SendSet node, ConstantExpression constant, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
-        new Selector.setter(Names.dynamic_), [visit(rhs)],
+        new Selector.setter(Names.dynamic_),
+        [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
-      CallStructure callStructure, _) {
+      CallStructure callStructure,
+      _) {
     for (ast.Node argument in arguments) visit(argument);
     ir.Primitive name =
         irBuilder.buildStringConstant(element.enclosingClass.name);
     return irBuilder.buildStaticFunctionInvocation(
         helpers.throwAbstractClassInstantiationError,
         <ir.Primitive>[name],
         sourceInformationBuilder.buildNew(node));
   }
 
   @override
   ir.Primitive handleFinalStaticFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs, _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow for static class members?
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(field.memberName),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitFinalSuperFieldSet(
-      ast.SendSet node,
-      FieldElement field,
-      ast.Node rhs, _) {
+      ast.SendSet node, FieldElement field, ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(field.memberName),
         elements.getTypeMask(node),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleImmutableLocalSet(
-      ast.SendSet node,
-      LocalElement local,
-      ast.Node rhs, _) {
+      ast.SendSet node, LocalElement local, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(new Name(local.name, local.library)),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticFunctionSet(
-      ast.Send node,
-      MethodElement function,
-      ast.Node rhs,
-      _) {
+      ast.Send node, MethodElement function, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(function.memberName),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive handleStaticGetterSet(
-      ast.SendSet node,
-      GetterElement getter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, GetterElement getter, ast.Node rhs, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(getter.memberName),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
-  ir.Primitive handleStaticSetterGet(
-      ast.Send node,
-      SetterElement setter,
-      _) {
+  ir.Primitive handleStaticSetterGet(ast.Send node, SetterElement setter, _) {
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.getter(setter.memberName),
         [],
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive handleStaticSetterInvoke(
-      ast.Send node,
-      SetterElement setter,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure, _) {
+  ir.Primitive handleStaticSetterInvoke(ast.Send node, SetterElement setter,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     // Translate as a method call.
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
         arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
   ir.Primitive visitSuperGetterSet(
-      ast.SendSet node,
-      GetterElement getter,
-      ast.Node rhs,
-      _) {
+      ast.SendSet node, GetterElement getter, ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(getter.memberName),
         elements.getTypeMask(node),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
   ir.Primitive visitSuperMethodSet(
-      ast.Send node,
-      MethodElement method,
-      ast.Node rhs,
-      _) {
+      ast.Send node, MethodElement method, ast.Node rhs, _) {
     return buildSuperNoSuchMethod(
         new Selector.setter(method.memberName),
         elements.getTypeMask(node),
         [visit(rhs)],
         sourceInformationBuilder.buildAssignment(node));
   }
 
   @override
-  ir.Primitive visitSuperSetterGet(
-      ast.Send node,
-      SetterElement setter, _) {
+  ir.Primitive visitSuperSetterGet(ast.Send node, SetterElement setter, _) {
     return buildSuperNoSuchMethod(
         new Selector.getter(setter.memberName),
         elements.getTypeMask(node),
         [],
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
-  ir.Primitive visitSuperSetterInvoke(
-      ast.Send node,
-      SetterElement setter,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure, _) {
+  ir.Primitive visitSuperSetterInvoke(ast.Send node, SetterElement setter,
+      ast.NodeList argumentsNode, CallStructure callStructure, _) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return buildSuperNoSuchMethod(
         new Selector.call(setter.memberName, callStructure),
         elements.getTypeMask(node),
         arguments,
         sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
-    } catch(e) {
+    } catch (e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   internalError(ast.Node node, String message) {
     reporter.internalError(node, message);
   }
@@ skipping 208 matching lines @@
       return _backend.dynamicType;
     }
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 
   bool isArrayType(TypeMask type) {
     return type.satisfies(_backend.helpers.jsArrayClass, _compiler.world);
   }
 
   TypeMask getTypeMaskForNativeFunction(FunctionElement function) {
-    return  _compiler.typesTask.getGuaranteedReturnTypeOfElement(function);
+    return _compiler.typesTask.getGuaranteedReturnTypeOfElement(function);
   }
 
   FieldElement locateSingleField(Selector selector, TypeMask type) {
     return _compiler.world.locateSingleField(selector, type);
   }
 
   bool fieldNeverChanges(FieldElement field) {
     return _compiler.world.fieldNeverChanges(field);
   }
 
   Element get closureConverter {
     return _backend.helpers.closureConverter;
   }
 
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
 
   bool get trustJSInteropTypeAnnotations =>
       _compiler.options.trustJSInteropTypeAnnotations;
 
   bool isNative(ClassElement element) => _backend.isNative(element);
 
   bool isJsInterop(FunctionElement element) => _backend.isJsInterop(element);
 
   bool isJsInteropAnonymous(FunctionElement element) =>
-    _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
+      _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
-      '${_backend.nativeData.getFixedBackendName(element)}';
+        '${_backend.nativeData.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
-    _backend.helpers.jsJavaScriptObjectClass.thisType;
+      _backend.helpers.jsJavaScriptObjectClass.thisType;
 }