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 36 matching lines @@
 
   /// 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;
     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);
@@ skipping 99 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);
   }
 
+  String getVariableName(tree.Variable variable) {

[sigurdm, 2014/06/04 07:51:56]

Maybe move this to a getter, so the .name field is not exposed.

[asgerf, 2014/06/04 09:40:51]

Not so easy since it depends on this.variableList and this.functionElement.

[sigurdm, 2014/06/04 10:29:39]

True - my mistake

+    if (variable.element != null && variable.index == 0) {
+      return variable.element.name;
+    }
+    // FIXME(asgerf): prevent name clashes
+    String name;
+    if (variable.element != null) {
+      name = '${variable.element.name}${variable.index}';
+    } else {
+      name = 'v${variable.index}';
+    }
+    // Synthesize an element for the variable
+    variable.element = new modelx.VariableElementX(
+        name,
+        ElementKind.VARIABLE,
+        functionElement,
+        variableList,
+        null);
+    variable.index = 0; // Index is relative to the new synthesized element.
+    return name;
+  }
+
   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,
-          ElementKind.VARIABLE,
-          functionElement,
-          variableList,
-          null);
-    }
+    String name = getVariableName(stmt.variable);
     if (seenVariables.add(stmt.variable)) {
-      variables.add(new VariableDeclaration(stmt.variable.name)
+      variables.add(new VariableDeclaration(name)
                             ..element = stmt.variable.element);
     }
     statementBuffer.add(new ExpressionStatement(makeAssignment(
         visitVariable(stmt.variable),
         visitExpression(stmt.definition))));
     visitStatement(stmt.next);
   }
 
   void visitReturn(tree.Return stmt) {
     Expression inner = visitExpression(stmt.value);
@@ skipping 143 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;
     } else if (type is VoidType) {
       return new TypeAnnotation('void')
           ..dartType = type;
     } else if (type is TypeVariableType) {
       return new TypeAnnotation(type.name)
           ..dartType = type;
+    } else if (type is DynamicType) {
+      return new TypeAnnotation("dynamic")
+          ..dartType = type;
     } else {
       throw "Unsupported type annotation: $type";
     }
   }
 
   /// Like [emitType] except the dynamic type is converted to null.
   TypeAnnotation emitOptionalType(DartType type) {
     if (type.isDynamic) {
       return null;
     } else {
@@ skipping 15 matching lines @@
             emitConstant(constant.keys.entries[i]),
             emitConstant(constant.values[i])));
       }
       return new LiteralMap(entries, isConst: true);
     } else {
       throw "Unsupported constant: $constant";
     }
   }
 }