dart2dart: Preserve variable names throughout the IR.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_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 dart_codegen;
 
 import 'dart_tree.dart' as tree;
 import 'dart_printer.dart';
 import 'dart_tree_printer.dart' show TreePrinter;
 import '../tree/tree.dart' as frontend;
@@ skipping 10 matching lines @@
                                  tree.FunctionDefinition definition) {
   FunctionExpression fn = new ASTEmitter().emit(element, definition);
   return new TreePrinter(treeElements).makeExpression(fn);
 }
 
 /// Translates the dart_tree IR to Dart backend AST.
 class ASTEmitter extends tree.Visitor<dynamic, Expression> {
   /// Variables to be hoisted at the top of the current function.
   List<VariableDeclaration> variables;
 
-  /// Set of variables that have had their declaration inserted in [variables].
-  Set<tree.Variable> seenVariables;
+  /// Maps variables to their name.
+  /// These variables have had their declaration inserted in [variables].
+  Map<tree.Variable, String> variableNames;
+
+  /// Variable names that have already been used. Used to avoid name clashes.
+  Set<String> usedVariableNames;
 
   /// Statements emitted by the most recent call to [visitStatement].
   List<Statement> statementBuffer;
 
   /// The function currently being emitted.
   FunctionElement functionElement;
 
   /// Bookkeeping object needed to synthesize a variable declaration.
   modelx.VariableList variableList;
 
   /// 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.Statement fallthrough;
 
   /// Labels that could not be eliminated using fallthrough.
   Set<tree.Label> usedLabels;
 
   FunctionExpression emit(FunctionElement element,
                           tree.FunctionDefinition definition) {
     functionElement = element;
     variables = <VariableDeclaration>[];
     statementBuffer = <Statement>[];
-    seenVariables = new Set<tree.Variable>();
-    tree.Variable.counter = 0;
+    variableNames = <tree.Variable, String>{};
+    usedVariableNames = new Set<String>();
     variableList = new modelx.VariableList(tree.Modifiers.EMPTY);
     fallthrough = null;
     usedLabels = new Set<tree.Label>();
 
     Parameters parameters = emitParameters(definition.parameters);
     visitStatement(definition.body);
     removeTrailingReturn();
     Statement body = new Block(statementBuffer);
     if (variables.length > 0) {
       Statement head = new VariableDeclarations(variables);
       body = new Block([head, body]);
     }
 
     FunctionType functionType = element.type;
 
     variables = null;
     statementBuffer = null;
     functionElement = null;
     variableList = null;
-    seenVariables = null;
+    variableNames = null;
+    usedVariableNames = null;
     usedLabels = null;
 
     return new FunctionExpression(
         parameters,
         body,
         name: element.name,
         returnType: emitOptionalType(functionType.returnType))
         ..element = element;
   }
 
   /// Removes a trailing "return null" from [statementBuffer].
   void removeTrailingReturn() {
     if (statementBuffer.isEmpty) return;
     if (statementBuffer.last is! Return) return;
     Return ret = statementBuffer.last;
     Expression expr = ret.expression;
     if (expr is Literal && expr.value is dart2js.NullConstant) {
       statementBuffer.removeLast();
     }
   }
 
   Parameter emitParameter(tree.Variable param) {
-    seenVariables.add(param);
+    String name = getVariableName(param);
     ParameterElement element = param.element;
     TypeAnnotation type = emitOptionalType(element.type);
-    return new Parameter(element.name, type:type)
+    return new Parameter(name, type:type)
                ..element = element;
   }
 
   Parameters emitParameters(List<tree.Variable> params) {
     return new Parameters(params.map(emitParameter).toList(growable:false));
   }
 
   /// True if the two expressions are a reference to the same variable.
   bool isSameVariable(Expression e1, Expression e2) {
     // TODO(asgerf): Using the annotated element isn't the best way to do this
@@ skipping 53 matching lines @@
       savedBuffer.add(new LabeledStatement(stmt.label.name,
                                            new Block(statementBuffer)));
     } else {
       savedBuffer.add(new Block(statementBuffer));
     }
     fallthrough = savedFallthrough;
     statementBuffer = savedBuffer;
     visitStatement(stmt.next);
   }
 
-  void visitAssign(tree.Assign stmt) {
-    // Synthesize an element for the variable, if necessary.
-    if (stmt.variable.element == null) {
-      stmt.variable.element = new modelx.VariableElementX(
-          stmt.variable.name,
+  /// Generates a name for the given variable and synthesizes an element for it,
+  /// if necessary.
+  String getVariableName(tree.Variable variable) {
+    String name = variableNames[variable];
+    if (name != null) {
+      return name;
+    }
+    String prefix = variable.element == null ? 'v' : variable.element.name;
+    int counter = 0;
+    name = variable.element == null ? '$prefix$counter' : variable.element.name;
+    while (!usedVariableNames.add(name)) {
+      ++counter;
+      name = '$prefix$counter';
+    }
+    variableNames[variable] = name;
+
+    // Synthesize an element for the variable
+    if (variable.element == null || name != variable.element.name) {
+      variable.element = new modelx.VariableElementX(
+          name,
           ElementKind.VARIABLE,
           functionElement,
           variableList,
           null);
     }
-    if (seenVariables.add(stmt.variable)) {
-      variables.add(new VariableDeclaration(stmt.variable.name)
-                            ..element = stmt.variable.element);
+    if (variable.element is! ParameterElement) {
+      variables.add(new VariableDeclaration(name)
+                        ..element = variable.element);
     }
+    return name;
+  }
+
+  void visitAssign(tree.Assign stmt) {
+    String name = getVariableName(stmt.variable);
     statementBuffer.add(new ExpressionStatement(makeAssignment(
         visitVariable(stmt.variable),
         visitExpression(stmt.definition))));
     visitStatement(stmt.next);
   }
 
   void visitReturn(tree.Return stmt) {
     Expression inner = visitExpression(stmt.value);
     statementBuffer.add(new Return(inner));
   }
@@ skipping 211 matching lines @@
     return new BinaryOperator(visitExpression(exp.left),
                               exp.operator,
                               visitExpression(exp.right));
   }
 
   Expression visitNot(tree.Not exp) {
     return new UnaryOperator('!', visitExpression(exp.operand));
   }
 
   Expression visitVariable(tree.Variable exp) {
-    return new Identifier(exp.name)
+    return new Identifier(getVariableName(exp))
                ..element = exp.element;
   }
 
   TypeAnnotation emitType(DartType type) {
     if (type is GenericType) { // TODO(asgerf): faster Link.map
       return new TypeAnnotation(
           type.element.name,
           type.typeArguments.toList(growable:false)
               .map(emitType).toList(growable:false))
           ..dartType = type;
@@ skipping 44 matching lines @@
         dart2js.StringConstant nameConstant = constant.fields[0];
         String nameString = nameConstant.value.slowToString();
         return new LiteralSymbol(nameString);
       } else {
         throw "Unsupported constant: $constant";
       }
     }
   }
 }