dart2js: Flatten the code generation visitor a little bit.

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;
@@ skipping 73 matching lines @@
   final Map<tree_ir.Label, String> labelNames = <tree_ir.Label, String>{};
 
   List<js.Statement> accumulator = new List<js.Statement>();
 
   CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
   js.Fun buildFunction(tree_ir.FunctionDefinition function) {
     registerDefaultParameterValues(function.element);
     currentFunction = function.element;
-    visitStatement(function.body);
+    tree_ir.Statement statement = function.body;
+    while (statement != null) {
+      statement = visitStatement(statement);
+    }
 
     List<js.Parameter> parameters = new List<js.Parameter>();
     Set<tree_ir.Variable> parameterSet = new Set<tree_ir.Variable>();
     Set<String> declaredVariables = new Set<String>();
 
     for (tree_ir.Variable parameter in function.parameters) {
       String name = getVariableName(parameter);
       parameters.add(new js.Parameter(name));
       parameterSet.add(parameter);
       declaredVariables.add(name);
@@ skipping 106 matching lines @@
       ++counter;
       name = '$prefix$counter';
     }
     variableNames[variable] = name;
 
     return name;
   }
 
   List<js.Expression> visitExpressionList(
       List<tree_ir.Expression> expressions) {
-    return new List<js.Expression>.generate(expressions.length,
-        (int index) => visitExpression(expressions[index]),
-        growable: false);
+    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']) {
     throw new CodegenBailout(node, reason);
   }
 
   @override
   js.Expression visitConditional(tree_ir.Conditional node) {
     return new js.Conditional(
@@ skipping 377 matching lines @@
     } 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
-  void visitExpressionStatement(tree_ir.ExpressionStatement node) {
+  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.
       accumulator.add(new js.Return(exp));
+      return null;
     } else {
       accumulator.add(new js.ExpressionStatement(exp));
-      visitStatement(node.next);
+      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);
   }
 
   @override
-  void visitIf(tree_ir.If node) {
+  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);
     emitUnreachableAsReturn.removeLast();
     bool thenHasFallthrough = (fallthrough.useCount > usesBefore);
     if (thenHasFallthrough) {
       js.Statement elseBody = buildBodyStatement(node.elseStatement);
       accumulator.add(new js.If(condition, thenBody, elseBody));
+      return null;
     } else {
       // The 'then' body cannot complete normally, so emit a short 'if'
       // and put the 'else' body after it.
       accumulator.add(new js.If.noElse(condition, thenBody));
-      visitStatement(node.elseStatement);
+      return node.elseStatement;
     }
   }
 
   @override
-  void visitLabeledStatement(tree_ir.LabeledStatement node) {
+  visitLabeledStatement(tree_ir.LabeledStatement node) {
     fallthrough.push(node.next);
     js.Statement body = buildBodyStatement(node.body);
     fallthrough.pop();
     accumulator.add(insertLabel(node.label, body));
-    visitStatement(node.next);
+    return node.next;
   }
 
   /// Creates a name for [label] if it does not already have one.
   ///
   /// This also marks the label as being used.
   String makeLabel(tree_ir.Label label) {
     return labelNames.putIfAbsent(label, () => 'L${labelNames.length}');
   }
 
   /// Wraps a node in a labeled statement unless the label is unused.
@@ skipping 11 matching lines @@
     if (accumulator.length == 1) {
       return accumulator.single;
     }
     return new js.Block(accumulator);
   }
 
   /// Builds a nested statement.
   js.Statement buildBodyStatement(tree_ir.Statement statement) {
     List<js.Statement> savedAccumulator = accumulator;
     accumulator = <js.Statement>[];
-    visitStatement(statement);
+    while (statement != null) {
+      statement = visitStatement(statement);
+    }
     js.Statement result = _bodyAsStatement();
     accumulator = savedAccumulator;
     return result;
   }
 
   js.Block buildBodyBlock(tree_ir.Statement statement) {
     List<js.Statement> savedAccumulator = accumulator;
     accumulator = <js.Statement>[];
-    visitStatement(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));
   }
 
   @override
-  void visitFor(tree_ir.For node) {
+  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.
       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);
     }
     accumulator.add(insertLabel(node.label, loopNode));
-    visitStatement(node.next);
+    return node.next;
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
     // A short break in the while will jump to the current fallthrough target.
     shortBreak.push(fallthrough.target);
     shortContinue.push(node);
     fallthrough.push(node);
     emitUnreachableAsReturn.add(true);
     js.Statement jsBody = buildBodyStatement(node.body);
@@ skipping 250 matching lines @@
   js.Expression visitForeignExpression(tree_ir.ForeignExpression node) {
     return handleForeignCode(node);
   }
 
   @override
   void visitForeignStatement(tree_ir.ForeignStatement node) {
     accumulator.add(handleForeignCode(node));
   }
 
   @override
-  void visitYield(tree_ir.Yield node) {
+  visitYield(tree_ir.Yield node) {
     js.Expression value = visitExpression(node.input);
     accumulator.add(new js.DartYield(value, node.hasStar));
-    visitStatement(node.next);
+    return node.next;
   }
 
   @override
-  void visitNullCheck(tree_ir.NullCheck node) {
+  visitNullCheck(tree_ir.NullCheck node) {
     js.Expression value = visitExpression(node.value);
     // TODO(sra): Try to use the selector even when [useSelector] is false. The
     // reason we use 'toString' is that it is always defined so avoids a slow
     // lookup (in V8) of an absent property. We could use the property for the
     // selector if we knew it was present. The property is present if the
     // associated method was not inlined away, or if there is a noSuchMethod
     // hook for that selector. We don't know these things here, but the decision
     // could be deferred by creating a deferred property that was resolved after
     // codegen.
     js.Expression access = node.selector != null && node.useSelector
         ? js.js('#.#', [value, glue.invocationName(node.selector)])
         : js.js('#.toString', [value]);
     if (node.condition != null) {
       js.Expression condition = visitExpression(node.condition);
       js.Statement body = isNullReturn(node.next)
           ? new js.ExpressionStatement(access)
           : new js.Return(access);
       accumulator.add(new js.If.noElse(condition, body));
     } else {
       accumulator.add(new js.ExpressionStatement(access));
     }
-    visitStatement(node.next);
+    return node.next;
   }
 
   @override
   js.Expression visitApplyBuiltinOperator(tree_ir.ApplyBuiltinOperator node) {
     List<js.Expression> args = visitExpressionList(node.arguments);
     switch (node.operator) {
       case BuiltinOperator.NumAdd:
         return new js.Binary('+', args[0], args[1]);
       case BuiltinOperator.NumSubtract:
         return new js.Binary('-', args[0], args[1]);
@@ skipping 167 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);
     });
   }
 }