dart2js cps: Use definitions by default, not references.

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 '../common.dart';
 import '../constants/values.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../elements/elements.dart';
@@ skipping 378 matching lines @@
 
   NodeCallback visitLetHandler(cps_ir.LetHandler node) => (Statement next) {
     List<Variable> catchParameters =
         node.handler.parameters.map(getVariable).toList();
     Statement catchBody = translateExpression(node.handler.body);
     return new Try(next, catchParameters, catchBody);
   };
 
   NodeCallback visitLetMutable(cps_ir.LetMutable node) {
     Variable variable = addMutableVariable(node.variable);
-    Expression value = getVariableUse(node.value);
+    Expression value = getVariableUse(node.valueRef);
     return (Statement next) => Assign.makeStatement(variable, value, next);
   }
 
   /************************** TAIL EXPRESSIONS  **************************/
   //
   // Visit methods for tail expressions must return a statement directly
   // (not a function like interior and call expressions).
 
   Statement visitThrow(cps_ir.Throw node) {
-    Expression value = getVariableUse(node.value);
+    Expression value = getVariableUse(node.valueRef);
     return new Throw(value);
   }
 
   Statement visitUnreachable(cps_ir.Unreachable node) {
     return new Unreachable();
   }
 
   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;
+    cps_ir.Continuation cont = node.continuation;
     if (cont == returnContinuation) {
-      assert(node.arguments.length == 1);
-      return new Return(getVariableUse(node.arguments.single),
+      assert(node.argumentRefs.length == 1);
+      return new Return(getVariableUse(node.argumentRefs.single),
                         sourceInformation: node.sourceInformation);
     } else {
-      List<Expression> arguments = translateArguments(node.arguments);
+      List<Expression> arguments = translateArguments(node.argumentRefs);
       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
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(getLabel(cont))
                   : new WhileTrue(getLabel(cont),
                                   translateExpression(cont.body));
             } else {
               return cont.hasExactlyOneUse && !node.isEscapingTry
                   ? translateExpression(cont.body)
                   : new Break(getLabel(cont));
             }
           });
     }
   }
 
   /// Translates a branch condition to a tree expression.
   Expression translateCondition(cps_ir.Branch branch) {
-    Expression value = getVariableUse(branch.condition);
+    Expression value = getVariableUse(branch.conditionRef);
     if (branch.isStrictCheck) {
       return new ApplyBuiltinOperator(
           BuiltinOperator.StrictEq,
           <Expression>[value, new Constant(new TrueConstantValue())]);
     } else {
       return value;
     }
   }
 
   Statement visitBranch(cps_ir.Branch node) {
     Expression condition = translateCondition(node);
     Statement thenStatement, elseStatement;
-    cps_ir.Continuation cont = node.trueContinuation.definition;
+    cps_ir.Continuation cont = node.trueContinuation;
     assert(cont.parameters.isEmpty);
     thenStatement = cont.hasExactlyOneUse
         ? translateExpression(cont.body)
         : new Break(labels[cont]);
-    cont = node.falseContinuation.definition;
+    cont = node.falseContinuation;
     assert(cont.parameters.isEmpty);
     elseStatement = cont.hasExactlyOneUse
         ? translateExpression(cont.body)
         : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
 
   /************************** PRIMITIVES  **************************/
   //
   // Visit methods for primitives must return an expression.
   //
 
   Expression visitSetField(cps_ir.SetField node) {
-    return new SetField(getVariableUse(node.object),
+    return new SetField(getVariableUse(node.objectRef),
                         node.field,
-                        getVariableUse(node.value));
+                        getVariableUse(node.valueRef));
   }
 
   Expression visitInterceptor(cps_ir.Interceptor node) {
-    return new Interceptor(getVariableUse(node.input),
+    return new Interceptor(getVariableUse(node.inputRef),
                            node.interceptedClasses,
                            node.sourceInformation);
   }
 
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
-        translateArguments(node.arguments),
-        getVariableUseOrNull(node.typeInformation),
+        translateArguments(node.argumentRefs),
+        getVariableUseOrNull(node.typeInformationRef),
         node.sourceInformation);
   }
 
   Expression visitGetField(cps_ir.GetField node) {
-    return new GetField(getVariableUse(node.object), node.field,
-        objectIsNotNull: !node.object.definition.type.isNullable);
+    return new GetField(getVariableUse(node.objectRef), node.field,
+        objectIsNotNull: !node.object.type.isNullable);
   }
 
   Expression visitCreateBox(cps_ir.CreateBox node) {
     return new CreateBox();
   }
 
   Expression visitCreateInvocationMirror(cps_ir.CreateInvocationMirror node) {
     return new CreateInvocationMirror(
         node.selector,
-        translateArguments(node.arguments));
+        translateArguments(node.argumentRefs));
   }
 
   Expression visitGetMutable(cps_ir.GetMutable node) {
-    return getMutableVariableUse(node.variable);
+    return getMutableVariableUse(node.variableRef);
   }
 
   Expression visitSetMutable(cps_ir.SetMutable node) {
-    Variable variable = getMutableVariable(node.variable.definition);
-    Expression value = getVariableUse(node.value);
+    Variable variable = getMutableVariable(node.variable);
+    Expression value = getVariableUse(node.valueRef);
     return new Assign(variable, value);
   }
 
   Expression visitConstant(cps_ir.Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Expression visitLiteralList(cps_ir.LiteralList node) {
     return new LiteralList(
             node.dartType,
-            translateArguments(node.values));
+            translateArguments(node.valueRefs));
   }
 
   Expression visitReifyRuntimeType(cps_ir.ReifyRuntimeType node) {
     return new ReifyRuntimeType(
-        getVariableUse(node.value), node.sourceInformation);
+        getVariableUse(node.valueRef), node.sourceInformation);
   }
 
   Expression visitReadTypeVariable(cps_ir.ReadTypeVariable node) {
     return new ReadTypeVariable(
         node.variable,
-        getVariableUse(node.target),
+        getVariableUse(node.targetRef),
         node.sourceInformation);
   }
 
   Expression visitTypeExpression(cps_ir.TypeExpression node) {
     return new TypeExpression(
         node.kind,
         node.dartType,
-        node.arguments.map(getVariableUse).toList());
+        node.argumentRefs.map(getVariableUse).toList());
   }
 
   Expression visitTypeTest(cps_ir.TypeTest node) {
-    Expression value = getVariableUse(node.value);
-    List<Expression> typeArgs = translateArguments(node.typeArguments);
+    Expression value = getVariableUse(node.valueRef);
+    List<Expression> typeArgs = translateArguments(node.typeArgumentRefs);
     return new TypeOperator(value, node.dartType, typeArgs, isTypeTest: true);
   }
 
   Expression visitTypeTestViaFlag(cps_ir.TypeTestViaFlag node) {
-    Expression value = getVariableUse(node.interceptor);
+    Expression value = getVariableUse(node.interceptorRef);
     // TODO(sra): Move !! to cps_ir level.
     return new Not(new Not(new GetTypeTestProperty(value, node.dartType)));
   }
 
   Expression visitGetStatic(cps_ir.GetStatic node) {
     return new GetStatic(node.element, node.sourceInformation);
   }
 
   Expression visitSetStatic(cps_ir.SetStatic node) {
     return new SetStatic(
         node.element,
-        getVariableUse(node.value),
+        getVariableUse(node.valueRef),
         node.sourceInformation);
   }
 
   Expression visitApplyBuiltinOperator(cps_ir.ApplyBuiltinOperator node) {
     if (node.operator == BuiltinOperator.IsFalsy) {
-      return new Not(getVariableUse(node.arguments.single));
+      return new Not(getVariableUse(node.argumentRefs.single));
     }
     return new ApplyBuiltinOperator(node.operator,
-                                    translateArguments(node.arguments));
+                                    translateArguments(node.argumentRefs));
   }
 
   Expression visitApplyBuiltinMethod(cps_ir.ApplyBuiltinMethod node) {
     return new ApplyBuiltinMethod(node.method,
-        getVariableUse(node.receiver),
-        translateArguments(node.arguments),
-        receiverIsNotNull: !node.receiver.definition.type.isNullable);
+        getVariableUse(node.receiverRef),
+        translateArguments(node.argumentRefs),
+        receiverIsNotNull: !node.receiver.type.isNullable);
   }
 
   Expression visitGetLength(cps_ir.GetLength node) {
-    return new GetLength(getVariableUse(node.object));
+    return new GetLength(getVariableUse(node.objectRef));
   }
 
   Expression visitGetIndex(cps_ir.GetIndex node) {
-    return new GetIndex(getVariableUse(node.object),
-                        getVariableUse(node.index));
+    return new GetIndex(getVariableUse(node.objectRef),
+                        getVariableUse(node.indexRef));
   }
 
   Expression visitSetIndex(cps_ir.SetIndex node) {
-    return new SetIndex(getVariableUse(node.object),
-                        getVariableUse(node.index),
-                        getVariableUse(node.value));
+    return new SetIndex(getVariableUse(node.objectRef),
+                        getVariableUse(node.indexRef),
+                        getVariableUse(node.valueRef));
   }
 
   Expression visitInvokeStatic(cps_ir.InvokeStatic node) {
-    List<Expression> arguments = translateArguments(node.arguments);
+    List<Expression> arguments = translateArguments(node.argumentRefs);
     return new InvokeStatic(node.target, node.selector, arguments,
                                          node.sourceInformation);
   }
 
   Expression visitInvokeMethod(cps_ir.InvokeMethod node) {
     if (node.callingConvention == cps_ir.CallingConvention.OneShotIntercepted) {
       List<Expression> arguments = new List.generate(
-          1 + node.arguments.length,
-          (n) => getVariableUse(n == 0 ? node.receiver : node.arguments[n - 1]),
+          1 + node.argumentRefs.length,
+          (n) => getVariableUse(n == 0 ? node.receiverRef : node.argumentRefs[n - 1]),
           growable: false);
       return new OneShotInterceptor(node.selector, node.mask, arguments,
           node.sourceInformation);
     }
     InvokeMethod invoke = new InvokeMethod(
-        getVariableUse(node.receiver),
+        getVariableUse(node.receiverRef),
         node.selector,
         node.mask,
-        translateArguments(node.arguments),
+        translateArguments(node.argumentRefs),
         node.sourceInformation);
     // Sometimes we know the Dart receiver is non-null because it has been
     // refined, which implies that the JS receiver also can not be null at the
     // use-site.  Interceptors are not refined, so this information is not
     // always available on the JS receiver.
     // Also check the JS receiver's type, however, because sometimes we know an
     // interceptor is non-null because it intercepts JSNull.
     invoke.receiverIsNotNull =
         !node.dartReceiver.type.isNullable ||
-        !node.receiver.definition.type.isNullable;
+        !node.receiver.type.isNullable;
     return invoke;
   }
 
   Expression visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
-    Expression receiver = getVariableUse(node.receiver);
-    List<Expression> arguments = translateArguments(node.arguments);
+    Expression receiver = getVariableUse(node.receiverRef);
+    List<Expression> arguments = translateArguments(node.argumentRefs);
     return new InvokeMethodDirectly(receiver, node.target,
         node.selector, arguments, node.sourceInformation);
   }
 
   Expression visitTypeCast(cps_ir.TypeCast node) {
-    Expression value = getVariableUse(node.value);
-    List<Expression> typeArgs = translateArguments(node.typeArguments);
+    Expression value = getVariableUse(node.valueRef);
+    List<Expression> typeArgs = translateArguments(node.typeArgumentRefs);
     return new TypeOperator(value, node.dartType, typeArgs, isTypeTest: false);
   }
 
   Expression visitInvokeConstructor(cps_ir.InvokeConstructor node) {
-    List<Expression> arguments = translateArguments(node.arguments);
+    List<Expression> arguments = translateArguments(node.argumentRefs);
     return new InvokeConstructor(
         node.dartType,
         node.target,
         node.selector,
         arguments,
         node.sourceInformation);
   }
 
   visitForeignCode(cps_ir.ForeignCode node) {
     List<Expression> arguments =
-        node.arguments.map(getVariableUse).toList(growable: false);
-    List<bool> nullableArguments = node.arguments
+        node.argumentRefs.map(getVariableUse).toList(growable: false);
+    List<bool> nullableArguments = node.argumentRefs
         .map((argument) => argument.definition.type.isNullable)
         .toList(growable: false);
     if (node.codeTemplate.isExpression) {
       return new ForeignExpression(
           node.codeTemplate,
           node.type,
           arguments,
           node.nativeBehavior,
           nullableArguments,
           node.dependency);
     } else {
       return (Statement next) {
         assert(next is Unreachable); // We are not using the `next` statement.
         return new ForeignStatement(
             node.codeTemplate,
             node.type,
             arguments,
             node.nativeBehavior,
             nullableArguments,
             node.dependency);
       };
     }
   }
 
   visitReceiverCheck(cps_ir.ReceiverCheck node) => (Statement next) {
     // The CPS IR uses 'isNullCheck' because the semantics are important.
     // In the Tree IR, syntax is more important, so the receiver check uses
     // "useInvoke" to denote if an invocation should be emitted.
     return new ReceiverCheck(
-        condition: getVariableUseOrNull(node.condition),
-        value: getVariableUse(node.value),
+        condition: getVariableUseOrNull(node.conditionRef),
+        value: getVariableUse(node.valueRef),
         selector: node.selector,
         useSelector: node.useSelector,
         useInvoke: !node.isNullCheck,
         next: next,
         sourceInformation: node.sourceInformation);
   };
 
   Expression visitGetLazyStatic(cps_ir.GetLazyStatic node) {
     return new GetStatic.lazy(node.element, node.sourceInformation);
   }
 
   @override
   NodeCallback visitYield(cps_ir.Yield node) {
     return (Statement next) {
-      return new Yield(getVariableUse(node.input), node.hasStar, next);
+      return new Yield(getVariableUse(node.inputRef), node.hasStar, next);
     };
   }
 
   @override
   Expression visitAwait(cps_ir.Await node) {
-    return new Await(getVariableUse(node.input));
+    return new Await(getVariableUse(node.inputRef));
   }
 
   @override
   visitRefinement(cps_ir.Refinement node) {
     return (Statement next) => next; // Compile to nothing.
   }
 
   /********** UNUSED VISIT METHODS *************/
 
   unexpectedNode(cps_ir.Node node) {
     internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node');
   }
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     unexpectedNode(node);
   }
   visitParameter(cps_ir.Parameter node) => unexpectedNode(node);
   visitContinuation(cps_ir.Continuation node) => unexpectedNode(node);
   visitMutableVariable(cps_ir.MutableVariable node) => unexpectedNode(node);
   visitRethrow(cps_ir.Rethrow node) => unexpectedNode(node);
   visitBoundsCheck(cps_ir.BoundsCheck node) => unexpectedNode(node);
 }