Add support for if, while, break, continue to js-cps

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 '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../js/js.dart' as js;
@@ skipping 21 matching lines @@
   /// 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>();
 
-  List<js.Parameter> parameters = new List<js.Parameter>();
+  /// Input to [visitStatement]. Denotes the statement that will execute next
+  /// if the statements produced by [visitStatement] complete normally.
+  /// Set to null if control will fall over the end of the method.
+  tree_ir.Statement fallthrough = null;
+
+  Set<tree_ir.Label> usedLabels = new Set<tree_ir.Label>();
+
   List<js.Statement> accumulator = new List<js.Statement>();
 
-  js.Block body;
+  CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
-  /// The code will be in [body] and the parameters will be in [parameters].
-  CodeGenerator(this.glue, this.registry);
-
-  void buildFunction(tree_ir.FunctionDefinition function) {
+  js.Fun buildFunction(tree_ir.FunctionDefinition function) {
     currentFunction = function.element;
     visitStatement(function.body);
 
+    List<js.Parameter> parameters = new List<js.Parameter>();
     Set<tree_ir.Variable> parameterSet = new Set<tree_ir.Variable>();
 
     for (tree_ir.Variable parameter in function.parameters) {
       String name = getVariableName(parameter);
       parameters.add(new js.Parameter(name));
       parameterSet.add(parameter);
     }
 
     List<js.VariableInitialization> jsVariables = <js.VariableInitialization>[];
 
     for (tree_ir.Variable variable in variableNames.keys) {
       if (parameterSet.contains(variable)) continue;
       String name = getVariableName(variable);
       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)));
     }
-    body = new js.Block(accumulator);
+    return new js.Fun(parameters, new js.Block(accumulator));
   }
 
   js.Expression visit(tree_ir.Expression node) {
     js.Expression result = node.accept(this);
     if (result == null) {
       glue.reportInternalError('$node did not produce code.');
     }
     return result;
   }
 
@@ skipping 119 matching lines @@
     // TODO: implement visitLiteralMap
   }
 
   @override
   js.Expression visitLogicalOperator(tree_ir.LogicalOperator node) {
     return new js.Binary(node.operator, visit(node.left), visit(node.right));
   }
 
   @override
   js.Expression visitNot(tree_ir.Not node) {
-    return giveup(node);
-    // TODO: implement visitNot
+    return new js.Prefix("!", visitExpression(node.operand));
   }
 
   @override
   js.Expression visitReifyTypeVar(tree_ir.ReifyTypeVar node) {
     return giveup(node);
     // TODO: implement visitReifyTypeVar
   }
 
   @override
   js.Expression visitThis(tree_ir.This node) {
     // TODO(sigurdm): Inside a js closure this will not work.
     return new js.This();
   }
 
   @override
   js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
     return giveup(node);
     // TODO: implement visitTypeOperator
   }
 
   @override
   js.Expression visitVariable(tree_ir.Variable node) {
     return new js.VariableUse(getVariableName(node));
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
-    return giveup(node);
-    // TODO: implement visitContinue
+    tree_ir.Statement fallthrough = this.fallthrough;
+    if (node.target.binding == fallthrough) {
+      // Fall through to continue target
+    } else if (fallthrough is tree_ir.Continue &&
+               fallthrough.target == node.target) {
+      // Fall through to equivalent continue
+    } else {
+      usedLabels.add(node.target);
+      accumulator.add(new js.Continue(node.target.name));
+    }
   }
 
   @override
   void visitExpressionStatement(tree_ir.ExpressionStatement node) {
     accumulator.add(new js.ExpressionStatement(
         visitExpression(node.expression)));
     visitStatement(node.next);
   }
 
   @override
   void visitFunctionDeclaration(tree_ir.FunctionDeclaration node) {
     giveup(node);
     // TODO: implement visitFunctionDeclaration
   }
 
   @override
   void visitIf(tree_ir.If node) {
-    giveup(node);
-    // TODO: implement visitIf
+    accumulator.add(new js.If(visitExpression(node.condition),
+                              buildBody(node.thenStatement),
+                              buildBody(node.elseStatement)));
   }
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
-    giveup(node);
-    // TODO: implement visitLabeledStatement
+    accumulator.add(buildLabeled(() => buildBody(node.body),
+                                 node.label,
+                                 node.next));
+    visitStatement(node.next);
+  }
+
+  js.Statement buildLabeled(js.Statement buildBody(),
+                tree_ir.Label label,
+                tree_ir.Statement fallthroughStatement) {
+    tree_ir.Statement savedFallthrough = fallthrough;
+    fallthrough = fallthroughStatement;
+    js.Statement result = buildBody();
+    if (usedLabels.remove(label)) {
+      result = new js.LabeledStatement(label.name, result);
+    }
+    fallthrough = savedFallthrough;
+    return result;
   }
 
   @override
   void visitAssign(tree_ir.Assign node) {
     tree_ir.Expression value = node.definition;
     js.Expression definition = visitExpression(value);
 
     accumulator.add(new js.ExpressionStatement(new js.Assignment(
         visitVariable(node.variable),
         definition)));
     visitStatement(node.next);
   }
 
   @override
   void visitBreak(tree_ir.Break node) {
-    giveup(node);
-    // TODO: implement visitBreak
+    tree_ir.Statement fallthrough = this.fallthrough;
+    if (node.target.binding.next == fallthrough) {
+      // Fall through to break target
+    } else if (fallthrough is tree_ir.Break &&
+               fallthrough.target == node.target) {
+      // Fall through to equivalent break
+    } else {
+      usedLabels.add(node.target);
+      accumulator.add(new js.Break(node.target.name));
+    }
+  }
+
+  /// Returns the current [accumulator] wrapped in a block if neccessary.
+  js.Statement _bodyAsStatement() {
+    if (accumulator.length == 0) {
+      return new js.EmptyStatement();
+    }
+    if (accumulator.length == 1) {
+      return accumulator.single;
+    }
+    return new js.Block(accumulator);
+  }
+
+  /// Builds a nested statement.
+  js.Statement buildBody(tree_ir.Statement statement) {
+    List<js.Statement> savedAccumulator = accumulator;
+    accumulator = new List<js.Statement>();
+    visitStatement(statement);
+    js.Statement result = _bodyAsStatement();
+    accumulator = savedAccumulator;
+    return result;
+  }
+
+  js.Statement buildWhile(js.Expression condition,
+                          tree_ir.Statement body,
+                          tree_ir.Label label,
+                          tree_ir.Statement fallthroughStatement) {
+    return buildLabeled(() => new js.While(condition, buildBody(body)),
+                        label,
+                        fallthroughStatement);
   }
 
   @override
   void visitWhileCondition(tree_ir.WhileCondition node) {
-    giveup(node);
-    // TODO: implement visitWhileCondition
+    accumulator.add(
+        buildWhile(visitExpression(node.condition),
+                   node.body,
+                   node.label,
+                   node));
+    visitStatement(node.next);
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
-    giveup(node);
-    // TODO: implement visitWhileTrue
+    accumulator.add(
+        buildWhile(new js.LiteralBool(true), node.body, node.label, node));
   }
 
   @override
   void visitReturn(tree_ir.Return node) {
     accumulator.add(new js.Return(visitExpression(node.value)));
   }
 
-  bool isNullLiteral(js.Expression exp) => exp is js.LiteralNull;
-
 }