Added VariableUse expression to tree IR.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 78 matching lines @@
   // and local function declarations.
   void addDeclaration(tree.Variable variable, [Expression initializer]) {
     assert(!declaredVariables.contains(variable));
     String name = getVariableName(variable);
     VariableDeclaration decl = new VariableDeclaration(name, initializer);
     decl.element = variable.element;
     declaredVariables.add(variable);
     variables.add(decl);
   }
 
+  /// Creates an [Identifier] referring to the given variable.
+  Expression makeVariableAccess(tree.Variable variable) {
+    return new Identifier(getVariableName(variable))
+               ..element = variable.element;
+  }
+
   /// Generates a name for the given variable and synthesizes an element for it,
   /// if necessary.
   String getVariableName(tree.Variable variable) {
     // If the variable belongs to an enclosing function, ask the parent emitter
     // for the variable name.
     if (!inInitializer && variable.host != currentElement) {
       return _parent.getVariableName(variable);
     }
 
     // Get the name if we already have one.
@@ skipping 424 matching lines @@
     // Try to pull into initializer.
     if (context.firstStatement == stmt && isFirstOccurrence && isDeclaredHere) {
       if (isNullLiteral(definition)) definition = null;
       context.addDeclaration(stmt.variable, definition);
       context.firstStatement = stmt.next;
       visitStatement(stmt.next, context);
       return;
     }
 
     // Emit a variable declaration if we are required to do so.
-    // This is to ensure that a fresh closure variable is created.
+    // For captured variables, this ensures that a fresh variable is created.
     if (stmt.isDeclaration) {
       assert(isFirstOccurrence);
       assert(isDeclaredHere);
       if (isNullLiteral(definition)) definition = null;
       VariableDeclaration decl = new VariableDeclaration(name, definition)
                                      ..element = stmt.variable.element;
       context.declaredVariables.add(stmt.variable);
       context.addStatement(new VariableDeclarations([decl]));
       visitStatement(stmt.next, context);
       return;
     }
 
     context.addStatement(new ExpressionStatement(makeAssignment(
-        visitVariable(stmt.variable, context),
+        context.makeVariableAccess(stmt.variable),
         definition)));
     visitStatement(stmt.next, context);
   }
 
   @override
   void visitReturn(tree.Return stmt,
                    BuilderContext<Statement> context) {
     if (context.currentElement.isGenerativeConstructor &&
         !context.inInitializer) {
       assert(() {
@@ skipping 288 matching lines @@
                               visitExpression(exp.right, context));
   }
 
   @override
   Expression visitNot(tree.Not exp,
                       BuilderContext<Statement> context) {
     return new UnaryOperator('!', visitExpression(exp.operand, context));
   }
 
   @override
-  Expression visitVariable(tree.Variable exp,
-                           BuilderContext<Statement> context) {
-    return new Identifier(context.getVariableName(exp))
-               ..element = exp.element;
+  Expression visitVariableUse(tree.VariableUse exp,
+                              BuilderContext<Statement> context) {
+    return context.makeVariableAccess(exp.variable);
   }
 
   FunctionExpression makeSubFunction(tree.FunctionDefinition function,
                                      BuilderContext<Statement> context) {
     return emit(function, new BuilderContext<Statement>.inner(context));
   }
 
   @override
   Expression visitFunctionExpression(tree.FunctionExpression exp,
                                      BuilderContext<Statement> context) {
@@ skipping 378 matching lines @@
     visitStatement(definition.body);
     environment = oldEnvironment;
     shadowedParameters = oldShadow;
 
     for (int i=0; i<definition.parameters.length; i++) {
       tree.Variable param = definition.parameters[i];
       if (hasShadowedUse.remove(param)) {
         tree.Variable newParam = new tree.Variable(definition.element,
             param.element);
         definition.parameters[i] = newParam;
-        definition.body = new tree.Assign(param, newParam, definition.body);
+        definition.body = new tree.Assign(param, new tree.VariableUse(newParam),
+            definition.body);
         newParam.writeCount = 1; // Being a parameter counts as a write.
+        param.writeCount--; // Not a parameter anymore.
       }
     }
   }
 
+  @override
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }
 
 // TODO(johnniwinther): Remove this when the dart `backend_ast` does not need
 // [Element] for entities.
 class _SyntheticLocalVariableElement extends modelx.VariableElementX
     implements LocalVariableElement {
 
   _SyntheticLocalVariableElement(String name,
                                  ExecutableElement enclosingElement,
                                  modelx.VariableList variables)
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }