Added VariableUse expression to tree IR.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, GenericType;
 import '../elements/elements.dart';
@@ skipping 66 matching lines @@
   /// Number of [Break] or [Continue] statements that target this label.
   /// The [Break] constructor will increment this automatically, but the
   /// counter must be decremented by hand when a [Break] becomes orphaned.
   int useCount = 0;
 
   /// The [LabeledStatement] or [WhileTrue] binding this label.
   JumpTarget binding;
 }
 
 /**
- * Variables are [Expression]s.
+ * A local variable in the tree IR.
+ *
+ * All tree IR variables are mutable, and may in Dart-mode be referenced inside
+ * nested functions.
+ *
+ * To use a variable as an expression, reference it from a [VariableUse], with
+ * one [VariableUse] per expression.
+ *
+ * [Variable]s are reference counted. The node constructors [VariableUse],
+ * [Assign], [FunctionDefinition] automatically update the reference count
+ * for their variables, but when transforming the tree, the transformer is
+ * responsible for updating reference counts.
  */
-class Variable extends Expression {
+class Variable extends Node {

[Kevin Millikin (Google), 2015/02/26 12:43:18]

Is there any reason to make this a subclass of Node?  (In fact, is there any
real reason to have Node in the first place?)

[asgerf, 2015/02/27 12:05:19]

Currently tree_ir.Node is just used for stuff like bailout, but I think it's
fine to have it.

I was thinking of adding a method accept(Visitor v) to the node class, and then
add visitVariable and visitFunctionDefinition to the Visitor class. It's a neat
trick but in the end I decided against it since there is no direct need for it
right now.

   /// Function that declares this variable.
   ExecutableElement host;
 
   /// [Entity] used for synthesizing a name for the variable.
   /// Different variables may have the same entity. May be null.
   Entity element;
 
+  /// Number of places where this variable occurs in a [VariableUse].
   int readCount = 0;
 
   /// Number of places where this variable occurs as:
   /// - left-hand of an [Assign]
   /// - left-hand of a [FunctionDeclaration]
   /// - parameter in a [FunctionDefinition]
   int writeCount = 0;
 
   Variable(this.host, this.element) {
     assert(host != null);
   }
+}
 
-  accept(ExpressionVisitor visitor) => visitor.visitVariable(this);
-  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitVariable(this, arg);
+/// Read the value of a variable.
+class VariableUse extends Expression {
+  Variable variable;
+
+  /// Creates a use of [variable] and updates its `readCount`.
+  VariableUse(this.variable) {
+    variable.readCount++;
+  }
+
+  accept(ExpressionVisitor visitor) => visitor.visitVariableUse(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitVariableUse(this, arg);
+  }
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
 }
 
@@ skipping 370 matching lines @@
   Statement next;
   Variable variable;
   Expression definition;
 
   /// If true, this assignes to a fresh variable scoped to the [next]
   /// statement.
   ///
   /// Variable declarations themselves are hoisted to function level.
   bool isDeclaration;
 
+  /// Creates an assignment to [variable] and updates its `writeCount`.
   Assign(this.variable, this.definition, this.next,
          { this.isDeclaration: false }) {
     variable.writeCount++;
   }
 
   bool get hasExactlyOneUse => variable.readCount == 1;
 
   accept(StatementVisitor visitor) => visitor.visitAssign(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitAssign(this, arg);
 }
@@ skipping 84 matching lines @@
   bool get hasInitializer => body != null;
 }
 
 class FunctionDefinition extends Node implements ExecutableDefinition {
   final FunctionElement element;
   final List<Variable> parameters;
   Statement body;
   final List<ConstDeclaration> localConstants;
   final List<ConstantExpression> defaultParameterValues;
 
+  /// Creates a function definition and updates `writeCount` for [parameters].
   FunctionDefinition(this.element, this.parameters, this.body,
-      this.localConstants, this.defaultParameterValues);
+      this.localConstants, this.defaultParameterValues) {
+    for (Variable param in parameters) {
+      param.writeCount++; // Being a parameter counts as a write.
+    }
+  }
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true` [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 }
 
 abstract class Initializer implements Expression, DartSpecificNode {}
 
@@ skipping 76 matching lines @@
   Statement next;
 
   SetField(this.object, this.field, this.value, this.next);
 
   accept(StatementVisitor visitor) => visitor.visitSetField(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
-  E visitVariable(Variable node);
+  E visitVariableUse(VariableUse node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitFieldInitializer(FieldInitializer node);
   E visitSuperInitializer(SuperInitializer node);
   E visitGetField(GetField node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression e, A arg) => e.accept1(this, arg);
-  E visitVariable(Variable node, A arg);
+  E visitVariableUse(VariableUse node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
@@ skipping 46 matching lines @@
 }
 
 abstract class Visitor1<S, E, A> implements ExpressionVisitor1<E, A>,
                                             StatementVisitor1<S, A> {
    E visitExpression(Expression e, A arg) => e.accept1(this, arg);
    S visitStatement(Statement s, A arg) => s.accept1(this, arg);
 }
 
 class RecursiveVisitor extends Visitor {
   visitFunctionDefinition(FunctionDefinition node) {
+    node.parameters.forEach(visitVariable);
     visitStatement(node.body);
   }
 
   visitVariable(Variable node) {}
 
+  visitVariableUse(VariableUse node) {
+    visitVariable(node.variable);
+  }
+
   visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethod(InvokeMethod node) {
     visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
@@ skipping 112 matching lines @@
     visitStatement(node.next);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
   }
 }