Added VariableUse expression to tree IR.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

Index: pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart
diff --git a/pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart b/pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart
index 5d3cb519d2b99e2a7fa4b14d1eb1a670c5344ce5..761689ac9a2311437db29788c27336345267fda5 100644
--- a/pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart
+++ b/pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart
@@ -91,14 +91,17 @@ class Builder extends cps_ir.Visitor<Node> {
     return variable;
   }
 
-  Variable getMutableVariableReference(
-        cps_ir.Reference<cps_ir.MutableVariable> reference) {
-    if (reference.definition.host != currentElement) {
-      return parent.getMutableVariableReference(reference);
+  Variable getMutableVariable(cps_ir.MutableVariable mutableVariable) {
+    if (mutableVariable.host != currentElement) {
+      return parent.getMutableVariable(mutableVariable);
     }
-    Variable variable = local2mutable[reference.definition];
-    ++variable.readCount;
-    return variable;
+    return local2mutable[mutableVariable];
+  }
+
+  VariableUse getMutableVariableUse(
+        cps_ir.Reference<cps_ir.MutableVariable> reference) {
+    Variable variable = getMutableVariable(reference.definition);
+    return new VariableUse(variable);
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
@@ -119,15 +122,14 @@ class Builder extends cps_ir.Visitor<Node> {
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
-  Expression getVariableReference(cps_ir.Reference reference) {
+  VariableUse getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
     Variable variable = getVariable(reference.definition);
     if (variable == null) {
       internalError(
           CURRENT_ELEMENT_SPANNABLE,
           "Reference to ${reference.definition} has no register");
     }
-    ++variable.readCount;
-    return variable;
+    return new VariableUse(variable);
   }
 
   ExecutableDefinition build(cps_ir.ExecutableDefinition node) {
@@ -168,14 +170,8 @@ class Builder extends cps_ir.Visitor<Node> {
 
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
-    List<Variable> parameters = <Variable>[];
-    for (cps_ir.Definition p in node.parameters) {
-      Variable parameter = addFunctionParameter(p);
-      assert(parameter != null);
-      ++parameter.writeCount; // Being a parameter counts as a write.
-      parameters.add(parameter);
-    }
-
+    List<Variable> parameters =
+        node.parameters.map(addFunctionParameter).toList();
     Statement body;
     if (!node.isAbstract) {
       returnContinuation = node.body.returnContinuation;
@@ -189,13 +185,8 @@ class Builder extends cps_ir.Visitor<Node> {
 
   ConstructorDefinition buildConstructor(cps_ir.ConstructorDefinition node) {
     currentElement = node.element;
-    List<Variable> parameters = <Variable>[];
-    for (cps_ir.Definition p in node.parameters) {
-      Variable parameter = addFunctionParameter(p);
-      assert(parameter != null);
-      ++parameter.writeCount; // Being a parameter counts as a write.
-      parameters.add(parameter);
-    }
+    List<Variable> parameters =
+        node.parameters.map(addFunctionParameter).toList();
     List<Initializer> initializers;
     Statement body;
     if (!node.isAbstract) {
@@ -219,7 +210,7 @@ class Builder extends cps_ir.Visitor<Node> {
   /// on the list during the rewrite phases.
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
     return new List<Expression>.generate(args.length,
-         (int index) => getVariableReference(args[index]),
+         (int index) => getVariableUse(args[index]),
          growable: false);
   }
 
@@ -280,12 +271,10 @@ class Builder extends cps_ir.Visitor<Node> {
 
     Statement first, current;
     void addAssignment(Variable dst, Variable src) {
-      ++src.readCount;
-      // `dst.writeCount` will be updated by the Assign constructor.
       if (first == null) {
-        first = current = new Assign(dst, src, null);
+        first = current = new Assign(dst, new VariableUse(src), null);
       } else {
-        current = current.next = new Assign(dst, src, null);
+        current = current.next = new Assign(dst, new VariableUse(src), null);
       }
     }
 
@@ -433,14 +422,14 @@ class Builder extends cps_ir.Visitor<Node> {
   }
 
   Statement visitInvokeMethod(cps_ir.InvokeMethod node) {
-    Expression invoke = new InvokeMethod(getVariableReference(node.receiver),
+    Expression invoke = new InvokeMethod(getVariableUse(node.receiver),
                                          node.selector,
                                          translateArguments(node.arguments));
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
-    Expression receiver = getVariableReference(node.receiver);
+    Expression receiver = getVariableUse(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeMethodDirectly(receiver, node.target,
         node.selector, arguments);
@@ -469,17 +458,17 @@ class Builder extends cps_ir.Visitor<Node> {
 
   Statement visitLetMutable(cps_ir.LetMutable node) {
     Variable variable = addMutableVariable(node.variable);
-    Expression value = getVariableReference(node.value);
+    Expression value = getVariableUse(node.value);
     return new Assign(variable, value, visit(node.body), isDeclaration: true);
   }
 
   Expression visitGetMutableVariable(cps_ir.GetMutableVariable node) {
-    return getMutableVariableReference(node.variable);
+    return getMutableVariableUse(node.variable);
   }
 
   Statement visitSetMutableVariable(cps_ir.SetMutableVariable node) {
-    Variable variable = getMutableVariableReference(node.variable);
-    Expression value = getVariableReference(node.value);
+    Variable variable = getMutableVariable(node.variable.definition);
+    Expression value = getVariableUse(node.value);
     return new Assign(variable, value, visit(node.body));
   }
 
@@ -490,7 +479,7 @@ class Builder extends cps_ir.Visitor<Node> {
   }
 
   Statement visitTypeOperator(cps_ir.TypeOperator node) {
-    Expression receiver = getVariableReference(node.receiver);
+    Expression receiver = getVariableUse(node.receiver);
     Expression concat =
         new TypeOperator(receiver, node.type, isTypeTest: node.isTypeTest);
     return continueWithExpression(node.continuation, concat);
@@ -512,9 +501,9 @@ class Builder extends cps_ir.Visitor<Node> {
     cps_ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       assert(node.arguments.length == 1);
-      return new Return(getVariableReference(node.arguments.single));
+      return new Return(getVariableUse(node.arguments.single));
     } else {
-      List<Expression> arguments = translatePhiArguments(node.arguments);
+      List<Variable> arguments = translatePhiArguments(node.arguments);
       return buildPhiAssignments(cont.parameters, arguments,
           () {
             // Translate invocations of recursive and non-recursive
@@ -582,8 +571,8 @@ class Builder extends cps_ir.Visitor<Node> {
         node.type,
         new List<LiteralMapEntry>.generate(node.entries.length, (int index) {
           return new LiteralMapEntry(
-              getVariableReference(node.entries[index].key),
-              getVariableReference(node.entries[index].value));
+              getVariableUse(node.entries[index].key),
+              getVariableUse(node.entries[index].value));
         })
     );
   }
@@ -620,7 +609,7 @@ class Builder extends cps_ir.Visitor<Node> {
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
-    return getVariableReference(node.value);
+    return getVariableUse(node.value);
   }
 }