dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library code_generator;
 
 import 'glue.dart';
 
-import '../../closure.dart' show
-    ClosureClassElement;
-import '../../common/codegen.dart' show
-    CodegenRegistry;
+import '../../closure.dart' show ClosureClassElement;
+import '../../common/codegen.dart' show CodegenRegistry;
 import '../../constants/values.dart';
 import '../../dart_types.dart';
 import '../../elements/elements.dart';
-import '../../io/source_information.dart' show
-    SourceInformation;
+import '../../io/source_information.dart' show SourceInformation;
 import '../../js/js.dart' as js;
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
-import '../../tree_ir/tree_ir_nodes.dart' show
-    BuiltinMethod,
-    BuiltinOperator,
-    isCompoundableOperator;
-import '../../types/types.dart' show
-    TypeMask;
-import '../../universe/call_structure.dart' show
-    CallStructure;
-import '../../universe/selector.dart' show
-    Selector;
-import '../../universe/use.dart' show
-    DynamicUse,
-    StaticUse,
-    TypeUse;
+import '../../tree_ir/tree_ir_nodes.dart'
+    show BuiltinMethod, BuiltinOperator, isCompoundableOperator;
+import '../../types/types.dart' show TypeMask;
+import '../../universe/call_structure.dart' show CallStructure;
+import '../../universe/selector.dart' show Selector;
+import '../../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../../util/maplet.dart';
 
 class CodegenBailout {
   final tree_ir.Node node;
   final String reason;
   CodegenBailout(this.node, this.reason);
   String get message {
     return 'bailout${node != null ? " on $node" : ""}: $reason';
   }
 }
 
 class CodeGenerator extends tree_ir.StatementVisitor
-                    with tree_ir.ExpressionVisitor<js.Expression> {
+    with tree_ir.ExpressionVisitor<js.Expression> {
   final CodegenRegistry registry;
 
   final Glue glue;
 
   ExecutableElement currentFunction;
 
   /// Maps variables to their name.
   Map<tree_ir.Variable, String> variableNames = <tree_ir.Variable, String>{};
 
   /// Maps local constants to their name.
   Maplet<VariableElement, String> constantNames =
       new Maplet<VariableElement, String>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   Set<String> usedVariableNames = new Set<String>();
 
   final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();
 
   /// Stacks whose top element is the current target of an unlabeled break
   /// or continue. For continues, this is the loop node itself.
   final tree_ir.FallthroughStack shortBreak = new tree_ir.FallthroughStack();
-  final tree_ir.FallthroughStack shortContinue =
-      new tree_ir.FallthroughStack();
+  final tree_ir.FallthroughStack shortContinue = new tree_ir.FallthroughStack();
 
   /// When the top element is true, [Unreachable] statements will be emitted
   /// as [Return]s, otherwise they are emitted as empty because they are
   /// followed by the end of the method.
   ///
   /// Note on why the [fallthrough] stack should not be used for this:
   /// Ordinary statements may choose whether to use the [fallthrough] target,
   /// and the choice to do so may disable an optimization in [visitIf].
   /// But omitting an unreachable 'return' should have lower priority than
   /// the optimizations in [visitIf], so [visitIf] will instead tell the
@@ skipping 43 matching lines @@
       if (assign.op != null) break; // Compound assignment.
       js.VariableUse use = assign.leftHandSide;
 
       // Do not touch non-local variables.
       if (!usedVariableNames.contains(use.name)) break;
 
       // We cannot declare a variable more than once.
       if (!declaredVariables.add(use.name)) break;
 
       js.VariableInitialization jsVariable = new js.VariableInitialization(
-        new js.VariableDeclaration(use.name),
-        assign.value);
+          new js.VariableDeclaration(use.name), assign.value);
       jsVariables.add(jsVariable);
 
       ++accumulatorIndex;
     }
 
     // If the last statement is a for loop with an initializer expression, try
     // to pull that expression into an initializer as well.
-    pullFromForLoop:
-    if (accumulatorIndex < accumulator.length &&
+    pullFromForLoop: if (accumulatorIndex < accumulator.length &&
         accumulator[accumulatorIndex] is js.For) {
       js.For forLoop = accumulator[accumulatorIndex];
       if (forLoop.init is! js.Assignment) break pullFromForLoop;
       js.Assignment assign = forLoop.init;
       if (assign.leftHandSide is! js.VariableUse) break pullFromForLoop;
       if (assign.op != null) break pullFromForLoop; // Compound assignment.
       js.VariableUse use = assign.leftHandSide;
 
       // Do not touch non-local variables.
       if (!usedVariableNames.contains(use.name)) break pullFromForLoop;
 
       // We cannot declare a variable more than once.
       if (!declaredVariables.add(use.name)) break pullFromForLoop;
 
       js.VariableInitialization jsVariable = new js.VariableInitialization(
-        new js.VariableDeclaration(use.name),
-        assign.value);
+          new js.VariableDeclaration(use.name), assign.value);
       jsVariables.add(jsVariable);
 
       // Remove the initializer from the for loop.
       accumulator[accumulatorIndex] =
           new js.For(null, forLoop.condition, forLoop.update, forLoop.body);
     }
 
     // Discard the statements that were pulled in the initializer.
     if (accumulatorIndex > 0) {
       accumulator = accumulator.sublist(accumulatorIndex);
     }
 
     // Declare remaining variables.
     for (tree_ir.Variable variable in variableNames.keys) {
       String name = getVariableName(variable);
       if (declaredVariables.contains(name)) continue;
-      js.VariableInitialization jsVariable = new js.VariableInitialization(
-        new js.VariableDeclaration(name),
-        null);
+      js.VariableInitialization jsVariable =
+          new js.VariableInitialization(new js.VariableDeclaration(name), null);
       jsVariables.add(jsVariable);
     }
 
     if (jsVariables.length > 0) {
       // Would be nice to avoid inserting at the beginning of list.
-      accumulator.insert(0, new js.ExpressionStatement(
-          new js.VariableDeclarationList(jsVariables)
+      accumulator.insert(
+          0,
+          new js.ExpressionStatement(new js.VariableDeclarationList(jsVariables)
               .withSourceInformation(function.sourceInformation)));
     }
     return new js.Fun(parameters, new js.Block(accumulator));
   }
 
   @override
   js.Expression visitExpression(tree_ir.Expression node) {
     js.Expression result = node.accept(this);
     if (result == null) {
       glue.reportInternalError('$node did not produce code.');
     }
     return result;
   }
 
   /// Generates a name for the given variable. First trying with the name of
   /// the [Variable.element] if it is non-null.
   String getVariableName(tree_ir.Variable variable) {
     // Functions are not nested in the JS backend.
     assert(variable.host == currentFunction);
 
     // Get the name if we already have one.
     String name = variableNames[variable];
     if (name != null) {
       return name;
     }
 
     // Synthesize a variable name that isn't used elsewhere.
     String prefix = variable.element == null ? 'v' : variable.element.name;
     int counter = 0;
-    name = glue.safeVariableName(variable.element == null
-        ? '$prefix$counter'
-        : variable.element.name);
+    name = glue.safeVariableName(
+        variable.element == null ? '$prefix$counter' : variable.element.name);
     while (!usedVariableNames.add(name)) {
       ++counter;
       name = '$prefix$counter';
     }
     variableNames[variable] = name;
 
     return name;
   }
 
   List<js.Expression> visitExpressionList(
       List<tree_ir.Expression> expressions) {
     List<js.Expression> result = new List<js.Expression>(expressions.length);
     for (int i = 0; i < expressions.length; ++i) {
       result[i] = visitExpression(expressions[i]);
     }
     return result;
   }
 
   giveup(tree_ir.Node node,
-         [String reason = 'unimplemented in CodeGenerator']) {
+      [String reason = 'unimplemented in CodeGenerator']) {
     throw new CodegenBailout(node, reason);
   }
 
   @override
   js.Expression visitConditional(tree_ir.Conditional node) {
     return new js.Conditional(
         visitExpression(node.condition),
         visitExpression(node.thenExpression),
         visitExpression(node.elseExpression));
   }
 
   js.Expression buildConstant(ConstantValue constant,
-                              {SourceInformation sourceInformation}) {
+      {SourceInformation sourceInformation}) {
     registry.registerCompileTimeConstant(constant);
-    return glue.constantReference(constant)
+    return glue
+        .constantReference(constant)
         .withSourceInformation(sourceInformation);
   }
 
   @override
   js.Expression visitConstant(tree_ir.Constant node) {
-    return buildConstant(
-        node.value,
-        sourceInformation: node.sourceInformation);
+    return buildConstant(node.value, sourceInformation: node.sourceInformation);
   }
 
-  js.Expression buildStaticInvoke(Element target,
-                                  List<js.Expression> arguments,
-                                  {SourceInformation sourceInformation}) {
+  js.Expression buildStaticInvoke(Element target, List<js.Expression> arguments,
+      {SourceInformation sourceInformation}) {
     if (target.isConstructor) {
       // TODO(johnniwinther): Avoid dependency on [isGenerativeConstructor] by
       // using backend-specific [StatisUse] classes.
-      registry.registerStaticUse(
-          new StaticUse.constructorInvoke(target.declaration,
-              new CallStructure.unnamed(arguments.length)));
+      registry.registerStaticUse(new StaticUse.constructorInvoke(
+          target.declaration, new CallStructure.unnamed(arguments.length)));
     } else {
-      registry.registerStaticUse(
-          new StaticUse.staticInvoke(target.declaration,
-              new CallStructure.unnamed(arguments.length)));
+      registry.registerStaticUse(new StaticUse.staticInvoke(
+          target.declaration, new CallStructure.unnamed(arguments.length)));
     }
     js.Expression elementAccess = glue.staticFunctionAccess(target);
     return new js.Call(elementAccess, arguments,
         sourceInformation: sourceInformation);
   }
 
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
     if (node.constant != null) return giveup(node);
 
     registry.registerInstantiation(node.type);
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
-    return buildStaticInvoke(
-        target,
-        arguments,
+    return buildStaticInvoke(target, arguments,
         sourceInformation: node.sourceInformation);
   }
 
   void registerMethodInvoke(Selector selector, TypeMask receiverType) {
     registry.registerDynamicUse(new DynamicUse(selector, receiverType));
     if (!selector.isGetter && !selector.isSetter) {
       // TODO(sigurdm): We should find a better place to register the call.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicUse(new DynamicUse(call, null));
     }
   }
 
   @override
   js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
     TypeMask mask = glue.extendMaskIfReachesAll(node.selector, node.mask);
     registerMethodInvoke(node.selector, mask);
-    return js.propertyCall(visitExpression(node.receiver),
-                           glue.invocationName(node.selector),
-                           visitExpressionList(node.arguments))
+    return js
+        .propertyCall(
+            visitExpression(node.receiver),
+            glue.invocationName(node.selector),
+            visitExpressionList(node.arguments))
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
     return buildStaticInvoke(target, arguments,
-          sourceInformation: node.sourceInformation);
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeMethodDirectly(tree_ir.InvokeMethodDirectly node) {
     if (node.isTearOff) {
       // If this is a tear-off, register the fact that a tear-off closure
       // will be created, and that this tear-off must bypass ordinary
       // dispatch to ensure the super method is invoked.
       registry.registerStaticUse(new StaticUse.staticInvoke(
-          glue.closureFromTearOff, new CallStructure.unnamed(
-            glue.closureFromTearOff.parameters.length)));
+          glue.closureFromTearOff,
+          new CallStructure.unnamed(
+              glue.closureFromTearOff.parameters.length)));
       registry.registerStaticUse(new StaticUse.superTearOff(node.target));
     }
     if (node.target is ConstructorBodyElement) {
-      registry.registerStaticUse(
-          new StaticUse.constructorBodyInvoke(
-              node.target.declaration,
-              new CallStructure.unnamed(node.arguments.length)));
+      registry.registerStaticUse(new StaticUse.constructorBodyInvoke(
+          node.target.declaration,
+          new CallStructure.unnamed(node.arguments.length)));
       // A constructor body cannot be overriden or intercepted, so we can
       // use the short form for this invocation.
-      return js.js('#.#(#)',
-          [visitExpression(node.receiver),
-           glue.instanceMethodName(node.target),
-           visitExpressionList(node.arguments)])
-          .withSourceInformation(node.sourceInformation);
+      return js.js('#.#(#)', [
+        visitExpression(node.receiver),
+        glue.instanceMethodName(node.target),
+        visitExpressionList(node.arguments)
+      ]).withSourceInformation(node.sourceInformation);
     }
-    registry.registerStaticUse(
-        new StaticUse.superInvoke(
-            node.target.declaration,
-            new CallStructure.unnamed(node.arguments.length)));
-    return js.js('#.#.call(#, #)',
-        [glue.prototypeAccess(node.target.enclosingClass),
-         glue.invocationName(node.selector),
-         visitExpression(node.receiver),
-         visitExpressionList(node.arguments)])
-        .withSourceInformation(node.sourceInformation);
+    registry.registerStaticUse(new StaticUse.superInvoke(
+        node.target.declaration,
+        new CallStructure.unnamed(node.arguments.length)));
+    return js.js('#.#.call(#, #)', [
+      glue.prototypeAccess(node.target.enclosingClass),
+      glue.invocationName(node.selector),
+      visitExpression(node.receiver),
+      visitExpressionList(node.arguments)
+    ]).withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitOneShotInterceptor(tree_ir.OneShotInterceptor node) {
     registerMethodInvoke(node.selector, node.mask);
     registry.registerUseInterceptor();
-    return js.js('#.#(#)',
-        [glue.getInterceptorLibrary(),
-         glue.registerOneShotInterceptor(node.selector),
-         visitExpressionList(node.arguments)])
-        .withSourceInformation(node.sourceInformation);
+    return js.js('#.#(#)', [
+      glue.getInterceptorLibrary(),
+      glue.registerOneShotInterceptor(node.selector),
+      visitExpressionList(node.arguments)
+    ]).withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitLiteralList(tree_ir.LiteralList node) {
     registry.registerInstantiatedClass(glue.listClass);
     List<js.Expression> entries = visitExpressionList(node.values);
     return new js.ArrayInitializer(entries);
   }
 
   @override
   js.Expression visitLogicalOperator(tree_ir.LogicalOperator node) {
     return new js.Binary(
-        node.operator,
-        visitExpression(node.left),
-        visitExpression(node.right));
+        node.operator, visitExpression(node.left), visitExpression(node.right));
   }
 
   @override
   js.Expression visitNot(tree_ir.Not node) {
     return new js.Prefix("!", visitExpression(node.operand));
   }
 
   @override
   js.Expression visitThis(tree_ir.This node) {
     return new js.This();
@@ skipping 31 matching lines @@
         if (node.isTypeTest) {
           return js.js(r'typeof # === "string"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'stringTypeCast'.
       } else if (glue.isBoolClass(clazz)) {
         if (node.isTypeTest) {
           return js.js(r'typeof # === "boolean"', <js.Expression>[value]);
         }
         // TODO(sra): Implement fast cast via calling 'boolTypeCast'.
       } else if (node.isTypeTest &&
-                 node.typeArguments.isEmpty &&
-                 glue.mayGenerateInstanceofCheck(type) &&
-                 tryRegisterInstanceofCheck(clazz)) {
+          node.typeArguments.isEmpty &&
+          glue.mayGenerateInstanceofCheck(type) &&
+          tryRegisterInstanceofCheck(clazz)) {
         return js.js('# instanceof #', [value, glue.constructorAccess(clazz)]);
       }
 
       // The helper we use needs the JSArray class to exist, but for some
       // reason the helper does not cause this dependency to be registered.
       // TODO(asgerf): Most programs need List anyway, but we should fix this.
       registry.registerInstantiatedClass(glue.listClass);
 
       // We use one of the two helpers:
       //
       //     checkSubtype(value, $isT, typeArgs, $asT)
       //     subtypeCast(value, $isT, typeArgs, $asT)
       //
       // Any of the last two arguments may be null if there are no type
       // arguments, and/or if no substitution is required.
-      Element function = node.isTypeTest
-          ? glue.getCheckSubtype()
-          : glue.getSubtypeCast();
+      Element function =
+          node.isTypeTest ? glue.getCheckSubtype() : glue.getSubtypeCast();
 
       js.Expression isT = js.quoteName(glue.getTypeTestTag(type));
 
       js.Expression typeArgumentArray = typeArguments.isNotEmpty
           ? new js.ArrayInitializer(typeArguments)
           : new js.LiteralNull();
 
       js.Expression asT = glue.hasStrictSubtype(clazz)
           ? js.quoteName(glue.getTypeSubstitutionTag(clazz))
           : new js.LiteralNull();
 
       return buildStaticHelperInvocation(
-          function,
-          <js.Expression>[value, isT, typeArgumentArray, asT]);
+          function, <js.Expression>[value, isT, typeArgumentArray, asT]);
     } else if (type is TypeVariableType || type is FunctionType) {
       registry.registerTypeUse(new TypeUse.isCheck(type));
 
       Element function = node.isTypeTest
           ? glue.getCheckSubtypeOfRuntimeType()
           : glue.getSubtypeOfRuntimeTypeCast();
 
       // The only type argument is the type held in the type variable.
       js.Expression typeValue = typeArguments.single;
 
       return buildStaticHelperInvocation(
-          function,
-          <js.Expression>[value, typeValue]);
+          function, <js.Expression>[value, typeValue]);
     }
     return giveup(node, 'type check unimplemented for $type.');
   }
 
   @override
   js.Expression visitGetTypeTestProperty(tree_ir.GetTypeTestProperty node) {
     js.Expression object = visitExpression(node.object);
     DartType dartType = node.dartType;
     assert(dartType.isInterfaceType);
     registry.registerTypeUse(new TypeUse.isCheck(dartType));
@@ skipping 27 matching lines @@
         return '/';
       case BuiltinOperator.NumRemainder:
         return '%';
       default:
         throw 'Not a compoundable operator: $operator';
     }
   }
 
   bool isCompoundableBuiltin(tree_ir.Expression exp) {
     return exp is tree_ir.ApplyBuiltinOperator &&
-           exp.arguments.length == 2 &&
-           isCompoundableOperator(exp.operator);
+        exp.arguments.length == 2 &&
+        isCompoundableOperator(exp.operator);
   }
 
   bool isOneConstant(tree_ir.Expression exp) {
     return exp is tree_ir.Constant && exp.value.isOne;
   }
 
-  js.Expression makeAssignment(
-      js.Expression leftHand,
-      tree_ir.Expression value,
-      {SourceInformation sourceInformation,
-       BuiltinOperator compound}) {
+  js.Expression makeAssignment(js.Expression leftHand, tree_ir.Expression value,
+      {SourceInformation sourceInformation, BuiltinOperator compound}) {
     if (isOneConstant(value)) {
       if (compound == BuiltinOperator.NumAdd) {
         return new js.Prefix('++', leftHand)
             .withSourceInformation(sourceInformation);
       }
       if (compound == BuiltinOperator.NumSubtract) {
         return new js.Prefix('--', leftHand)
             .withSourceInformation(sourceInformation);
       }
     }
     if (compound != null) {
-      return new js.Assignment.compound(leftHand,
-          getAsCompoundOperator(compound), visitExpression(value))
+      return new js.Assignment.compound(
+              leftHand, getAsCompoundOperator(compound), visitExpression(value))
           .withSourceInformation(sourceInformation);
     }
     return new js.Assignment(leftHand, visitExpression(value))
         .withSourceInformation(sourceInformation);
   }
 
   @override
   js.Expression visitAssign(tree_ir.Assign node) {
     js.Expression variable = buildVariableAccess(node.variable);
     if (isCompoundableBuiltin(node.value)) {
       tree_ir.ApplyBuiltinOperator rhs = node.value;
       tree_ir.Expression left = rhs.arguments[0];
       tree_ir.Expression right = rhs.arguments[1];
       if (left is tree_ir.VariableUse && left.variable == node.variable) {
-        return makeAssignment(variable, right, compound: rhs.operator,
-            sourceInformation: node.sourceInformation);
+        return makeAssignment(variable, right,
+            compound: rhs.operator, sourceInformation: node.sourceInformation);
       }
     }
-    return makeAssignment(
-        variable, node.value, sourceInformation: node.sourceInformation);
+    return makeAssignment(variable, node.value,
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
     tree_ir.Statement next = fallthrough.target;
     if (node.target.binding == next ||
         next is tree_ir.Continue && node.target == next.target) {
       // Fall through to continue target or to equivalent continue.
       fallthrough.use();
     } else if (node.target.binding == shortContinue.target) {
       // The target is the immediately enclosing loop.
       shortContinue.use();
       accumulator.add(new js.Continue(null));
     } else {
       accumulator.add(new js.Continue(makeLabel(node.target)));
     }
   }
 
   /// True if [other] is the target of [node] or is a [Break] with the same
   /// target. This means jumping to [other] is equivalent to executing [node].
   bool isEffectiveBreakTarget(tree_ir.Break node, tree_ir.Statement other) {
     return node.target.binding.next == other ||
-           other is tree_ir.Break && node.target == other.target;
+        other is tree_ir.Break && node.target == other.target;
   }
 
   /// True if the given break is equivalent to an unlabeled continue.
   bool isShortContinue(tree_ir.Break node) {
     tree_ir.Statement next = node.target.binding.next;
     return next is tree_ir.Continue &&
-           next.target.binding == shortContinue.target;
+        next.target.binding == shortContinue.target;
   }
 
   @override
   void visitBreak(tree_ir.Break node) {
     if (isEffectiveBreakTarget(node, fallthrough.target)) {
       // Fall through to break target or to equivalent break.
       fallthrough.use();
     } else if (isEffectiveBreakTarget(node, shortBreak.target)) {
       // Unlabeled break to the break target or to an equivalent break.
       shortBreak.use();
       accumulator.add(new js.Break(null));
     } else if (isShortContinue(node)) {
       // An unlabeled continue is better than a labeled break.
       shortContinue.use();
       accumulator.add(new js.Continue(null));
     } else {
       accumulator.add(new js.Break(makeLabel(node.target)));
     }
   }
 
   @override
   visitExpressionStatement(tree_ir.ExpressionStatement node) {
     js.Expression exp = visitExpression(node.expression);
     if (node.next is tree_ir.Unreachable && emitUnreachableAsReturn.last) {
       // Emit as 'return exp' to assist local analysis in the VM.
       SourceInformation sourceInformation = node.expression.sourceInformation;
-      accumulator.add(
-          new js.Return(exp).withSourceInformation(sourceInformation));
+      accumulator
+          .add(new js.Return(exp).withSourceInformation(sourceInformation));
       return null;
     } else {
       accumulator.add(new js.ExpressionStatement(exp));
       return node.next;
     }
   }
 
   bool isNullReturn(tree_ir.Statement node) {
     return node is tree_ir.Return && isNull(node.value);
   }
 
   bool isEndOfMethod(tree_ir.Statement node) {
     return isNullReturn(node) ||
-           node is tree_ir.Break && isNullReturn(node.target.binding.next);
+        node is tree_ir.Break && isNullReturn(node.target.binding.next);
   }
 
   @override
   visitIf(tree_ir.If node) {
     js.Expression condition = visitExpression(node.condition);
     int usesBefore = fallthrough.useCount;
     // Unless the 'else' part ends the method. make sure to terminate any
     // uncompletable code paths in the 'then' part.
     emitUnreachableAsReturn.add(!isEndOfMethod(node.elseStatement));
     js.Statement thenBody = buildBodyStatement(node.thenStatement);
@@ skipping 64 matching lines @@
     accumulator = <js.Statement>[];
     while (statement != null) {
       statement = visitStatement(statement);
     }
     js.Statement result = new js.Block(accumulator);
     accumulator = savedAccumulator;
     return result;
   }
 
   js.Expression makeSequence(List<tree_ir.Expression> list) {
-    return list.map(visitExpression).reduce((x,y) => new js.Binary(',', x, y));
+    return list.map(visitExpression).reduce((x, y) => new js.Binary(',', x, y));
   }
 
   @override
   visitFor(tree_ir.For node) {
     js.Expression condition = visitExpression(node.condition);
     shortBreak.push(node.next);
     shortContinue.push(node);
     fallthrough.push(node);
     emitUnreachableAsReturn.add(true);
     js.Statement body = buildBodyStatement(node.body);
     emitUnreachableAsReturn.removeLast();
     fallthrough.pop();
     shortContinue.pop();
     shortBreak.pop();
     js.Statement loopNode;
     if (node.updates.isEmpty) {
       loopNode = new js.While(condition, body);
-    } else { // Compile as a for loop.
+    } else {
+      // Compile as a for loop.
       js.Expression init;
       if (accumulator.isNotEmpty &&
           accumulator.last is js.ExpressionStatement) {
         // Take the preceding expression from the accumulator and use
         // it as the initializer expression.
         js.ExpressionStatement initStmt = accumulator.removeLast();
         init = initStmt.expression;
       }
       js.Expression update = makeSequence(node.updates);
       loopNode = new js.For(init, condition, update, body);
@@ skipping 11 matching lines @@
     emitUnreachableAsReturn.add(true);
     js.Statement jsBody = buildBodyStatement(node.body);
     emitUnreachableAsReturn.removeLast();
     fallthrough.pop();
     shortContinue.pop();
     if (shortBreak.useCount > 0) {
       // Short breaks use the current fallthrough target.
       fallthrough.use();
     }
     shortBreak.pop();
-    accumulator.add(
-        insertLabel(node.label, new js.For(null, null, null, jsBody)));
+    accumulator
+        .add(insertLabel(node.label, new js.For(null, null, null, jsBody)));
   }
 
   bool isNull(tree_ir.Expression node) {
     return node is tree_ir.Constant && node.value.isNull;
   }
 
   @override
   void visitReturn(tree_ir.Return node) {
     if (isNull(node.value) && fallthrough.target == null) {
       // Do nothing. Implicitly return JS undefined by falling over the end.
       registry.registerCompileTimeConstant(new NullConstantValue());
       fallthrough.use();
     } else {
       accumulator.add(new js.Return(visitExpression(node.value))
-            .withSourceInformation(node.sourceInformation));
+          .withSourceInformation(node.sourceInformation));
     }
   }
 
   @override
   void visitThrow(tree_ir.Throw node) {
     accumulator.add(new js.Throw(visitExpression(node.value)));
   }
 
   @override
   void visitUnreachable(tree_ir.Unreachable node) {
@@ skipping 23 matching lines @@
   js.Expression visitCreateInstance(tree_ir.CreateInstance node) {
     ClassElement classElement = node.classElement;
     // TODO(asgerf): To allow inlining of InvokeConstructor, CreateInstance must
     //               carry a DartType so we can register the instantiated type
     //               with its type arguments. Otherwise dataflow analysis is
     //               needed to reconstruct the instantiated type.
     registry.registerInstantiation(classElement.rawType);
     if (classElement is ClosureClassElement) {
       registry.registerInstantiatedClosure(classElement.methodElement);
     }
-    js.Expression instance = new js.New(
-            glue.constructorAccess(classElement),
+    js.Expression instance = new js.New(glue.constructorAccess(classElement),
             visitExpressionList(node.arguments))
         .withSourceInformation(node.sourceInformation);
 
     tree_ir.Expression typeInformation = node.typeInformation;
     if (typeInformation != null) {
       FunctionElement helper = glue.getAddRuntimeTypeInformation();
       js.Expression typeArguments = visitExpression(typeInformation);
-      return buildStaticHelperInvocation(helper,
-          <js.Expression>[instance, typeArguments],
+      return buildStaticHelperInvocation(
+          helper, <js.Expression>[instance, typeArguments],
           sourceInformation: node.sourceInformation);
     } else {
       return instance;
     }
   }
 
   @override
   js.Expression visitCreateInvocationMirror(
       tree_ir.CreateInvocationMirror node) {
     js.Expression name = js.string(node.selector.name);
     js.Expression internalName =
         js.quoteName(glue.invocationName(node.selector));
     js.Expression kind = js.number(node.selector.invocationMirrorKind);
-    js.Expression arguments = new js.ArrayInitializer(
-        visitExpressionList(node.arguments));
+    js.Expression arguments =
+        new js.ArrayInitializer(visitExpressionList(node.arguments));
     js.Expression argumentNames = new js.ArrayInitializer(
         node.selector.namedArguments.map(js.string).toList(growable: false));
     return buildStaticHelperInvocation(glue.createInvocationMirrorMethod,
         <js.Expression>[name, internalName, kind, arguments, argumentNames]);
   }
 
   @override
   js.Expression visitInterceptor(tree_ir.Interceptor node) {
     registry.registerUseInterceptor();
     // Default to all intercepted classes if they have not been computed.
     // This is to ensure we can run codegen without prior optimization passes.
     Set<ClassElement> interceptedClasses = node.interceptedClasses.isEmpty
         ? glue.interceptedClasses
         : node.interceptedClasses;
     registry.registerSpecializedGetInterceptor(interceptedClasses);
     js.Name helperName = glue.getInterceptorName(interceptedClasses);
     js.Expression globalHolder = glue.getInterceptorLibrary();
-    return js.js('#.#(#)',
-        [globalHolder, helperName, visitExpression(node.input)])
-            .withSourceInformation(node.sourceInformation);
+    return js.js('#.#(#)', [
+      globalHolder,
+      helperName,
+      visitExpression(node.input)
+    ]).withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitGetField(tree_ir.GetField node) {
     registry.registerStaticUse(new StaticUse.fieldGet(node.field));
-    return new js.PropertyAccess(
-        visitExpression(node.object),
-        glue.instanceFieldPropertyName(node.field))
+    return new js.PropertyAccess(visitExpression(node.object),
+            glue.instanceFieldPropertyName(node.field))
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitSetField(tree_ir.SetField node) {
     registry.registerStaticUse(new StaticUse.fieldSet(node.field));
-    js.PropertyAccess field =
-        new js.PropertyAccess(
-            visitExpression(node.object),
-            glue.instanceFieldPropertyName(node.field));
-    return makeAssignment(field, node.value, compound: node.compound,
-        sourceInformation: node.sourceInformation);
+    js.PropertyAccess field = new js.PropertyAccess(
+        visitExpression(node.object),
+        glue.instanceFieldPropertyName(node.field));
+    return makeAssignment(field, node.value,
+        compound: node.compound, sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitGetStatic(tree_ir.GetStatic node) {
     assert(node.element is FieldElement || node.element is FunctionElement);
     if (node.element is FunctionElement) {
       // Tear off a method.
       registry.registerStaticUse(
           new StaticUse.staticTearOff(node.element.declaration));
-      return glue.isolateStaticClosureAccess(node.element)
-        .withSourceInformation(node.sourceInformation);
+      return glue
+          .isolateStaticClosureAccess(node.element)
+          .withSourceInformation(node.sourceInformation);
     }
     if (node.useLazyGetter) {
       // Read a lazily initialized field.
       registry.registerStaticUse(
           new StaticUse.staticInit(node.element.declaration));
       js.Expression getter = glue.isolateLazyInitializerAccess(node.element);
       return new js.Call(getter, <js.Expression>[],
           sourceInformation: node.sourceInformation);
     }
     // Read an eagerly initialized field.
-    registry.registerStaticUse(
-        new StaticUse.staticGet(node.element.declaration));
-    return glue.staticFieldAccess(node.element)
+    registry
+        .registerStaticUse(new StaticUse.staticGet(node.element.declaration));
+    return glue
+        .staticFieldAccess(node.element)
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitSetStatic(tree_ir.SetStatic node) {
     assert(node.element is FieldElement);
-    registry.registerStaticUse(
-        new StaticUse.staticSet(node.element.declaration));
+    registry
+        .registerStaticUse(new StaticUse.staticSet(node.element.declaration));
     js.Expression field = glue.staticFieldAccess(node.element);
-    return makeAssignment(field, node.value, compound: node.compound,
-        sourceInformation: node.sourceInformation);
+    return makeAssignment(field, node.value,
+        compound: node.compound, sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitGetLength(tree_ir.GetLength node) {
     return new js.PropertyAccess.field(visitExpression(node.object), 'length');
   }
 
   @override
   js.Expression visitGetIndex(tree_ir.GetIndex node) {
     return new js.PropertyAccess(
-        visitExpression(node.object),
-        visitExpression(node.index));
+        visitExpression(node.object), visitExpression(node.index));
   }
 
   @override
   js.Expression visitSetIndex(tree_ir.SetIndex node) {
     js.Expression index = new js.PropertyAccess(
         visitExpression(node.object), visitExpression(node.index));
     return makeAssignment(index, node.value, compound: node.compound);
   }
 
   js.Expression buildStaticHelperInvocation(
-      FunctionElement helper,
-      List<js.Expression> arguments,
+      FunctionElement helper, List<js.Expression> arguments,
       {SourceInformation sourceInformation}) {
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(arguments.length)));
-    return buildStaticInvoke(
-        helper, arguments, sourceInformation: sourceInformation);
+    return buildStaticInvoke(helper, arguments,
+        sourceInformation: sourceInformation);
   }
 
   @override
   js.Expression visitReifyRuntimeType(tree_ir.ReifyRuntimeType node) {
     js.Expression typeToString = buildStaticHelperInvocation(
-        glue.getRuntimeTypeToString(),
-        [visitExpression(node.value)],
+        glue.getRuntimeTypeToString(), [visitExpression(node.value)],
         sourceInformation: node.sourceInformation);
     return buildStaticHelperInvocation(
-        glue.getCreateRuntimeType(),
-        [typeToString],
+        glue.getCreateRuntimeType(), [typeToString],
         sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitReadTypeVariable(tree_ir.ReadTypeVariable node) {
     ClassElement context = node.variable.element.enclosingClass;
     js.Expression index = js.number(glue.getTypeVariableIndex(node.variable));
     if (glue.needsSubstitutionForTypeVariableAccess(context)) {
       js.Expression typeName = glue.getRuntimeTypeName(context);
-      return buildStaticHelperInvocation(
-          glue.getRuntimeTypeArgument(),
+      return buildStaticHelperInvocation(glue.getRuntimeTypeArgument(),
           [visitExpression(node.target), typeName, index],
           sourceInformation: node.sourceInformation);
     } else {
       return buildStaticHelperInvocation(
-          glue.getTypeArgumentByIndex(),
-          [visitExpression(node.target), index],
+          glue.getTypeArgumentByIndex(), [visitExpression(node.target), index],
           sourceInformation: node.sourceInformation);
     }
   }
 
   @override
   js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
     List<js.Expression> arguments = visitExpressionList(node.arguments);
     switch (node.kind) {
       case tree_ir.TypeExpressionKind.COMPLETE:
         return glue.generateTypeRepresentation(
             node.dartType, arguments, registry);
       case tree_ir.TypeExpressionKind.INSTANCE:
         // We expect only flat types for the INSTANCE representation.
-        assert(node.dartType ==
-               (node.dartType.element as ClassElement).thisType);
+        assert(
+            node.dartType == (node.dartType.element as ClassElement).thisType);
         registry.registerInstantiatedClass(glue.listClass);
         return new js.ArrayInitializer(arguments);
     }
   }
 
   js.Node handleForeignCode(tree_ir.ForeignCode node) {
     if (node.dependency != null) {
       // Dependency is only used if [node] calls a Dart function. Currently only
       // through foreign function `RAW_DART_FUNCTION_REF`.
-      registry.registerStaticUse(
-          new StaticUse.staticInvoke(
-              node.dependency,
-              new CallStructure.unnamed(node.arguments.length)));
+      registry.registerStaticUse(new StaticUse.staticInvoke(
+          node.dependency, new CallStructure.unnamed(node.arguments.length)));
     }
     // TODO(sra,johnniwinther): Should this be in CodegenRegistry?
     glue.registerNativeBehavior(node.nativeBehavior, node);
-    return node.codeTemplate.instantiate(visitExpressionList(node.arguments))
+    return node.codeTemplate
+        .instantiate(visitExpressionList(node.arguments))
         .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitForeignExpression(tree_ir.ForeignExpression node) {
     return handleForeignCode(node);
   }
 
   @override
   void visitForeignStatement(tree_ir.ForeignStatement node) {
@@ skipping 72 matching lines @@
           return normalizeBitOp(js.js('# << #', args), node);
         case BuiltinOperator.NumShr:
           // No normalization required since output is always uint32.
           return js.js('# >>> #', args);
         case BuiltinOperator.NumBitNot:
           return js.js('(~#) >>> 0', args);
         case BuiltinOperator.NumNegate:
           return js.js('-#', args);
         case BuiltinOperator.StringConcatenate:
           if (args.isEmpty) return js.string('');
-          return args.reduce((e1,e2) => new js.Binary('+', e1, e2));
+          return args.reduce((e1, e2) => new js.Binary('+', e1, e2));
         case BuiltinOperator.CharCodeAt:
           return js.js('#.charCodeAt(#)', args);
         case BuiltinOperator.Identical:
           registry.registerStaticUse(new StaticUse.staticInvoke(
               glue.identicalFunction, new CallStructure.unnamed(args.length)));
           return buildStaticHelperInvocation(glue.identicalFunction, args);
         case BuiltinOperator.StrictEq:
           return new js.Binary('===', args[0], args[1]);
         case BuiltinOperator.StrictNeq:
           return new js.Binary('!==', args[0], args[1]);
@@ skipping 28 matching lines @@
           // TODO(sra): Remove boolify (i.e. !!).
           return js.js(r'!!#.immutable$list', args);
       }
     }
 
     return createExpression().withSourceInformation(node.sourceInformation);
   }
 
   /// Add a uint32 normalization `op >>> 0` to [op] if it is not in 31-bit
   /// range.
-  js.Expression normalizeBitOp(js.Expression op,
-                               tree_ir.ApplyBuiltinOperator node) {
+  js.Expression normalizeBitOp(
+      js.Expression op, tree_ir.ApplyBuiltinOperator node) {
     const MAX_UINT31 = 0x7fffffff;
     const MAX_UINT32 = 0xffffffff;
 
     int constantValue(tree_ir.Expression e) {
       if (e is tree_ir.Constant) {
         ConstantValue value = e.value;
         if (!value.isInt) return null;
         IntConstantValue intConstant = value;
         if (intConstant.primitiveValue < 0) return null;
         if (intConstant.primitiveValue > MAX_UINT32) return null;
@@ skipping 82 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }