Added VariableUse expression to tree IR.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 73 matching lines @@
   Variable addMutableVariable(cps_ir.MutableVariable irVariable) {
     if (irVariable.host != currentElement) {
       return parent.addMutableVariable(irVariable);
     }
     assert(!local2mutable.containsKey(irVariable));
     Variable variable = new Variable(currentElement, irVariable.hint);
     local2mutable[irVariable] = variable;
     return variable;
   }
 
-  Variable getMutableVariableReference(
+  Variable getMutableVariable(cps_ir.MutableVariable mutableVariable) {
+    if (mutableVariable.host != currentElement) {
+      return parent.getMutableVariable(mutableVariable);
+    }
+    return local2mutable[mutableVariable];
+  }
+
+  VariableUse getMutableVariableUse(
         cps_ir.Reference<cps_ir.MutableVariable> reference) {
-    if (reference.definition.host != currentElement) {
-      return parent.getMutableVariableReference(reference);
-    }
-    Variable variable = local2mutable[reference.definition];
-    ++variable.readCount;
-    return variable;
+    Variable variable = getMutableVariable(reference.definition);
+    return new VariableUse(variable);
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(cps_ir.Primitive primitive) {
     if (primitive.registerIndex == null) {
       return null; // variable is unused
     }
     List<Variable> variables = local2variables.putIfAbsent(primitive.hint,
         () => <Variable>[]);
     while (variables.length <= primitive.registerIndex) {
       variables.add(new Variable(currentElement, primitive.hint));
     }
     return variables[primitive.registerIndex];
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// 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) {
     if (node is cps_ir.FieldDefinition) {
       return buildField(node);
     } else if (node is cps_ir.ConstructorDefinition) {
       return buildConstructor(node);
     } else {
       assert(dart2js.invariant(
           CURRENT_ELEMENT_SPANNABLE,
@@ skipping 20 matching lines @@
   Variable addFunctionParameter(cps_ir.Definition variable) {
     if (variable is cps_ir.Parameter) {
       return getVariable(variable);
     } else {
       return addMutableVariable(variable as cps_ir.MutableVariable);
     }
   }
 
   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;
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new FunctionDefinition(node.element, parameters,
         body, node.localConstants, node.defaultParameterValues);
   }
 
   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) {
       initializers = node.initializers.map(visit).toList();
       returnContinuation = node.body.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new ConstructorDefinition(node.element, parameters,
         body, initializers, node.localConstants, node.defaultParameterValues);
   }
 
   /// Returns a list of variables corresponding to the arguments to a method
   /// call or similar construct.
   ///
   /// The `readCount` for these variables will be incremented.
   ///
   /// The list will be typed as a list of [Expression] to allow inplace updates
   /// 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);
   }
 
   /// Returns the list of variables corresponding to the arguments to a join
   /// continuation.
   ///
   /// The `readCount` of these variables will not be incremented. Instead,
   /// [buildPhiAssignments] will handle the increment, if necessary.
   List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
     return new List<Variable>.generate(args.length,
@@ skipping 40 matching lines @@
       }
       List<int> list = rightHand[arg];
       if (list == null) {
         rightHand[arg] = list = <int>[];
       }
       list.add(i);
     }
 
     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);
       }
     }
 
     List<Variable> assignmentSrc = new List<Variable>(parameters.length);
     List<bool> done = new List<bool>(parameters.length);
     void visitAssignment(int i) {
       if (done[i] == true) {
         return;
       }
       Variable param = getVariable(parameters[i]);
@@ skipping 127 matching lines @@
   }
 
   Statement visitInvokeStatic(cps_ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments);
     return continueWithExpression(node.continuation, invoke);
   }
 
   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);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitConcatenateStrings(cps_ir.ConcatenateStrings node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression concat = new ConcatenateStrings(arguments);
     return continueWithExpression(node.continuation, concat);
   }
 
   Statement continueWithExpression(cps_ir.Reference continuation,
                                    Expression expression) {
     cps_ir.Continuation cont = continuation.definition;
     if (cont == returnContinuation) {
       return new Return(expression);
     } else {
       assert(cont.parameters.length == 1);
       Function nextBuilder = cont.hasExactlyOneUse ?
           () => visit(cont.body) : () => new Break(labels[cont]);
       return buildContinuationAssignment(cont.parameters.single, expression,
           nextBuilder);
     }
   }
 
   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));
   }
 
   Statement visitDeclareFunction(cps_ir.DeclareFunction node) {
     Variable variable = addMutableVariable(node.variable);
     FunctionDefinition function = makeSubFunction(node.definition);
     return new FunctionDeclaration(variable, function, visit(node.body));
   }
 
   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);
   }
 
   Statement visitInvokeConstructor(cps_ir.InvokeConstructor node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke =
         new InvokeConstructor(node.type, node.target, node.selector, arguments);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeContinuation(cps_ir.InvokeContinuation node) {
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     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
             // continuations differently.
             //   * Non-recursive continuations
             //     - If there is one use, translate the continuation body
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
@@ skipping 47 matching lines @@
     return new LiteralList(
             node.type,
             translateArguments(node.values));
   }
 
   Expression visitLiteralMap(cps_ir.LiteralMap node) {
     return new LiteralMap(
         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));
         })
     );
   }
 
   FunctionDefinition makeSubFunction(cps_ir.FunctionDefinition function) {
     return createInnerBuilder().buildFunction(function);
   }
 
   Node visitCreateFunction(cps_ir.CreateFunction node) {
     FunctionDefinition def = makeSubFunction(node.definition);
@@ skipping 16 matching lines @@
   }
 
   Expression visitContinuation(cps_ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
     // visited.
     internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node.');
     return null;
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
-    return getVariableReference(node.value);
+    return getVariableUse(node.value);
   }
 }