Add support for local variables(including parameters) to cps->js.

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;
 import '../../elements/elements.dart';
 import '../../util/maplet.dart';
 import '../../constants/values.dart';
 import '../../dart2jslib.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.Visitor<dynamic, js.Expression> {
   final CodegenRegistry registry;
 
   final Glue glue;
 
-  /// Variables to be hoisted at the top of the current function.
-  List<js.VariableDeclaration> variables = <js.VariableDeclaration>[];
+  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>();
 
-  /// Variables that have had their declaration created.
-  Set<tree_ir.Variable> declaredVariables = new Set<tree_ir.Variable>();
-
   /// Variable names that have already been used. Used to avoid name clashes.
-  Set<String> usedVariableNames;
+  Set<String> usedVariableNames = new Set<String>();
 
   List<js.Parameter> parameters = new List<js.Parameter>();
   List<js.Statement> accumulator = new List<js.Statement>();
 
   js.Block body;
 
   /// 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) {
+    currentFunction = function.element;
     visitStatement(function.body);
     for (tree_ir.Variable parameter in function.parameters) {
-      parameters.add(new js.Parameter(variableNames[parameter]));
+      String name = getVariableName(parameter);
+      parameters.add(new js.Parameter(name));
+    }
+
+    List<js.VariableInitialization> jsVariables = <js.VariableInitialization>[];
+
+    for (tree_ir.Variable variable in variableNames.keys) {
+      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);
   }
 
+  /// 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) {
+    // TODO(sigurdm): Handle case where the variable belongs to an enclosing
+    // function.
+    if (variable.host.element != currentFunction) giveup(variable);
+
+    // 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.
+    // The [usedVariableNames] set is shared between nested emitters,
+    // so this also prevents clash with variables in an enclosing/inner scope.
+    // The renaming phase after codegen will further prefix local variables
+    // so they cannot clash with top-level variables or fields.
+    String prefix = variable.element == null ? 'v' : variable.element.name;
+    int counter = 0;
+    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> visitArguments(List<tree_ir.Expression> arguments) {
     return arguments.map(visitExpression).toList();
   }
 
   giveup(tree_ir.Node node,
          [String reason = 'unimplemented in CodeGenerator']) {
     throw new CodegenBailout(node, reason);
   }
 
   @override
@@ skipping 86 matching lines @@
   }
 
   @override
   js.Expression visitTypeOperator(tree_ir.TypeOperator node) {
     return giveup(node);
     // TODO: implement visitTypeOperator
   }
 
   @override
   js.Expression visitVariable(tree_ir.Variable node) {
-    return giveup(node);
+    return new js.VariableUse(getVariableName(node));
     // TODO: implement visitVariable
   }
 
   @override
   void visitContinue(tree_ir.Continue node) {
     return giveup(node);
     // TODO: implement visitContinue
   }
 
   @override
@@ skipping 16 matching lines @@
   }
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
     giveup(node);
     // TODO: implement visitLabeledStatement
   }
 
   @override
   void visitAssign(tree_ir.Assign node) {
-    giveup(node);
-    // TODO: implement visitAssign
+
+    bool isFirstOccurrence = (variableNames[node.variable] == null);

[floitsch, 2014/11/19 12:02:19]

unused

[sigurdm, 2014/11/20 12:22:40]

Fixed by https://codereview.chromium.org/737363002

+    bool isDeclaredHere = node.variable.host.element == currentFunction;

[floitsch, 2014/11/19 12:02:19]

unused.

[sigurdm, 2014/11/20 12:22:40]

Done.

+    String name = getVariableName(node.variable);

[floitsch, 2014/11/19 12:02:19]

unused.

[sigurdm, 2014/11/20 12:22:40]

Done.

+    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
   }
 
   @override
   void visitWhileCondition(tree_ir.WhileCondition node) {
     giveup(node);
     // TODO: implement visitWhileCondition
   }
 
   @override
   void visitWhileTrue(tree_ir.WhileTrue node) {
     giveup(node);
     // TODO: implement visitWhileTrue
   }
 
   @override
   void visitReturn(tree_ir.Return node) {
     if (node.value != null) {
       accumulator.add(new js.Return(visitExpression(node.value)));
     }
   }
+
+  bool isNullLiteral(js.Expression exp) => exp is js.LiteralNull;
+
 }