dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../closure.dart' as closure;
 import '../common.dart';
-import '../common/names.dart' show
-    Names,
-    Selectors;
-import '../compile_time_constants.dart' show
-    BackendConstantEnvironment;
+import '../common/names.dart' show Names, Selectors;
+import '../compile_time_constants.dart' show BackendConstantEnvironment;
 import '../constants/constant_system.dart';
-import '../constants/values.dart' show
-    ConstantValue,
-    PrimitiveConstantValue;
+import '../constants/values.dart' show ConstantValue, PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
-import '../js/js.dart' as js show
-    js,
-    objectLiteral,
-    Expression,
-    LiteralStatement,
-    Template,
-    InterpolatedExpression,
-    isIdentityTemplate;
-import '../native/native.dart' show
-    NativeBehavior;
+import '../js/js.dart' as js
+    show
+        js,
+        objectLiteral,
+        Expression,
+        LiteralStatement,
+        Template,
+        InterpolatedExpression,
+        isIdentityTemplate;
+import '../native/native.dart' show NativeBehavior;
 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,
-    SelectorKind;
+import '../types/types.dart' show TypeMask;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector, SelectorKind;
 
-import 'cps_ir_builder_task.dart' show
-    GlobalProgramInformation;
+import 'cps_ir_builder_task.dart' show GlobalProgramInformation;
 import 'cps_ir_nodes.dart' as ir;
 
-
 /// A mapping from variable elements to their compile-time values.
 ///
 /// Map elements denoted by parameters and local variables to the
 /// [ir.Primitive] that is their value.  Parameters and locals are
 /// assigned indexes which can be used to refer to them.
 class Environment {
   /// A map from locals to their environment index.
   final Map<Local, int> variable2index;
 
   /// A reverse map from environment indexes to the variable.
@@ skipping 48 matching lines @@
     ir.Primitive value = index2value.last;
     // The map from variables to their index are shared, so we cannot remove
     // the mapping in `variable2index`.
     index2variable.length -= count;
     index2value.length -= count;
     return value;
   }
 
   ir.Primitive lookup(Local element) {
     assert(invariant(element, variable2index.containsKey(element),
-                     message: "Unknown variable: $element."));
+        message: "Unknown variable: $element."));
     return index2value[variable2index[element]];
   }
 
   void update(Local element, ir.Primitive value) {
     index2value[variable2index[element]] = value;
   }
 
   /// Verify that the variable2index and index2variable maps agree up to the
   /// index [length] exclusive.
   bool sameDomain(int length, Environment other) {
@@ skipping 27 matching lines @@
   final Environment _continuationEnvironment;
 
   final List<Iterable<LocalVariableElement>> _boxedTryVariables =
       <Iterable<LocalVariableElement>>[];
 
   /// Construct a collector for a given environment and optionally a target.
   ///
   /// The environment is the one in effect at the point where the jump's
   /// continuation will be bound.  Continuations can take an extra argument
   /// (see [addJump]).
-  JumpCollector(this._continuationEnvironment, this.target,
-      bool hasExtraArgument) {
+  JumpCollector(
+      this._continuationEnvironment, this.target, bool hasExtraArgument) {
     if (hasExtraArgument) _continuationEnvironment.extend(null, null);
   }
 
   /// Construct a collector for collecting only return jumps.
   ///
   /// There is no jump target, it is implicitly the exit from the function.
   /// There is no environment at the destination.
   JumpCollector.retrn(this._continuation)
-      : _continuationEnvironment = null, target = null;
+      : _continuationEnvironment = null,
+        target = null;
 
   /// Construct a collector for collecting goto jumps.
   ///
   /// There is no continuation or environment at the destination.
   JumpCollector.goto(this.target) : _continuationEnvironment = null;
 
   /// True if the collector has not recorded any jumps to its continuation.
   bool get isEmpty;
 
   /// The continuation encapsulated by this collector.
@@ skipping 91 matching lines @@
 
   Environment get environment {
     if (_continuation == null) _setContinuation();
     return _continuationEnvironment;
   }
 
   void addJump(IrBuilder builder,
       [ir.Primitive value, SourceInformation sourceInformation]) {
     assert(_continuation == null);
     _buildTryExit(builder);
-    ir.InvokeContinuation invoke = new ir.InvokeContinuation.uninitialized(
-        isEscapingTry: isEscapingTry);
+    ir.InvokeContinuation invoke =
+        new ir.InvokeContinuation.uninitialized(isEscapingTry: isEscapingTry);
     builder.add(invoke);
     _invocations.add(invoke);
     // Truncate the environment at the invocation site so it only includes
     // values that will be continuation arguments.  If an extra value is passed
     // it will already be included in the continuation environment, but it is
     // not present in the invocation environment.
     int delta = builder.environment.length - _continuationEnvironment.length;
     if (value != null) ++delta;
     if (delta > 0) builder.environment.discard(delta);
     if (value != null) builder.environment.extend(null, value);
@@ skipping 14 matching lines @@
     // that has a different value (from the environment in scope at the
     // continuation binding) on some path.  `_environment` is initially a copy
     // of the environment in scope at the continuation binding.  Compute the
     // continuation parameters and add them to `_environment` so it will become
     // the one in scope for the continuation body.
     List<ir.Parameter> parameters = <ir.Parameter>[];
     if (_invocationEnvironments.isNotEmpty) {
       int length = _continuationEnvironment.length;
       for (int varIndex = 0; varIndex < length; ++varIndex) {
         for (Environment invocationEnvironment in _invocationEnvironments) {
-          assert(invocationEnvironment.sameDomain(length,
-                                                  _continuationEnvironment));
+          assert(invocationEnvironment.sameDomain(
+              length, _continuationEnvironment));
           if (invocationEnvironment[varIndex] !=
               _continuationEnvironment[varIndex]) {
             ir.Parameter parameter = new ir.Parameter(
                 _continuationEnvironment.index2variable[varIndex]);
             _continuationEnvironment.index2value[varIndex] = parameter;
             parameters.add(parameter);
             break;
           }
         }
       }
@@ skipping 61 matching lines @@
     isEmpty = false;
     _buildTryExit(builder);
     // Truncate the environment at the invocation site so it only includes
     // values that will be continuation arguments.  If an extra value is passed
     // it will already be included in the continuation environment, but it is
     // not present in the invocation environment.
     int delta = builder.environment.length - _continuationEnvironment.length;
     if (value != null) ++delta;
     if (delta > 0) builder.environment.discard(delta);
     if (value != null) builder.environment.extend(null, value);
-    builder.add(new ir.InvokeContinuation(_continuation,
-        builder.environment.index2value,
-        isRecursive: true,
-        isEscapingTry: isEscapingTry));
+    builder.add(new ir.InvokeContinuation(
+        _continuation, builder.environment.index2value,
+        isRecursive: true, isEscapingTry: isEscapingTry));
     builder._current = null;
   }
 }
 
 /// Collect 'return' jumps.
 ///
 /// A return jump is one that targets the return continuation of a function.
 /// Thus, returns from inside try/finally are not return jumps because they are
 /// intercepted by a block that contains the finally handler code.
 class ReturnJumpCollector extends JumpCollector {
   bool isEmpty = true;
   ir.Continuation get continuation => _continuation;
   Environment environment = null;
 
   /// Construct a return jump collector for a given return continuation.
   ReturnJumpCollector(ir.Continuation continuation) : super.retrn(continuation);
 
   void addJump(IrBuilder builder,
       [ir.Primitive value, SourceInformation sourceInformation]) {
     isEmpty = false;
     builder.add(new ir.InvokeContinuation(continuation, <ir.Primitive>[value],
-        isEscapingTry: isEscapingTry,
-        sourceInformation: sourceInformation));
+        isEscapingTry: isEscapingTry, sourceInformation: sourceInformation));
     builder._current = null;
   }
 }
 
 /// Collect 'goto' jumps, continue to a labeled case from within a switch.
 ///
 /// These jumps are unrestricted within the switch.  They can be forward or
 /// backward.  They are implemented by assigning to a state variable.
 class GotoJumpCollector extends JumpCollector {
   bool isEmpty = true;
   final ir.Continuation continuation = null;
   final Environment environment = null;
 
   int _stateVariableIndex;
   int _stateValue;
   JumpCollector _breakJoin;
 
   GotoJumpCollector(JumpTarget target, this._stateVariableIndex,
-      this._stateValue, this._breakJoin) : super.goto(target);
+      this._stateValue, this._breakJoin)
+      : super.goto(target);
 
   void addJump(IrBuilder builder,
       [ir.Primitive value, SourceInformation sourceInformation]) {
     isEmpty = false;
     ir.Primitive constant = builder.buildIntegerConstant(_stateValue);
     builder.environment.index2value[_stateVariableIndex] = constant;
     builder.jumpTo(_breakJoin);
   }
 }
 
@@ skipping 134 matching lines @@
   /// Mutable variables are treated as boxed.  Writes to them are observable
   /// side effects.
   Map<Local, ir.MutableVariable> mutableVariables;
 
   ir.Expression root = null;
   ir.Expression _current = null;
 
   GlobalProgramInformation get program => state.program;
 
   IrBuilder(GlobalProgramInformation program,
-            BackendConstantEnvironment constants,
-            ExecutableElement currentElement)
-    : state = new IrBuilderSharedState(program, constants, currentElement),
-      environment = new Environment.empty(),
-      mutableVariables = <Local, ir.MutableVariable>{};
+      BackendConstantEnvironment constants, ExecutableElement currentElement)
+      : state = new IrBuilderSharedState(program, constants, currentElement),
+        environment = new Environment.empty(),
+        mutableVariables = <Local, ir.MutableVariable>{};
 
   IrBuilder._internal(this.state, this.environment, this.mutableVariables);
 
   /// Construct a delimited visitor for visiting a subtree.
   ///
   /// Build a subterm that is not (yet) connected to the CPS term.  The
   /// delimited visitor has its own has its own context for building an IR
   /// expression, so the built expression is not plugged into the parent's
   /// context.  It has its own compile-time environment mapping local
   /// variables to their values.  If an optional environment argument is
   /// supplied, it is used as the builder's initial environment.  Otherwise
   /// the environment is initially a copy of the parent builder's environment.
   IrBuilder makeDelimitedBuilder([Environment env = null]) {
     return new IrBuilder._internal(
         state,
         env != null ? env : new Environment.from(environment),
         mutableVariables);
   }
 
   /// True if [local] should currently be accessed from a [ir.MutableVariable].
   bool isInMutableVariable(Local local) {
     return mutableVariables.containsKey(local);
   }
 
   /// Creates a [ir.MutableVariable] for the given local.
   void makeMutableVariable(Local local) {
-    mutableVariables[local] =
-        new ir.MutableVariable(local);
+    mutableVariables[local] = new ir.MutableVariable(local);
   }
 
   /// Remove an [ir.MutableVariable] for a local.
   ///
   /// Subsequent access to the local will be direct rather than through the
   /// mutable variable.
   void removeMutableVariable(Local local) {
     mutableVariables.remove(local);
   }
 
   /// Gets the [MutableVariable] containing the value of [local].
   ir.MutableVariable getMutableVariable(Local local) {
     return mutableVariables[local];
   }
 
   bool get isOpen => root == null || _current != null;
 
   List<ir.Primitive> buildFunctionHeader(Iterable<Local> parameters,
-                                        {ClosureScope closureScope,
-                                         ClosureEnvironment env}) {
+      {ClosureScope closureScope, ClosureEnvironment env}) {
     _createThisParameter();
     _enterClosureEnvironment(env);
     _enterScope(closureScope);
     parameters.forEach(_createFunctionParameter);
     return _parameters;
   }
 
   /// Creates a parameter for [local] and adds it to the current environment.
   ir.Parameter _createLocalParameter(Local local) {
     ir.Parameter parameter = new ir.Parameter(local);
@@ skipping 15 matching lines @@
       _current = _current.plug(expr);
     }
   }
 
   /// Create and add a new [LetPrim] for [primitive].
   ir.Primitive addPrimitive(ir.Primitive primitive) {
     add(new ir.LetPrim(primitive));
     return primitive;
   }
 
-  ir.Primitive buildInvokeStatic(Element element,
-                                 Selector selector,
-                                 List<ir.Primitive> arguments,
-                                 SourceInformation sourceInformation) {
+  ir.Primitive buildInvokeStatic(Element element, Selector selector,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     assert(!element.isLocal);
     assert(!element.isInstanceMember);
     assert(isOpen);
     if (program.isJsInterop(element)) {
       return buildInvokeJsInteropMember(element, arguments, sourceInformation);
     }
     return addPrimitive(
         new ir.InvokeStatic(element, selector, arguments, sourceInformation));
   }
 
-  ir.Primitive _buildInvokeSuper(Element target,
-                                 Selector selector,
-                                 List<ir.Primitive> arguments,
-                                 SourceInformation sourceInformation) {
+  ir.Primitive _buildInvokeSuper(Element target, Selector selector,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     assert(target.isInstanceMember);
     assert(isOpen);
     return addPrimitive(new ir.InvokeMethodDirectly(
         buildThis(), target, selector, arguments, sourceInformation));
   }
 
-  ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
-                                   Selector selector,
-                                   TypeMask mask,
-                                   List<ir.Primitive> arguments,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive _buildInvokeDynamic(
+      ir.Primitive receiver,
+      Selector selector,
+      TypeMask mask,
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     assert(isOpen);
-    return addPrimitive(new ir.InvokeMethod(
-        receiver, selector, mask, arguments,
+    return addPrimitive(new ir.InvokeMethod(receiver, selector, mask, arguments,
         sourceInformation: sourceInformation));
   }
 
-  ir.Primitive _buildInvokeCall(ir.Primitive target,
-                                CallStructure callStructure,
-                                TypeMask mask,
-                                List<ir.Definition> arguments,
-                                SourceInformation sourceInformation) {
+  ir.Primitive _buildInvokeCall(
+      ir.Primitive target,
+      CallStructure callStructure,
+      TypeMask mask,
+      List<ir.Definition> arguments,
+      SourceInformation sourceInformation) {
     Selector selector = callStructure.callSelector;
     return _buildInvokeDynamic(
         target, selector, mask, arguments, sourceInformation);
   }
 
-  ir.Primitive buildStaticNoSuchMethod(
-      Selector selector,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildStaticNoSuchMethod(Selector selector,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     ir.Primitive receiver = buildStringConstant('');
     ir.Primitive name = buildStringConstant(selector.name);
     ir.Primitive argumentList = buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = buildNullConstant();
     return buildStaticFunctionInvocation(
         program.throwNoSuchMethod,
         <ir.Primitive>[receiver, name, argumentList, expectedArgumentNames],
         sourceInformation);
   }
 
   /// Create a [ir.Constant] from [value] and add it to the CPS term.
   ir.Constant buildConstant(ConstantValue value,
-                            {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     assert(isOpen);
     return addPrimitive(
         new ir.Constant(value, sourceInformation: sourceInformation));
   }
 
   /// Create an integer constant and add it to the CPS term.
   ir.Constant buildIntegerConstant(int value) {
     return buildConstant(state.constantSystem.createInt(value));
   }
 
@@ skipping 18 matching lines @@
         state.constantSystem.createString(new ast.DartString.literal(value)));
   }
 
   /// Create a string constant and add it to the CPS term.
   ir.Constant buildDartStringConstant(ast.DartString value) {
     return buildConstant(state.constantSystem.createString(value));
   }
 
   /// Creates a non-constant list literal of the provided [type] and with the
   /// provided [values].
-  ir.Primitive buildListLiteral(InterfaceType type,
-                                Iterable<ir.Primitive> values,
-                                {TypeMask allocationSiteType}) {
+  ir.Primitive buildListLiteral(
+      InterfaceType type, Iterable<ir.Primitive> values,
+      {TypeMask allocationSiteType}) {
     assert(isOpen);
     return addPrimitive(new ir.LiteralList(type, values.toList(),
         allocationSiteType: allocationSiteType));
   }
 
   /// Creates a conditional expression with the provided [condition] where the
   /// then and else expression are created through the [buildThenExpression]
   /// and [buildElseExpression] functions, respectively.
   ir.Primitive buildConditional(
       ir.Primitive condition,
@@ skipping 22 matching lines @@
     // Build the term
     //   let cont join(x, ..., result) = [] in
     //   let cont then() = [[thenPart]]; join(v, ...)
     //        and else() = [[elsePart]]; join(v, ...)
     //   in
     //     if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     thenContinuation.body = thenBuilder.root;
     elseContinuation.body = elseBuilder.root;
-    add(new ir.LetCont(join.continuation,
-            new ir.LetCont.two(thenContinuation, elseContinuation,
-                new ir.Branch.strict(condition,
-                                     thenContinuation,
-                                     elseContinuation,
-                                     sourceInformation))));
+    add(new ir.LetCont(
+        join.continuation,
+        new ir.LetCont.two(
+            thenContinuation,
+            elseContinuation,
+            new ir.Branch.strict(condition, thenContinuation, elseContinuation,
+                sourceInformation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   /**
    * Add an explicit `return null` for functions that don't have a return
    * statement on each branch. This includes functions with an empty body,
    * such as `foo(){ }`.
    */
   void _ensureReturn() {
     if (!isOpen) return;
     ir.Constant constant = buildNullConstant();
     add(new ir.InvokeContinuation(state.returnContinuation, [constant]));
     _current = null;
   }
 
   /// Create a [ir.FunctionDefinition] using [root] as the body.
   ///
   /// The protocol for building a function is:
   /// 1. Call [buildFunctionHeader].
   /// 2. Call `buildXXX` methods to build the body.
   /// 3. Call [makeFunctionDefinition] to finish.
   ir.FunctionDefinition makeFunctionDefinition(
       SourceInformation sourceInformation) {
     _ensureReturn();
-    return new ir.FunctionDefinition(
-        state.currentElement,
-        state.thisParameter,
-        state.functionParameters,
-        state.returnContinuation,
-        root,
+    return new ir.FunctionDefinition(state.currentElement, state.thisParameter,
+        state.functionParameters, state.returnContinuation, root,
         sourceInformation: sourceInformation);
   }
 
   /// Create a invocation of the [method] on the super class where the call
   /// structure is defined [callStructure] and the argument values are defined
   /// by [arguments].
   ir.Primitive buildSuperMethodInvocation(
       MethodElement method,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation) {
     // TODO(johnniwinther): This shouldn't be necessary.
     SelectorKind kind = Elements.isOperatorName(method.name)
-        ? SelectorKind.OPERATOR : SelectorKind.CALL;
-    Selector selector =
-        new Selector(kind, method.memberName, callStructure);
+        ? SelectorKind.OPERATOR
+        : SelectorKind.CALL;
+    Selector selector = new Selector(kind, method.memberName, callStructure);
     return _buildInvokeSuper(method, selector, arguments, sourceInformation);
   }
 
   /// Create a read access of the [method] on the super class, i.e. a
   /// closurization of [method].
-  ir.Primitive buildSuperMethodGet(MethodElement method,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive buildSuperMethodGet(
+      MethodElement method, SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
-    return _buildInvokeSuper(
-        method,
-        new Selector.getter(method.memberName),
-        const <ir.Primitive>[],
-        sourceInformation);
+    return _buildInvokeSuper(method, new Selector.getter(method.memberName),
+        const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a getter invocation of the [getter] on the super class.
-  ir.Primitive buildSuperGetterGet(MethodElement getter,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive buildSuperGetterGet(
+      MethodElement getter, SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
-    return _buildInvokeSuper(
-        getter,
-        new Selector.getter(getter.memberName),
-        const <ir.Primitive>[],
-        sourceInformation);
+    return _buildInvokeSuper(getter, new Selector.getter(getter.memberName),
+        const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create an setter invocation of the [setter] on the super class with
   /// [value].
-  ir.Primitive buildSuperSetterSet(MethodElement setter,
-                                   ir.Primitive value,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive buildSuperSetterSet(MethodElement setter, ir.Primitive value,
+      SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
-    _buildInvokeSuper(
-        setter,
-        new Selector.setter(setter.memberName),
-        <ir.Primitive>[value],
-        sourceInformation);
+    _buildInvokeSuper(setter, new Selector.setter(setter.memberName),
+        <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create an invocation of the index [method] on the super class with
   /// the provided [index].
-  ir.Primitive buildSuperIndex(MethodElement method,
-                               ir.Primitive index,
-                               SourceInformation sourceInformation) {
+  ir.Primitive buildSuperIndex(MethodElement method, ir.Primitive index,
+      SourceInformation sourceInformation) {
     return _buildInvokeSuper(
-        method, new Selector.index(), <ir.Primitive>[index],
-        sourceInformation);
+        method, new Selector.index(), <ir.Primitive>[index], sourceInformation);
   }
 
   /// Create an invocation of the index set [method] on the super class with
   /// the provided [index] and [value].
-  ir.Primitive buildSuperIndexSet(MethodElement method,
-                                  ir.Primitive index,
-                                  ir.Primitive value,
-                                  SourceInformation sourceInformation) {
+  ir.Primitive buildSuperIndexSet(MethodElement method, ir.Primitive index,
+      ir.Primitive value, SourceInformation sourceInformation) {
     _buildInvokeSuper(method, new Selector.indexSet(),
         <ir.Primitive>[index, value], sourceInformation);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
-  ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
-                                      Selector selector,
-                                      TypeMask mask,
-                                      List<ir.Primitive> arguments,
-                                      SourceInformation sourceInformation) {
+  ir.Primitive buildDynamicInvocation(
+      ir.Primitive receiver,
+      Selector selector,
+      TypeMask mask,
+      List<ir.Primitive> arguments,
+      SourceInformation sourceInformation) {
     return _buildInvokeDynamic(
         receiver, selector, mask, arguments, sourceInformation);
   }
 
   /// Create a dynamic getter invocation on [receiver] where the getter name is
   /// defined by [selector].
-  ir.Primitive buildDynamicGet(ir.Primitive receiver,
-                               Selector selector,
-                               TypeMask mask,
-                               SourceInformation sourceInformation) {
+  ir.Primitive buildDynamicGet(ir.Primitive receiver, Selector selector,
+      TypeMask mask, SourceInformation sourceInformation) {
     assert(selector.isGetter);
     FieldElement field = program.locateSingleField(selector, mask);
     if (field != null) {
       // If the world says this resolves to a unique field, then it MUST be
       // treated as a field access, since the getter might not be emitted.
       return buildFieldGet(receiver, field, sourceInformation);
     } else {
       return _buildInvokeDynamic(
           receiver, selector, mask, const <ir.Primitive>[], sourceInformation);
     }
   }
 
   /// Create a dynamic setter invocation on [receiver] where the setter name and
   /// argument are defined by [selector] and [value], respectively.
-  ir.Primitive buildDynamicSet(ir.Primitive receiver,
-                               Selector selector,
-                               TypeMask mask,
-                               ir.Primitive value,
-                               SourceInformation sourceInformation) {
+  ir.Primitive buildDynamicSet(ir.Primitive receiver, Selector selector,
+      TypeMask mask, ir.Primitive value, SourceInformation sourceInformation) {
     assert(selector.isSetter);
     FieldElement field = program.locateSingleField(selector, mask);
     if (field != null) {
       // If the world says this resolves to a unique field, then it MUST be
       // treated as a field access, since the setter might not be emitted.
       buildFieldSet(receiver, field, value, sourceInformation);
     } else {
-      _buildInvokeDynamic(receiver, selector, mask, <ir.Primitive>[value],
-                          sourceInformation);
+      _buildInvokeDynamic(
+          receiver, selector, mask, <ir.Primitive>[value], sourceInformation);
     }
     return value;
   }
 
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
-  ir.Primitive buildDynamicIndexSet(ir.Primitive receiver,
-                                    TypeMask mask,
-                                    ir.Primitive index,
-                                    ir.Primitive value,
-                                    SourceInformation sourceInformation) {
-    _buildInvokeDynamic(
-        receiver, new Selector.indexSet(), mask, <ir.Primitive>[index, value],
-        sourceInformation);
+  ir.Primitive buildDynamicIndexSet(
+      ir.Primitive receiver,
+      TypeMask mask,
+      ir.Primitive index,
+      ir.Primitive value,
+      SourceInformation sourceInformation) {
+    _buildInvokeDynamic(receiver, new Selector.indexSet(), mask,
+        <ir.Primitive>[index, value], sourceInformation);
     return value;
   }
 
   /// Create an invocation of the local [function] where argument structure is
   /// defined by [callStructure] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildLocalFunctionInvocation(
       LocalFunctionElement function,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
-        buildLocalGet(function), callStructure, arguments,
-        sourceInformation);
+        buildLocalGet(function), callStructure, arguments, sourceInformation);
   }
 
   /// Create a static invocation of [function].
   ///
   /// The arguments are not named and their values are defined by [arguments].
-  ir.Primitive buildStaticFunctionInvocation(
-      MethodElement function,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildStaticFunctionInvocation(MethodElement function,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     Selector selector = new Selector.call(
         function.memberName, new CallStructure(arguments.length));
     return buildInvokeStatic(function, selector, arguments, sourceInformation);
   }
 
   /// Create a getter invocation of the static [getter].
-  ir.Primitive buildStaticGetterGet(MethodElement getter,
-                                    SourceInformation sourceInformation) {
+  ir.Primitive buildStaticGetterGet(
+      MethodElement getter, SourceInformation sourceInformation) {
     Selector selector = new Selector.getter(getter.memberName);
     return buildInvokeStatic(
         getter, selector, const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a write access to the static [field] with the [value].
-  ir.Primitive buildStaticFieldSet(FieldElement field,
-                                   ir.Primitive value,
-                                   SourceInformation sourceInformation) {
+  ir.Primitive buildStaticFieldSet(FieldElement field, ir.Primitive value,
+      SourceInformation sourceInformation) {
     addPrimitive(new ir.SetStatic(field, value, sourceInformation));
     return value;
   }
 
   /// Create a setter invocation of the static [setter] with the [value].
-  ir.Primitive buildStaticSetterSet(MethodElement setter,
-                                    ir.Primitive value,
-                                    SourceInformation sourceInformation) {
+  ir.Primitive buildStaticSetterSet(MethodElement setter, ir.Primitive value,
+      SourceInformation sourceInformation) {
     Selector selector = new Selector.setter(setter.memberName);
     buildInvokeStatic(
         setter, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create an erroneous invocation where argument structure is defined by
   /// [selector] and the argument values are defined by [arguments].
   // TODO(johnniwinther): Make this more fine-grained.
-  ir.Primitive buildErroneousInvocation(
-      Element element,
-      Selector selector,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildErroneousInvocation(Element element, Selector selector,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
     return buildInvokeStatic(element, selector, arguments, sourceInformation);
   }
 
   /// Concatenate string values.  The arguments must be strings.
-  ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments,
-                                        SourceInformation sourceInformation) {
+  ir.Primitive buildStringConcatenation(
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     assert(isOpen);
     return addPrimitive(new ir.ApplyBuiltinOperator(
-        ir.BuiltinOperator.StringConcatenate,
-        arguments,
-        sourceInformation));
+        ir.BuiltinOperator.StringConcatenate, arguments, sourceInformation));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the structure of arguments are given by [callStructure].
   // TODO(johnniwinther): This should take a [TypeMask].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
       CallStructure callStructure,
       List<ir.Definition> arguments,
       SourceInformation sourceInformation) {
     return _buildInvokeCall(
         functionExpression, callStructure, null, arguments, sourceInformation);
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
-  void buildIf(ir.Primitive condition,
-               void buildThenPart(IrBuilder builder),
-               void buildElsePart(IrBuilder builder),
-               SourceInformation sourceInformation) {
+  void buildIf(
+      ir.Primitive condition,
+      void buildThenPart(IrBuilder builder),
+      void buildElsePart(IrBuilder builder),
+      SourceInformation sourceInformation) {
     assert(isOpen);
 
     // The then and else parts are delimited.
     IrBuilder thenBuilder = makeDelimitedBuilder();
     IrBuilder elseBuilder = makeDelimitedBuilder();
     buildThenPart(thenBuilder);
     buildElsePart(elseBuilder);
 
     // Build the term
     // (Result =) let cont then() = [[thenPart]]
     //                 and else() = [[elsePart]]
     //            in
     //              if condition (then, else)
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
     // If exactly one of the then and else continuation bodies is open (i.e.,
     // the other one has an exit on all paths), then Continuation.plug expects
     // that continuation to be listed first.  Arbitrarily use [then, else]
     // order otherwise.
     List<ir.Continuation> arms = !thenBuilder.isOpen && elseBuilder.isOpen
         ? <ir.Continuation>[elseContinuation, thenContinuation]
         : <ir.Continuation>[thenContinuation, elseContinuation];
 
-    ir.Expression result =
-        new ir.LetCont.many(arms,
-            new ir.Branch.strict(condition,
-                                 thenContinuation,
-                                 elseContinuation,
-                                 sourceInformation));
+    ir.Expression result = new ir.LetCont.many(
+        arms,
+        new ir.Branch.strict(
+            condition, thenContinuation, elseContinuation, sourceInformation));
 
-    JumpCollector join;  // Null if there is no join.
+    JumpCollector join; // Null if there is no join.
     if (thenBuilder.isOpen && elseBuilder.isOpen) {
       // There is a join-point continuation.  Build the term
       // 'let cont join(x, ...) = [] in Result' and plug invocations of the
       // join-point continuation into the then and else continuations.
       join = new ForwardJumpCollector(environment);
       thenBuilder.jumpTo(join);
       elseBuilder.jumpTo(join);
       result = new ir.LetCont(join.continuation, result);
     }
 
@@ skipping 24 matching lines @@
     }
   }
 
   void jumpTo(JumpCollector collector,
       [ir.Primitive value, SourceInformation sourceInformation]) {
     collector.addJump(this, value, sourceInformation);
   }
 
   void addRecursiveContinuation(BackwardJumpCollector collector) {
     assert(environment.length == collector.environment.length);
-    add(new ir.LetCont(collector.continuation,
-            new ir.InvokeContinuation(collector.continuation,
-                                      environment.index2value)));
+    add(new ir.LetCont(
+        collector.continuation,
+        new ir.InvokeContinuation(
+            collector.continuation, environment.index2value)));
     environment = collector.environment;
   }
 
   /// Creates a for loop in which the initializer, condition, body, update are
   /// created by [buildInitializer], [buildCondition], [buildBody] and
   /// [buildUpdate], respectively.
   ///
   /// The jump [target] is used to identify which `break` and `continue`
   /// statements that have this `for` statement as their target.
   ///
   /// The [closureScope] identifies variables that should be boxed in this loop.
   /// This includes variables declared inside the body of the loop as well as
   /// in the for-loop initializer.
   ///
   /// [loopVariables] is the list of variables declared in the for-loop
   /// initializer.
-  void buildFor({SubbuildFunction buildInitializer,
-                 SubbuildFunction buildCondition,
-                 SourceInformation conditionSourceInformation,
-                 SubbuildFunction buildBody,
-                 SubbuildFunction buildUpdate,
-                 JumpTarget target,
-                 ClosureScope closureScope,
-                 List<LocalElement> loopVariables}) {
+  void buildFor(
+      {SubbuildFunction buildInitializer,
+      SubbuildFunction buildCondition,
+      SourceInformation conditionSourceInformation,
+      SubbuildFunction buildBody,
+      SubbuildFunction buildUpdate,
+      JumpTarget target,
+      ClosureScope closureScope,
+      List<LocalElement> loopVariables}) {
     assert(isOpen);
 
     // For loops use four named continuations: the entry to the condition,
     // the entry to the body, the loop exit, and the loop successor (break).
     // The CPS translation of
     // [[for (initializer; condition; update) body; successor]] is:
     //
     // _enterForLoopInitializer();
     // [[initializer]];
     // let cont loop(x, ...) =
@@ skipping 62 matching lines @@
       updateBuilder = makeDelimitedBuilder(continueCollector.environment);
     } else {
       updateBuilder = innerBodyBuilder;
     }
     updateBuilder._enterForLoopUpdate(closureScope, loopVariables);
     buildUpdate(updateBuilder);
     if (updateBuilder.isOpen) updateBuilder.jumpTo(loop);
     // Connect the inner and outer body builders.  This is done only after
     // it is guaranteed that the updateBuilder has a non-empty term.
     if (hasContinues) {
-      outerBodyBuilder.add(new ir.LetCont(continueCollector.continuation,
-          innerBodyBuilder.root));
+      outerBodyBuilder.add(new ir.LetCont(
+          continueCollector.continuation, innerBodyBuilder.root));
       continueCollector.continuation.body = updateBuilder.root;
     } else {
       outerBodyBuilder.add(innerBodyBuilder.root);
     }
 
     // Create loop exit and body entry continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = outerBodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
-    ir.LetCont branch =
-        new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch.strict(condition,
-                                 bodyContinuation,
-                                 exitContinuation,
-                                 conditionSourceInformation));
+    ir.LetCont branch = new ir.LetCont.two(
+        exitContinuation,
+        bodyContinuation,
+        new ir.Branch.strict(condition, bodyContinuation, exitContinuation,
+            conditionSourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
@@ skipping 13 matching lines @@
   ///        creates its declaration and [variableElement] is the element for
   ///        the declared variable,
   ///     2) `v` is predeclared statically known variable, that is top-level,
   ///        static, or local variable, in which case [variableElement] is the
   ///        variable element, and [variableSelector] defines its write access,
   ///     3) `v` is an instance variable in which case [variableSelector]
   ///        defines its write access.
   /// [buildBody] creates the body, `b`, of the loop. The jump [target] is used
   /// to identify which `break` and `continue` statements that have this for-in
   /// statement as their target.
-  void buildForIn({SubbuildFunction buildExpression,
-                   SubbuildFunction buildVariableDeclaration,
-                   Element variableElement,
-                   Selector variableSelector,
-                   TypeMask variableMask,
-                   SourceInformation variableSetSourceInformation,
-                   TypeMask currentMask,
-                   SourceInformation currentSourceInformation,
-                   TypeMask iteratorMask,
-                   SourceInformation iteratorSourceInformation,
-                   TypeMask moveNextMask,
-                   SourceInformation moveNextSourceInformation,
-                   SubbuildFunction buildBody,
-                   JumpTarget target,
-                   ClosureScope closureScope,
-                   SourceInformation conditionSourceInformation}) {
+  void buildForIn(
+      {SubbuildFunction buildExpression,
+      SubbuildFunction buildVariableDeclaration,
+      Element variableElement,
+      Selector variableSelector,
+      TypeMask variableMask,
+      SourceInformation variableSetSourceInformation,
+      TypeMask currentMask,
+      SourceInformation currentSourceInformation,
+      TypeMask iteratorMask,
+      SourceInformation iteratorSourceInformation,
+      TypeMask moveNextMask,
+      SourceInformation moveNextSourceInformation,
+      SubbuildFunction buildBody,
+      JumpTarget target,
+      ClosureScope closureScope,
+      SourceInformation conditionSourceInformation}) {
     // The for-in loop
     //
     // for (a in e) s;
     //
     // Is compiled analogously to:
     //
     // it = e.iterator;
     // while (it.moveNext()) {
     //   var a = it.current;
     //   s;
     // }
 
     // Fill the current hole with:
     // let prim expressionReceiver = [[e]] in
     // let cont iteratorInvoked(iterator) =
     //     [ ]
     // in expressionReceiver.iterator () iteratorInvoked
     ir.Primitive expressionReceiver = buildExpression(this);
     List<ir.Primitive> emptyArguments = <ir.Primitive>[];
-    ir.Primitive iterator = addPrimitive(
-        new ir.InvokeMethod(expressionReceiver,
-            Selectors.iterator,
-            iteratorMask,
-            emptyArguments));
+    ir.Primitive iterator = addPrimitive(new ir.InvokeMethod(
+        expressionReceiver, Selectors.iterator, iteratorMask, emptyArguments));
 
     // Fill with:
     // let cont loop(x, ...) =
     //     let cont moveNextInvoked(condition) =
     //         [ ]
     //     in iterator.moveNext () moveNextInvoked
     // in loop(v, ...)
     JumpCollector loop = new BackwardJumpCollector(environment, target: target);
     addRecursiveContinuation(loop);
-    ir.Primitive condition = addPrimitive(
-        new ir.InvokeMethod(iterator,
-            Selectors.moveNext,
-            moveNextMask,
-            emptyArguments));
+    ir.Primitive condition = addPrimitive(new ir.InvokeMethod(
+        iterator, Selectors.moveNext, moveNextMask, emptyArguments));
 
     // As a delimited term, build:
     // <<BODY>> =
     //   _enterScope();
     //   [[variableDeclaration]]
     //   let cont currentInvoked(currentValue) =
     //       [[a = currentValue]];
     //       [ ]
     //   in iterator.current () currentInvoked
     IrBuilder bodyBuilder = makeDelimitedBuilder();
     bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
-    ir.Primitive currentValue = bodyBuilder.addPrimitive(
-        new ir.InvokeMethod(
-            iterator,
-            Selectors.current,
-            currentMask,
-            emptyArguments,
-            sourceInformation: currentSourceInformation));
+    ir.Primitive currentValue = bodyBuilder.addPrimitive(new ir.InvokeMethod(
+        iterator, Selectors.current, currentMask, emptyArguments,
+        sourceInformation: currentSourceInformation));
     // TODO(johnniwinther): Extract this as a provided strategy.
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalVariableSet(
-          variableElement,
-          currentValue,
-          variableSetSourceInformation);
+          variableElement, currentValue, variableSetSourceInformation);
     } else if (Elements.isError(variableElement) ||
-               Elements.isMalformed(variableElement)) {
+        Elements.isMalformed(variableElement)) {
       Selector selector = new Selector.setter(
           new Name(variableElement.name, variableElement.library));
       List<ir.Primitive> value = <ir.Primitive>[currentValue];
       // Note the comparison below.  It can be the case that an element isError
       // and isMalformed.
       if (Elements.isError(variableElement)) {
-        bodyBuilder.buildStaticNoSuchMethod(selector, value,
-            variableSetSourceInformation);
+        bodyBuilder.buildStaticNoSuchMethod(
+            selector, value, variableSetSourceInformation);
       } else {
         bodyBuilder.buildErroneousInvocation(
             variableElement, selector, value, variableSetSourceInformation);
       }
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       if (variableElement.isField) {
-        bodyBuilder.addPrimitive(
-            new ir.SetStatic(
-                variableElement, currentValue, variableSetSourceInformation));
+        bodyBuilder.addPrimitive(new ir.SetStatic(
+            variableElement, currentValue, variableSetSourceInformation));
       } else {
         bodyBuilder.buildStaticSetterSet(
             variableElement, currentValue, variableSetSourceInformation);
       }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
-      bodyBuilder.buildDynamicSet(
-          receiver, variableSelector, variableMask, currentValue,
-          variableSetSourceInformation);
+      bodyBuilder.buildDynamicSet(receiver, variableSelector, variableMask,
+          currentValue, variableSetSourceInformation);
     }
 
     // Translate the body in the hole in the delimited term above, and add
     // a jump to the loop if control flow is live after the body.
     JumpCollector breakCollector =
         new ForwardJumpCollector(environment, target: target);
     state.breakCollectors.add(breakCollector);
     state.continueCollectors.add(loop);
     buildBody(bodyBuilder);
     assert(state.breakCollectors.last == breakCollector);
     assert(state.continueCollectors.last == loop);
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
     if (bodyBuilder.isOpen) bodyBuilder.jumpTo(loop);
 
     // Create body entry and loop exit continuations and a branch to them.
     //
     // let cont exit() = [ ]
     //      and body() = <<BODY>>
     // in branch condition (body, exit)
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
-    ir.LetCont branch =
-        new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch.strict(condition,
-                                 bodyContinuation,
-                                 exitContinuation,
-                                 conditionSourceInformation));
+    ir.LetCont branch = new ir.LetCont.two(
+        exitContinuation,
+        bodyContinuation,
+        new ir.Branch.strict(condition, bodyContinuation, exitContinuation,
+            conditionSourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
   /// Creates a while loop in which the condition and body are created by
   /// [buildCondition] and [buildBody], respectively.
   ///
   /// The jump [target] is used to identify which `break` and `continue`
   /// statements that have this `while` statement as their target.
-  void buildWhile({SubbuildFunction buildCondition,
-                   SubbuildFunction buildBody,
-                   JumpTarget target,
-                   ClosureScope closureScope,
-                   SourceInformation sourceInformation}) {
+  void buildWhile(
+      {SubbuildFunction buildCondition,
+      SubbuildFunction buildBody,
+      JumpTarget target,
+      ClosureScope closureScope,
+      SourceInformation sourceInformation}) {
     assert(isOpen);
     // While loops use four named continuations: the entry to the body, the
     // loop exit, the loop back edge (continue), and the loop exit (break).
     // The CPS translation of [[while (condition) body; successor]] is:
     //
     // let cont continue(x, ...) =
     //     let prim cond = [[condition]] in
     //     let cont break(x, ...) = [[successor]] in
     //     let cont exit() = break(v, ...)
     //          and body() =
@@ skipping 24 matching lines @@
     state.breakCollectors.removeLast();
     state.continueCollectors.removeLast();
     if (bodyBuilder.isOpen) bodyBuilder.jumpTo(loop);
 
     // Create body entry and loop exit continuations and a branch to them.
     ir.Continuation exitContinuation = new ir.Continuation([]);
     ir.Continuation bodyContinuation = new ir.Continuation([]);
     bodyContinuation.body = bodyBuilder.root;
     // Note the order of continuations: the first one is the one that will
     // be filled by LetCont.plug.
-    ir.LetCont branch =
-        new ir.LetCont.two(exitContinuation, bodyContinuation,
-            new ir.Branch.strict(condition,
-                                 bodyContinuation,
-                                 exitContinuation,
-                                 sourceInformation));
+    ir.LetCont branch = new ir.LetCont.two(
+        exitContinuation,
+        bodyContinuation,
+        new ir.Branch.strict(
+            condition, bodyContinuation, exitContinuation, sourceInformation));
     // If there are breaks in the body, then there must be a join-point
     // continuation for the normal exit and the breaks.  Otherwise, the
     // successor is translated in the hole in the exit continuation.
     bool hasBreaks = !breakCollector.isEmpty;
     ir.LetCont letBreak;
     if (hasBreaks) {
       IrBuilder exitBuilder = makeDelimitedBuilder();
       exitBuilder.jumpTo(breakCollector);
       exitContinuation.body = exitBuilder.root;
       letBreak = new ir.LetCont(breakCollector.continuation, branch);
       add(letBreak);
       environment = breakCollector.environment;
     } else {
       add(branch);
     }
   }
 
-
   /// Creates a do-while loop.
   ///
   /// The body and condition are created by [buildBody] and [buildCondition].
   /// The jump target [target] is the target of `break` and `continue`
   /// statements in the body that have the loop as their target.
   /// [closureScope] contains all the variables declared in the loop (but not
   /// declared in some inner closure scope).
-  void buildDoWhile({SubbuildFunction buildBody,
-                     SubbuildFunction buildCondition,
-                     JumpTarget target,
-                     ClosureScope closureScope,
-                     SourceInformation sourceInformation}) {
+  void buildDoWhile(
+      {SubbuildFunction buildBody,
+      SubbuildFunction buildCondition,
+      JumpTarget target,
+      ClosureScope closureScope,
+      SourceInformation sourceInformation}) {
     assert(isOpen);
     // The CPS translation of [[do body; while (condition); successor]] is:
     //
     // let cont break(x, ...) = [[successor]] in
     // let cont rec loop(x, ...) =
     //   let cont continue(x, ...) =
     //     let prim cond = [[condition]] in
     //       let cont exit() = break(v, ...)
     //            and repeat() = loop(v, ...)
     //       in branch cond (repeat, exit)
@@ skipping 32 matching lines @@
 
     ir.Continuation exitContinuation = new ir.Continuation([]);
     IrBuilder exitBuilder = continueBuilder.makeDelimitedBuilder();
     exitBuilder.jumpTo(breakCollector);
     exitContinuation.body = exitBuilder.root;
     ir.Continuation repeatContinuation = new ir.Continuation([]);
     IrBuilder repeatBuilder = continueBuilder.makeDelimitedBuilder();
     repeatBuilder.jumpTo(loop);
     repeatContinuation.body = repeatBuilder.root;
 
-    continueBuilder.add(
-        new ir.LetCont.two(exitContinuation, repeatContinuation,
-            new ir.Branch.strict(condition,
-                                 repeatContinuation,
-                                 exitContinuation,
-                                 sourceInformation)));
+    continueBuilder.add(new ir.LetCont.two(
+        exitContinuation,
+        repeatContinuation,
+        new ir.Branch.strict(condition, repeatContinuation, exitContinuation,
+            sourceInformation)));
     continueCollector.continuation.body = continueBuilder.root;
 
     // Construct the loop continuation (i.e., the body and condition).
     // <Loop> =
     // let cont continue(x, ...) =
     //   <Continue>
     // in [[body]]; continue(v, ...)
-    loopBuilder.add(
-        new ir.LetCont(continueCollector.continuation,
-            bodyBuilder.root));
+    loopBuilder
+        .add(new ir.LetCont(continueCollector.continuation, bodyBuilder.root));
 
     // And tie it all together.
     add(new ir.LetCont(breakCollector.continuation, loopBuilder.root));
     environment = breakCollector.environment;
   }
 
-  void buildSimpleSwitch(JumpCollector join,
-                         List<SwitchCaseInfo> cases,
-                         SubbuildFunction buildDefaultBody) {
+  void buildSimpleSwitch(JumpCollector join, List<SwitchCaseInfo> cases,
+      SubbuildFunction buildDefaultBody) {
     IrBuilder casesBuilder = makeDelimitedBuilder();
     for (SwitchCaseInfo caseInfo in cases) {
       ir.Primitive condition = caseInfo.buildCondition(casesBuilder);
       IrBuilder thenBuilder = makeDelimitedBuilder();
       caseInfo.buildBody(thenBuilder);
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = thenBuilder.root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
       // A LetCont.two term has a hole as the body of the first listed
       // continuation, to be plugged by the translation.  Therefore put the
       // else continuation first.
-      casesBuilder.add(
-          new ir.LetCont.two(elseContinuation, thenContinuation,
-              new ir.Branch.strict(condition,
-                                   thenContinuation,
-                                   elseContinuation,
-                                   caseInfo.sourceInformation)));
+      casesBuilder.add(new ir.LetCont.two(
+          elseContinuation,
+          thenContinuation,
+          new ir.Branch.strict(condition, thenContinuation, elseContinuation,
+              caseInfo.sourceInformation)));
     }
 
     if (buildDefaultBody == null) {
       casesBuilder.jumpTo(join);
     } else {
       buildDefaultBody(casesBuilder);
     }
 
     if (!join.isEmpty) {
       add(new ir.LetCont(join.continuation, casesBuilder.root));
@@ skipping 11 matching lines @@
   ///
   /// The translation treats try/finally and try/catch/finally as if they
   /// were macro-expanded into try/catch.  This utility function generates
   /// that try/catch.  The function is parameterized over a list of variables
   /// that should be boxed on entry to the try, and over functions to emit
   /// code for entering the try, building the try body, leaving the try body,
   /// building the catch body, and leaving the entire try/catch.
   ///
   /// Please see the function's implementation for where these functions are
   /// called.
-  void _helpBuildTryCatch(TryStatementInfo variables,
+  void _helpBuildTryCatch(
+      TryStatementInfo variables,
       void enterTry(IrBuilder builder),
       SubbuildFunction buildTryBlock,
       void leaveTry(IrBuilder builder),
       List<ir.Parameter> buildCatch(IrBuilder builder, JumpCollector join),
-      void leaveTryCatch(IrBuilder builder, JumpCollector join,
-          ir.Expression body)) {
+      void leaveTryCatch(
+          IrBuilder builder, JumpCollector join, ir.Expression body)) {
     JumpCollector join = new ForwardJumpCollector(environment);
     IrBuilder tryCatchBuilder = makeDelimitedBuilder();
 
     // Variables treated as mutable in a try are not mutable outside of it.
     // Work with a copy of the outer builder's mutable variables.
     tryCatchBuilder.mutableVariables =
         new Map<Local, ir.MutableVariable>.from(mutableVariables);
     for (LocalVariableElement variable in variables.boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
       ir.Primitive value = tryCatchBuilder.buildLocalGet(variable);
@@ skipping 17 matching lines @@
       ir.Primitive value = catchBuilder.buildLocalGet(variable);
       // After this point, the variables that were boxed on entry to the try
       // are no longer treated as mutable.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     List<ir.Parameter> catchParameters = buildCatch(catchBuilder, join);
     ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
     catchContinuation.body = catchBuilder.root;
-    tryCatchBuilder.add(
-        new ir.LetHandler(catchContinuation, tryBuilder.root));
+    tryCatchBuilder.add(new ir.LetHandler(catchContinuation, tryBuilder.root));
 
     leaveTryCatch(this, join, tryCatchBuilder.root);
   }
 
   /// Translates a try/catch.
   ///
   /// [variables] provides information on local variables declared and boxed
   /// within the try body.
   /// [buildTryBlock] builds the try block.
   /// [catchClauseInfos] provides access to the catch type, exception variable,
   /// and stack trace variable, and a function for building the catch block.
-  void buildTryCatch(TryStatementInfo variables,
-                     SubbuildFunction buildTryBlock,
-                     List<CatchClauseInfo> catchClauseInfos) {
+  void buildTryCatch(TryStatementInfo variables, SubbuildFunction buildTryBlock,
+      List<CatchClauseInfo> catchClauseInfos) {
     assert(isOpen);
     // Catch handlers are in scope for their body.  The CPS translation of
     // [[try tryBlock catch (ex, st) catchBlock; successor]] is:
     //
     // let cont join(v0, v1, ...) = [[successor]] in
     //   let mutable m0 = x0 in
     //     let mutable m1 = x1 in
     //       ...
     //       let handler catch_(ex, st) =
     //         let prim p0 = GetMutable(m0) in
@@ skipping 33 matching lines @@
       // On exit from try of try/catch, update the builder's state to reflect
       // the variables that are no longer boxed.
       void restoreJump(JumpCollector collector) {
         collector.leaveTry();
       }
       builder.state.breakCollectors.forEach(restoreJump);
       builder.state.continueCollectors.forEach(restoreJump);
       restoreJump(builder.state.returnCollector);
     }
 
-    List<ir.Parameter> buildCatch(IrBuilder builder,
-                                  JumpCollector join) {
+    List<ir.Parameter> buildCatch(IrBuilder builder, JumpCollector join) {
       // Translate the catch clauses.  Multiple clauses are translated as if
       // they were explicitly cascaded if/else type tests.
 
       // Handlers are always translated as having both exception and stack trace
       // parameters.  Multiple clauses do not have to use the same names for
       // them.  Choose the first of each as the name hint for the respective
       // handler parameter.
       ir.Parameter exceptionParameter =
           new ir.Parameter(catchClauseInfos.first.exceptionVariable);
       LocalVariableElement traceVariable;
@@ skipping 21 matching lines @@
           clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
               initialValue: traceParameter);
         }
         clause.buildCatchBlock(clauseBuilder);
         if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
         return clauseBuilder.root;
       }
 
       // Expand multiple catch clauses into an explicit if/then/else.  Iterate
       // them in reverse so the current block becomes the next else block.
-      ir.Expression catchBody = (catchAll == null)
-          ? new ir.Rethrow()
-          : buildCatchClause(catchAll);
+      ir.Expression catchBody =
+          (catchAll == null) ? new ir.Rethrow() : buildCatchClause(catchAll);
       for (CatchClauseInfo clause in catchClauseInfos.reversed) {
         ir.Continuation thenContinuation = new ir.Continuation([]);
         ir.Continuation elseContinuation = new ir.Continuation([]);
         thenContinuation.body = buildCatchClause(clause);
         elseContinuation.body = catchBody;
 
         // Build the type test guarding this clause. We can share the
         // environment with the nested builder because this part cannot mutate
         // it.
         IrBuilder checkBuilder = builder.makeDelimitedBuilder(environment);
-        ir.Primitive typeMatches =
-            checkBuilder.buildTypeOperator(exceptionParameter,
-                clause.type,
-                clause.sourceInformation,
-                isTypeTest: true);
-        checkBuilder.add(new ir.LetCont.two(thenContinuation, elseContinuation,
-            new ir.Branch.strict(typeMatches,
-                                 thenContinuation,
-                                 elseContinuation,
-                                 clause.sourceInformation)));
+        ir.Primitive typeMatches = checkBuilder.buildTypeOperator(
+            exceptionParameter, clause.type, clause.sourceInformation,
+            isTypeTest: true);
+        checkBuilder.add(new ir.LetCont.two(
+            thenContinuation,
+            elseContinuation,
+            new ir.Branch.strict(typeMatches, thenContinuation,
+                elseContinuation, clause.sourceInformation)));
         catchBody = checkBuilder.root;
       }
       builder.add(catchBody);
 
       return <ir.Parameter>[exceptionParameter, traceParameter];
     }
 
-    void leaveTryCatch(IrBuilder builder, JumpCollector join,
-                       ir.Expression body) {
+    void leaveTryCatch(
+        IrBuilder builder, JumpCollector join, ir.Expression body) {
       // Add the binding for the join-point continuation and continue the
       // translation in its body.
       builder.add(new ir.LetCont(join.continuation, body));
       builder.environment = join.environment;
     }
 
-    _helpBuildTryCatch(variables, enterTry, buildTryBlock, leaveTry,
-        buildCatch, leaveTryCatch);
+    _helpBuildTryCatch(variables, enterTry, buildTryBlock, leaveTry, buildCatch,
+        leaveTryCatch);
   }
 
   /// Translates a try/finally.
   ///
   /// [variables] provides information on local variables declared and boxed
   /// within the try body.
   /// [buildTryBlock] builds the try block.
   /// [buildFinallyBlock] builds the finally block.
   void buildTryFinally(TryStatementInfo variables,
-                       SubbuildFunction buildTryBlock,
-                       SubbuildFunction buildFinallyBlock) {
+      SubbuildFunction buildTryBlock, SubbuildFunction buildFinallyBlock) {
     assert(isOpen);
     // Try/finally is implemented in terms of try/catch and by duplicating the
     // code for finally at all exits.  The encoding is:
     //
     // try tryBlock finally finallyBlock
     // ==>
     // try tryBlock catch (ex, st) { finallyBlock; rethrow } finallyBlock
     //
     // Where in tryBlock, all of the break, continue, and return exits are
     // translated as jumps to continuations (bound outside the catch handler)
@@ skipping 10 matching lines @@
       JumpCollector interceptJump(JumpCollector collector) {
         JumpCollector result =
             new ForwardJumpCollector(environment, target: collector.target);
         result.enterTry(variables.boxedOnEntry);
         return result;
       }
       savedBreaks = builder.state.breakCollectors;
       savedContinues = builder.state.continueCollectors;
       savedReturn = builder.state.returnCollector;
 
-      builder.state.breakCollectors = newBreaks =
-          savedBreaks.map(interceptJump).toList();
-      builder.state.continueCollectors = newContinues =
-          savedContinues.map(interceptJump).toList();
+      builder.state.breakCollectors =
+          newBreaks = savedBreaks.map(interceptJump).toList();
+      builder.state.continueCollectors =
+          newContinues = savedContinues.map(interceptJump).toList();
       builder.state.returnCollector = newReturn =
           new ForwardJumpCollector(environment, hasExtraArgument: true)
-              ..enterTry(variables.boxedOnEntry);
+            ..enterTry(variables.boxedOnEntry);
     }
 
     void leaveTry(IrBuilder builder) {
       // On exit from the try of try/finally, update the builder's state to
       // reflect the variables that are no longer boxed and restore the
       // original, unintercepted break, continue, and return targets.
       void restoreJump(JumpCollector collector) {
         collector.leaveTry();
       }
       newBreaks.forEach(restoreJump);
       newContinues.forEach(restoreJump);
       newReturn.leaveTry();
       builder.state.breakCollectors = savedBreaks;
       builder.state.continueCollectors = savedContinues;
       builder.state.returnCollector = savedReturn;
     }
 
-    List<ir.Parameter> buildCatch(IrBuilder builder,
-                                  JumpCollector join) {
+    List<ir.Parameter> buildCatch(IrBuilder builder, JumpCollector join) {
       // The catch block of the try/catch used for try/finally is the finally
       // code followed by a rethrow.
       buildFinallyBlock(builder);
       if (builder.isOpen) {
         builder.add(new ir.Rethrow());
         builder._current = null;
       }
       return <ir.Parameter>[new ir.Parameter(null), new ir.Parameter(null)];
     }
 
-    void leaveTryCatch(IrBuilder builder, JumpCollector join,
-                       ir.Expression body) {
+    void leaveTryCatch(
+        IrBuilder builder, JumpCollector join, ir.Expression body) {
       // Build a list of continuations for jumps from the try block and
       // duplicate the finally code before jumping to the actual target.
       List<ir.Continuation> exits = <ir.Continuation>[join.continuation];
-      void addJump(JumpCollector newCollector,
-                   JumpCollector originalCollector) {
+      void addJump(
+          JumpCollector newCollector, JumpCollector originalCollector) {
         if (newCollector.isEmpty) return;
         IrBuilder builder = makeDelimitedBuilder(newCollector.environment);
         buildFinallyBlock(builder);
         if (builder.isOpen) builder.jumpTo(originalCollector);
         newCollector.continuation.body = builder.root;
         exits.add(newCollector.continuation);
       }
       for (int i = 0; i < newBreaks.length; ++i) {
         addJump(newBreaks[i], savedBreaks[i]);
       }
       for (int i = 0; i < newContinues.length; ++i) {
         addJump(newContinues[i], savedContinues[i]);
       }
       if (!newReturn.isEmpty) {
         IrBuilder builder = makeDelimitedBuilder(newReturn.environment);
         ir.Primitive value = builder.environment.discard(1);
         buildFinallyBlock(builder);
         if (builder.isOpen) builder.buildReturn(value: value);
         newReturn.continuation.body = builder.root;
         exits.add(newReturn.continuation);
       }
       builder.add(new ir.LetCont.many(exits, body));
       builder.environment = join.environment;
       buildFinallyBlock(builder);
     }
 
-    _helpBuildTryCatch(variables, enterTry, buildTryBlock, leaveTry,
-        buildCatch, leaveTryCatch);
+    _helpBuildTryCatch(variables, enterTry, buildTryBlock, leaveTry, buildCatch,
+        leaveTryCatch);
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn({ir.Primitive value, SourceInformation sourceInformation}) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
       value = buildNullConstant();
     }
     jumpTo(state.returnCollector, value, sourceInformation);
   }
 
   /// Generate the body for a native function [function] that is annotated with
   /// an implementation in JavaScript (provided as string in [javaScriptCode]).
-  void buildNativeFunctionBody(
-      FunctionElement function,
-      String javaScriptCode,
+  void buildNativeFunctionBody(FunctionElement function, String javaScriptCode,
       SourceInformation sourceInformation) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setAllSideEffects();
     // Generate a [ForeignCode] statement from the given native code.
     buildForeignCode(
-        js.js.statementTemplateYielding(
-            new js.LiteralStatement(javaScriptCode)),
+        js.js
+            .statementTemplateYielding(new js.LiteralStatement(javaScriptCode)),
         <ir.Primitive>[],
         behavior,
         sourceInformation);
   }
 
   /// Generate the body for a native function that redirects to a native
   /// JavaScript function, getter, or setter.
   ///
   /// Generates a call to the real target, which is given by [functions]'s
   /// `fixedBackendName`, passing all parameters as arguments.  The target can
   /// be the JavaScript implementation of a function, getter, or setter.
-  void buildRedirectingNativeFunctionBody(FunctionElement function,
-                                          String name,
-                                          SourceInformation sourceInformation) {
+  void buildRedirectingNativeFunctionBody(FunctionElement function, String name,
+      SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setAllSideEffects();
     program.addNativeMethod(function);
     // Construct the access of the target element.
     String code = function.isInstanceMember ? '#.$name' : name;
     if (function.isInstanceMember) {
       arguments.add(state.thisParameter);
     }
     // Collect all parameters of the function and templates for them to be
     // inserted into the JavaScript code.
     List<String> argumentTemplates = <String>[];
     function.functionSignature.forEachParameter((ParameterElement parameter) {
       ir.Primitive input = environment.lookup(parameter);
       DartType type = program.unaliasType(parameter.type);
       if (type is FunctionType) {
         // The parameter type is a function type either directly or through
         // typedef(s).
         ir.Constant arity = buildIntegerConstant(type.computeArity());
-        input = buildStaticFunctionInvocation(
-            program.closureConverter, <ir.Primitive>[input, arity],
-            sourceInformation);
+        input = buildStaticFunctionInvocation(program.closureConverter,
+            <ir.Primitive>[input, arity], sourceInformation);
       }
       arguments.add(input);
       argumentTemplates.add('#');
     });
     // Construct the application of parameters for functions and setters.
     if (function.kind == ElementKind.FUNCTION) {
       code = "$code(${argumentTemplates.join(', ')})";
     } else if (function.kind == ElementKind.SETTER) {
       code = "$code = ${argumentTemplates.single}";
     } else {
       assert(argumentTemplates.isEmpty);
       assert(function.kind == ElementKind.GETTER);
     }
     // Generate the [ForeignCode] expression and a return statement to return
     // its value.
     ir.Primitive value = buildForeignCode(
         js.js.uncachedExpressionTemplate(code),
         arguments,
         behavior,
         sourceInformation,
         type: program.getTypeMaskForNativeFunction(function));
     buildReturn(value: value, sourceInformation: sourceInformation);
   }
 
   static _isNotNull(ir.Primitive value) =>
       !(value is ir.Constant && value.value.isNull);
 
   /// Builds a call to a resolved js-interop element.
-  ir.Primitive buildInvokeJsInteropMember(
-      FunctionElement element,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildInvokeJsInteropMember(FunctionElement element,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     program.addNativeMethod(element);
     String target = program.getJsInteropTargetPath(element);
     // Strip off trailing arguments that were not specified.
     // TODO(jacobr,sigmund): assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     var inputs = arguments.where(_isNotNull).toList();
 
     var behavior = new NativeBehavior()..sideEffects.setAllSideEffects();
-    DartType type = element.isConstructor ?
-        element.enclosingClass.thisType : element.type.returnType;
+    DartType type = element.isConstructor
+        ? element.enclosingClass.thisType
+        : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
     behavior.typesReturned.add(
         program.trustJSInteropTypeAnnotations ? type : const DynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && program.isNative(type.element)) {
       behavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
-    if (!program.trustJSInteropTypeAnnotations || type.isObject ||
+    if (!program.trustJSInteropTypeAnnotations ||
+        type.isObject ||
         type.isDynamic) {
       behavior.typesInstantiated.add(program.jsJavascriptObjectType);
     }
 
     String code;
     if (element.isGetter) {
       code = target;
     } else if (element.isSetter) {
       code = "$target = #";
     } else {
       var args = new List.filled(inputs.length, '#').join(',');
       code = element.isConstructor ? "new $target($args)" : "$target($args)";
     }
-    return buildForeignCode(js.js.parseForeignJS(code),
-        inputs, behavior, sourceInformation);
+    return buildForeignCode(
+        js.js.parseForeignJS(code), inputs, behavior, sourceInformation);
     // TODO(sigmund): should we record the source-information here?
   }
 
   /// Builds an object literal that results from invoking a factory constructor
   /// of a js-interop anonymous type.
-  ir.Primitive buildJsInteropObjectLiteral(
-      ConstructorElement constructor,
-      List<ir.Primitive> arguments,
-      SourceInformation sourceInformation) {
+  ir.Primitive buildJsInteropObjectLiteral(ConstructorElement constructor,
+      List<ir.Primitive> arguments, SourceInformation sourceInformation) {
     assert(program.isJsInteropAnonymous(constructor));
     program.addNativeMethod(constructor);
     FunctionSignature params = constructor.functionSignature;
     int i = 0;
     var filteredArguments = <ir.Primitive>[];
     var entries = new Map<String, js.Expression>();
     params.orderedForEachParameter((ParameterElement parameter) {
       // TODO(jacobr): throw if parameter names do not match names of property
       // names in the class.
-      assert (parameter.isNamed);
+      assert(parameter.isNamed);
       ir.Primitive argument = arguments[i++];
       if (_isNotNull(argument)) {
         filteredArguments.add(argument);
         entries[parameter.name] =
             new js.InterpolatedExpression(filteredArguments.length - 1);
       }
     });
     var code = new js.Template(null, js.objectLiteral(entries));
     var behavior = new NativeBehavior();
     if (program.trustJSInteropTypeAnnotations) {
@@ skipping 21 matching lines @@
   // TODO(johnniwinther): Type [nodes] as `Iterable` when `NodeList` uses
   // `List` instead of `Link`.
   void buildSequence(var nodes, BuildFunction build) {
     for (var node in nodes) {
       if (!isOpen) return;
       build(node);
     }
   }
 
   /// Creates a labeled statement
-  void buildLabeledStatement({SubbuildFunction buildBody,
-                              JumpTarget target}) {
+  void buildLabeledStatement({SubbuildFunction buildBody, JumpTarget target}) {
     JumpCollector join = new ForwardJumpCollector(environment, target: target);
     IrBuilder innerBuilder = makeDelimitedBuilder();
     innerBuilder.state.breakCollectors.add(join);
     buildBody(innerBuilder);
     innerBuilder.state.breakCollectors.removeLast();
     bool hasBreaks = !join.isEmpty;
     if (hasBreaks) {
       if (innerBuilder.isOpen) innerBuilder.jumpTo(join);
       add(new ir.LetCont(join.continuation, innerBuilder.root));
       environment = join.environment;
@@ skipping 15 matching lines @@
   }
 
   // Build(ContinueStatement L, C) = C[InvokeContinuation(...)]
   //
   // The continuation and arguments are filled in later after translating
   // the body containing the continue.
   bool buildContinue(JumpTarget target) {
     return buildJumpInternal(target, state.continueCollectors);
   }
 
-  bool buildJumpInternal(JumpTarget target,
-                         Iterable<JumpCollector> collectors) {
+  bool buildJumpInternal(
+      JumpTarget target, Iterable<JumpCollector> collectors) {
     assert(isOpen);
     for (JumpCollector collector in collectors) {
       if (target == collector.target) {
         jumpTo(collector);
         return true;
       }
     }
     return false;
   }
 
@@ skipping 12 matching lines @@
   }
 
   void buildRethrow() {
     assert(isOpen);
     add(new ir.Rethrow());
     _current = null;
   }
 
   /// Create a negation of [condition].
   ir.Primitive buildNegation(
-      ir.Primitive condition,
-      SourceInformation sourceInformation) {
+      ir.Primitive condition, SourceInformation sourceInformation) {
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
     ir.Continuation elseContinuation = new ir.Continuation([]);
 
     ir.Constant makeBoolConstant(bool value) {
       return new ir.Constant(state.constantSystem.createBool(value));
     }
 
     ir.Constant trueConstant = makeBoolConstant(true);
     ir.Constant falseConstant = makeBoolConstant(false);
 
     thenContinuation.body = new ir.LetPrim(falseConstant)
-        ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
+      ..plug(new ir.InvokeContinuation(joinContinuation, [falseConstant]));
     elseContinuation.body = new ir.LetPrim(trueConstant)
-        ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
+      ..plug(new ir.InvokeContinuation(joinContinuation, [trueConstant]));
 
-    add(new ir.LetCont(joinContinuation,
-          new ir.LetCont.two(thenContinuation, elseContinuation,
-              new ir.Branch.strict(condition,
-                                   thenContinuation,
-                                   elseContinuation,
-                                   sourceInformation))));
+    add(new ir.LetCont(
+        joinContinuation,
+        new ir.LetCont.two(
+            thenContinuation,
+            elseContinuation,
+            new ir.Branch.strict(condition, thenContinuation, elseContinuation,
+                sourceInformation))));
     return resultParameter;
   }
 
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
       SourceInformation sourceInformation,
@@ skipping 36 matching lines @@
     emptyBuilder.jumpTo(join, leftBool);
     rightTrueBuilder.jumpTo(join, rightTrue);
     rightFalseBuilder.jumpTo(join, rightFalse);
     ir.Continuation leftTrueContinuation = new ir.Continuation([]);
     ir.Continuation leftFalseContinuation = new ir.Continuation([]);
     ir.Continuation rightTrueContinuation = new ir.Continuation([]);
     ir.Continuation rightFalseContinuation = new ir.Continuation([]);
     rightTrueContinuation.body = rightTrueBuilder.root;
     rightFalseContinuation.body = rightFalseBuilder.root;
     // The right subexpression has two continuations.
-    rightBuilder.add(
-        new ir.LetCont.two(rightTrueContinuation, rightFalseContinuation,
-            new ir.Branch.strict(rightValue,
-                                 rightTrueContinuation,
-                                 rightFalseContinuation,
-                                 sourceInformation)));
+    rightBuilder.add(new ir.LetCont.two(
+        rightTrueContinuation,
+        rightFalseContinuation,
+        new ir.Branch.strict(rightValue, rightTrueContinuation,
+            rightFalseContinuation, sourceInformation)));
     // Depending on the operator, the left subexpression's continuations are
     // either the right subexpression or an invocation of the join-point
     // continuation.
     if (isLazyOr) {
       leftTrueContinuation.body = emptyBuilder.root;
       leftFalseContinuation.body = rightBuilder.root;
     } else {
       leftTrueContinuation.body = rightBuilder.root;
       leftFalseContinuation.body = emptyBuilder.root;
     }
 
-    add(new ir.LetCont(join.continuation,
-            new ir.LetCont.two(leftTrueContinuation, leftFalseContinuation,
-                new ir.Branch.strict(leftValue,
-                                     leftTrueContinuation,
-                                     leftFalseContinuation,
-                                     sourceInformation))));
+    add(new ir.LetCont(
+        join.continuation,
+        new ir.LetCont.two(
+            leftTrueContinuation,
+            leftFalseContinuation,
+            new ir.Branch.strict(leftValue, leftTrueContinuation,
+                leftFalseContinuation, sourceInformation))));
     environment = join.environment;
     return environment.discard(1);
   }
 
   ir.Primitive buildIdentical(ir.Primitive x, ir.Primitive y,
-                              {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.ApplyBuiltinOperator(
-        ir.BuiltinOperator.Identical, <ir.Primitive>[x, y],
-        sourceInformation));
+        ir.BuiltinOperator.Identical, <ir.Primitive>[x, y], sourceInformation));
   }
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
     ir.Parameter thisPrim = state.thisParameter;
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
         // Boxed variables are loaded from their box on-demand.
         state.boxedVariables[local] = location;
       } else {
         // Unboxed variables are loaded from the function object immediately.
         // This includes BoxLocals which are themselves unboxed variables.
-        environment.extend(local,
-            addPrimitive(new ir.GetField(thisPrim, location.field)));
+        environment.extend(
+            local, addPrimitive(new ir.GetField(thisPrim, location.field)));
       }
     });
 
     // If the function captures a reference to the receiver from the
     // enclosing method, remember which primitive refers to the receiver object.
     if (env.thisLocal != null && env.freeVariables.containsKey(env.thisLocal)) {
       state.enclosingThis = environment.lookup(env.thisLocal);
     }
 
     // If the function has a self-reference, use the value of `this`.
@@ skipping 32 matching lines @@
 
   /// Add the given function parameter to the IR, and bind it in the environment
   /// or put it in its box, if necessary.
   void _createFunctionParameter(Local parameterElement) {
     ir.Parameter parameter = new ir.Parameter(parameterElement);
     _parameters.add(parameter);
     state.functionParameters.add(parameter);
     ClosureLocation location = state.boxedVariables[parameterElement];
     if (location != null) {
       addPrimitive(new ir.SetField(
-          environment.lookup(location.box),
-          location.field,
-          parameter));
+          environment.lookup(location.box), location.field, parameter));
     } else {
       environment.extend(parameterElement, parameter);
     }
   }
 
   void _createThisParameter() {
     assert(state.thisParameter == null);
     if (Elements.isStaticOrTopLevel(state.currentElement)) return;
     if (state.currentElement.isLocal) return;
     state.thisParameter =
         new ir.Parameter(new ThisParameterLocal(state.currentElement));
   }
 
   void declareLocalVariable(LocalElement variableElement,
-                            {ir.Primitive initialValue}) {
+      {ir.Primitive initialValue}) {
     assert(isOpen);
     if (initialValue == null) {
       initialValue = buildNullConstant();
     }
     ClosureLocation location = state.boxedVariables[variableElement];
     if (location != null) {
       addPrimitive(new ir.SetField(
-          environment.lookup(location.box),
-          location.field,
-          initialValue));
+          environment.lookup(location.box), location.field, initialValue));
     } else if (isInMutableVariable(variableElement)) {
-      add(new ir.LetMutable(
-          getMutableVariable(variableElement),
-          initialValue));
+      add(new ir.LetMutable(getMutableVariable(variableElement), initialValue));
     } else {
       initialValue.useElementAsHint(variableElement);
       environment.extend(variableElement, initialValue);
     }
   }
 
   /// Add [functionElement] to the environment with provided [definition].
-  void declareLocalFunction(LocalFunctionElement functionElement,
-                            closure.ClosureClassElement classElement,
-                            SourceInformation sourceInformation) {
+  void declareLocalFunction(
+      LocalFunctionElement functionElement,
+      closure.ClosureClassElement classElement,
+      SourceInformation sourceInformation) {
     ir.Primitive closure =
-         buildFunctionExpression(classElement, sourceInformation);
+        buildFunctionExpression(classElement, sourceInformation);
     declareLocalVariable(functionElement, initialValue: closure);
   }
 
   ir.Primitive buildFunctionExpression(closure.ClosureClassElement classElement,
-                                       SourceInformation sourceInformation) {
+      SourceInformation sourceInformation) {
     List<ir.Primitive> arguments = <ir.Primitive>[];
     for (closure.ClosureFieldElement field in classElement.closureFields) {
       // Captured 'this' and type variables are not always available as locals
       // in the environment, so treat those specially.
       ir.Primitive value;
       if (field.local is closure.ThisLocal) {
         value = buildThis();
       } else if (field.local is closure.TypeVariableLocal) {
         closure.TypeVariableLocal variable = field.local;
         value = buildTypeVariableAccess(variable.typeVariable);
       } else {
         value = environment.lookup(field.local);
       }
       arguments.add(value);
     }
     return addPrimitive(new ir.CreateInstance(
         classElement, arguments, null, sourceInformation));
   }
 
   /// Create a read access of [local] function, variable, or parameter.
   // TODO(johnniwinther): Make [sourceInformation] mandatory.
-  ir.Primitive buildLocalGet(
-      LocalElement local,
+  ir.Primitive buildLocalGet(LocalElement local,
       {SourceInformation sourceInformation}) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(
-          environment.lookup(location.box),
-          location.field,
+          environment.lookup(location.box), location.field,
           sourceInformation: sourceInformation);
       result.useElementAsHint(local);
       return addPrimitive(result);
     } else if (isInMutableVariable(local)) {
-      return addPrimitive(
-          new ir.GetMutable(
-              getMutableVariable(local), sourceInformation: sourceInformation));
+      return addPrimitive(new ir.GetMutable(getMutableVariable(local),
+          sourceInformation: sourceInformation));
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] variable or parameter with the provided
   /// [value].
-  ir.Primitive buildLocalVariableSet(
-      LocalElement local,
-      ir.Primitive value,
+  ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value,
       SourceInformation sourceInformation) {
     assert(isOpen);
     ClosureLocation location = state.boxedVariables[local];
     if (location != null) {
       addPrimitive(new ir.SetField(
-          environment.lookup(location.box),
-          location.field,
-          value,
+          environment.lookup(location.box), location.field, value,
           sourceInformation: sourceInformation));
     } else if (isInMutableVariable(local)) {
-      addPrimitive(new ir.SetMutable(
-          getMutableVariable(local),
-          value,
+      addPrimitive(new ir.SetMutable(getMutableVariable(local), value,
           sourceInformation: sourceInformation));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   /// Called before building the initializer of a for-loop.
   ///
   /// The loop variables will subsequently be declared using
   /// [declareLocalVariable].
-  void _enterForLoopInitializer(ClosureScope scope,
-                                List<LocalElement> loopVariables) {
+  void _enterForLoopInitializer(
+      ClosureScope scope, List<LocalElement> loopVariables) {
     if (scope == null) return;
     // If there are no boxed loop variables, don't create the box here, let
     // it be created inside the body instead.
     if (scope.boxedLoopVariables.isEmpty) return;
     _enterScope(scope);
   }
 
   /// Called before building the body of a for-loop.
-  void _enterForLoopBody(ClosureScope scope,
-                         List<LocalElement> loopVariables) {
+  void _enterForLoopBody(ClosureScope scope, List<LocalElement> loopVariables) {
     if (scope == null) return;
     // If there are boxed loop variables, the box has already been created
     // at the initializer.
     if (!scope.boxedLoopVariables.isEmpty) return;
     _enterScope(scope);
   }
 
   /// Called before building the update of a for-loop.
-  void _enterForLoopUpdate(ClosureScope scope,
-                           List<LocalElement> loopVariables) {
+  void _enterForLoopUpdate(
+      ClosureScope scope, List<LocalElement> loopVariables) {
     if (scope == null) return;
     // If there are no boxed loop variables, then the box is created inside the
     // body, so there is no need to explicitly renew it.
     if (scope.boxedLoopVariables.isEmpty) return;
     ir.Primitive box = environment.lookup(scope.box);
     ir.Primitive newBox = addPrimitive(new ir.CreateBox());
     newBox.useElementAsHint(scope.box);
     for (VariableElement loopVar in scope.boxedLoopVariables) {
       ClosureLocation location = scope.capturedVariables[loopVar];
       ir.Primitive value = addPrimitive(new ir.GetField(box, location.field));
       addPrimitive(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis() {
     if (state.enclosingThis != null) return state.enclosingThis;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
-  ir.Primitive buildFieldGet(
-      ir.Primitive receiver,
-      FieldElement target,
+  ir.Primitive buildFieldGet(ir.Primitive receiver, FieldElement target,
       SourceInformation sourceInformation) {
     return addPrimitive(new ir.GetField(receiver, target,
         sourceInformation: sourceInformation,
         isFinal: program.fieldNeverChanges(target)));
   }
 
-  void buildFieldSet(ir.Primitive receiver,
-                     FieldElement target,
-                     ir.Primitive value,
-                     SourceInformation sourceInformation) {
-    addPrimitive(new ir.SetField(
-        receiver, target, value, sourceInformation: sourceInformation));
+  void buildFieldSet(ir.Primitive receiver, FieldElement target,
+      ir.Primitive value, SourceInformation sourceInformation) {
+    addPrimitive(new ir.SetField(receiver, target, value,
+        sourceInformation: sourceInformation));
   }
 
   ir.Primitive buildSuperFieldGet(
-      FieldElement target,
-      SourceInformation sourceInformation) {
-    return addPrimitive(
-        new ir.GetField(
-            buildThis(), target, sourceInformation: sourceInformation));
+      FieldElement target, SourceInformation sourceInformation) {
+    return addPrimitive(new ir.GetField(buildThis(), target,
+        sourceInformation: sourceInformation));
   }
 
-  ir.Primitive buildSuperFieldSet(
-      FieldElement target,
-      ir.Primitive value,
+  ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value,
       SourceInformation sourceInformation) {
-    addPrimitive(
-        new ir.SetField(
-            buildThis(), target, value, sourceInformation: sourceInformation));
+    addPrimitive(new ir.SetField(buildThis(), target, value,
+        sourceInformation: sourceInformation));
     return value;
   }
 
   /// Loads parameters to a constructor body into the environment.
   ///
   /// The header for a constructor body differs from other functions in that
   /// some parameters are already boxed, and the box is passed as an argument
   /// instead of being created in the header.
-  void buildConstructorBodyHeader(Iterable<Local> parameters,
-                                  ClosureScope closureScope) {
+  void buildConstructorBodyHeader(
+      Iterable<Local> parameters, ClosureScope closureScope) {
     _createThisParameter();
     for (Local param in parameters) {
       ir.Parameter parameter = _createLocalParameter(param);
       state.functionParameters.add(parameter);
     }
     if (closureScope != null) {
       state.boxedVariables.addAll(closureScope.capturedVariables);
     }
   }
 
@@ skipping 19 matching lines @@
       return buildInvokeJsInteropMember(element, arguments, sourceInformation);
     }
     if (program.requiresRuntimeTypesFor(cls)) {
       InterfaceType interface = type;
       Iterable<ir.Primitive> typeArguments =
           interface.typeArguments.map((DartType argument) {
         return type.treatAsRaw
             ? buildNullConstant()
             : buildTypeExpression(argument);
       });
-      arguments = new List<ir.Primitive>.from(arguments)
-          ..addAll(typeArguments);
+      arguments = new List<ir.Primitive>.from(arguments)..addAll(typeArguments);
     }
     return addPrimitive(new ir.InvokeConstructor(
         type, element, selector, arguments, sourceInformation,
         allocationSiteType: allocationSiteType));
   }
 
   ir.Primitive buildTypeExpression(DartType type) {
     type = program.unaliasType(type);
     if (type is TypeVariableType) {
       return buildTypeVariableAccess(type);
     } else if (type is InterfaceType || type is FunctionType) {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       type.forEachTypeVariable((TypeVariableType variable) {
         ir.Primitive value = buildTypeVariableAccess(variable);
         arguments.add(value);
       });
-      return addPrimitive(new ir.TypeExpression(ir.TypeExpressionKind.COMPLETE,
-                                                type, arguments));
+      return addPrimitive(new ir.TypeExpression(
+          ir.TypeExpressionKind.COMPLETE, type, arguments));
     } else if (type.treatAsDynamic) {
       return buildNullConstant();
     } else {
       // TypedefType can reach here, and possibly other things.
       throw 'unimplemented translation of type expression $type (${type.kind})';
     }
   }
 
   /// Obtains the internal type representation of the type held in [variable].
   ///
   /// The value of [variable] is taken from the current receiver object, or
   /// if we are currently building a constructor field initializer, from the
   /// corresponding type argument (field initializers are evaluated before the
   /// receiver object is created).
   ir.Primitive buildTypeVariableAccess(TypeVariableType variable,
-                                       {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     // If the local exists in the environment, use that.
     // This is put here when we are inside a constructor or field initializer,
     // (or possibly a closure inside one of these).
     Local local = new closure.TypeVariableLocal(variable, state.currentElement);
     if (environment.contains(local)) {
       return environment.lookup(local);
     }
 
     // If the type variable is not in a local, read its value from the
     // receiver object.
     ir.Primitive target = buildThis();
     return addPrimitive(
         new ir.ReadTypeVariable(variable, target, sourceInformation));
   }
 
   /// Make the given type variable accessible through the local environment
   /// with the value of [binding].
   void declareTypeVariable(TypeVariableType variable, DartType binding) {
     environment.extend(
         new closure.TypeVariableLocal(variable, state.currentElement),
         buildTypeExpression(binding));
   }
 
   /// Reifies the value of [variable] on the current receiver object.
-  ir.Primitive buildReifyTypeVariable(TypeVariableType variable,
-                                      SourceInformation sourceInformation) {
+  ir.Primitive buildReifyTypeVariable(
+      TypeVariableType variable, SourceInformation sourceInformation) {
     ir.Primitive typeArgument =
         buildTypeVariableAccess(variable, sourceInformation: sourceInformation);
     return addPrimitive(
         new ir.ReifyRuntimeType(typeArgument, sourceInformation));
   }
 
-  ir.Primitive buildInvocationMirror(Selector selector,
-                                     List<ir.Primitive> arguments) {
+  ir.Primitive buildInvocationMirror(
+      Selector selector, List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
 
-  ir.Primitive buildForeignCode(js.Template codeTemplate,
-                                List<ir.Primitive> arguments,
-                                NativeBehavior behavior,
-                                SourceInformation sourceInformation,
-                                {Element dependency,
-                                 TypeMask type}) {
+  ir.Primitive buildForeignCode(
+      js.Template codeTemplate,
+      List<ir.Primitive> arguments,
+      NativeBehavior behavior,
+      SourceInformation sourceInformation,
+      {Element dependency,
+      TypeMask type}) {
     assert(behavior != null);
     if (type == null) {
       type = program.getTypeMaskForForeign(behavior);
     }
     if (js.isIdentityTemplate(codeTemplate) && !program.isArrayType(type)) {
       // JS expression is just a refinement.
       // Do not do this for arrays - those are special because array types can
       // change after creation.  The input and output must therefore be modeled
       // as distinct values.
       return addPrimitive(new ir.Refinement(arguments.single, type));
     }
     ir.Primitive result = addPrimitive(new ir.ForeignCode(
-        codeTemplate,
-        type,
-        arguments,
-        behavior,
-        sourceInformation,
+        codeTemplate, type, arguments, behavior, sourceInformation,
         dependency: dependency));
     if (!codeTemplate.isExpression) {
       // Close the term if this is a "throw" expression or native body.
       add(new ir.Unreachable());
       _current = null;
     }
     return result;
   }
 
   /// Creates a type test or type cast of [value] against [type].
-  ir.Primitive buildTypeOperator(ir.Primitive value,
-                                 DartType type,
-                                 SourceInformation sourceInformation,
-                                 {bool isTypeTest}) {
+  ir.Primitive buildTypeOperator(
+      ir.Primitive value, DartType type, SourceInformation sourceInformation,
+      {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
 
     type = program.unaliasType(type);
 
     if (type.isMalformed) {
       ErroneousElement element = type.element;
       ir.Primitive message = buildStringConstant(element.message);
-      return buildStaticFunctionInvocation(
-          program.throwTypeErrorHelper,
-          <ir.Primitive>[message],
-          sourceInformation);
+      return buildStaticFunctionInvocation(program.throwTypeErrorHelper,
+          <ir.Primitive>[message], sourceInformation);
     }
 
     List<ir.Primitive> typeArguments = const <ir.Primitive>[];
     if (type is GenericType && type.typeArguments.isNotEmpty) {
       typeArguments = type.typeArguments.map(buildTypeExpression).toList();
     } else if (type is TypeVariableType) {
       typeArguments = <ir.Primitive>[buildTypeVariableAccess(type)];
     } else if (type is FunctionType) {
       typeArguments = <ir.Primitive>[buildTypeExpression(type)];
     }
@@ skipping 18 matching lines @@
         return value;
       }
       return addPrimitive(new ir.TypeCast(value, type, typeArguments));
     }
   }
 
   /// Create an if-null expression. This is equivalent to a conditional
   /// expression whose result is either [value] if [value] is not null, or
   /// `right` if [value] is null. Only when [value] is null, [buildRight] is
   /// evaluated to produce the `right` value.
-  ir.Primitive buildIfNull(ir.Primitive value,
-                           ir.Primitive buildRight(IrBuilder builder),
-                           SourceInformation sourceInformation) {
-    ir.Primitive condition =
-        _buildCheckNull(value, sourceInformation);
+  ir.Primitive buildIfNull(
+      ir.Primitive value,
+      ir.Primitive buildRight(IrBuilder builder),
+      SourceInformation sourceInformation) {
+    ir.Primitive condition = _buildCheckNull(value, sourceInformation);
     return buildConditional(
         condition, buildRight, (_) => value, sourceInformation);
   }
 
   /// Create a conditional send. This is equivalent to a conditional expression
   /// that checks if [receiver] is null, if so, it returns null, otherwise it
   /// evaluates the [buildSend] expression.
-  ir.Primitive buildIfNotNullSend(ir.Primitive receiver,
-                                  ir.Primitive buildSend(IrBuilder builder),
-                                  SourceInformation sourceInformation) {
-    ir.Primitive condition =
-        _buildCheckNull(receiver, sourceInformation);
+  ir.Primitive buildIfNotNullSend(
+      ir.Primitive receiver,
+      ir.Primitive buildSend(IrBuilder builder),
+      SourceInformation sourceInformation) {
+    ir.Primitive condition = _buildCheckNull(receiver, sourceInformation);
     return buildConditional(
         condition, (_) => receiver, buildSend, sourceInformation);
   }
 
   /// Creates a type test checking whether [value] is null.
-  ir.Primitive _buildCheckNull(ir.Primitive value,
-                               SourceInformation sourceInformation) {
+  ir.Primitive _buildCheckNull(
+      ir.Primitive value, SourceInformation sourceInformation) {
     assert(isOpen);
     return buildIdentical(value, buildNullConstant(),
         sourceInformation: sourceInformation);
   }
 }
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
@@ skipping 82 matching lines @@
       new Set<LocalVariableElement>();
 }
 
 class CatchClauseInfo {
   final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
   final SourceInformation sourceInformation;
 
-  CatchClauseInfo({this.type,
-                   this.exceptionVariable,
-                   this.stackTraceVariable,
-                   this.buildCatchBlock,
-                   this.sourceInformation});
+  CatchClauseInfo(
+      {this.type,
+      this.exceptionVariable,
+      this.stackTraceVariable,
+      this.buildCatchBlock,
+      this.sourceInformation});
 }
 
 class SwitchCaseInfo {
   final SubbuildFunction buildCondition;
   final SubbuildFunction buildBody;
   final SourceInformation sourceInformation;
 
   SwitchCaseInfo(this.buildCondition, this.buildBody, this.sourceInformation);
 }