dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/cps_ir_tracer.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 dart2js.ir_tracer;
 
 import 'dart:async' show EventSink;
 import 'cps_ir_nodes.dart' as cps_ir;
 import '../tracer.dart';
 
@@ skipping 119 matching lines @@
     if (IR_TRACE_LET_CONT) {
       String dummy = names.name(node);
       String id = names.name(node.handler);
       printStmt(dummy, "LetHandler $id = <$id>");
     }
     visit(node.body);
   }
 
   visitLetMutable(cps_ir.LetMutable node) {
     String id = names.name(node.variable);
-    printStmt(id, "LetMutable $id = ${formatReference(node.value)}");
+    printStmt(id, "LetMutable $id = ${formatReference(node.valueRef)}");
     visit(node.body);
   }
 
   visitInvokeStatic(cps_ir.InvokeStatic node) {
     String callName = node.selector.name;
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return "InvokeStatic $callName ($args)";
   }
 
   visitInvokeMethod(cps_ir.InvokeMethod node) {
-    String receiver = formatReference(node.receiver);
+    String receiver = formatReference(node.receiverRef);
     String callName = node.selector.name;
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return "InvokeMethod $receiver $callName ($args)";
   }
 
   visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
-    String receiver = formatReference(node.receiver);
+    String receiver = formatReference(node.receiverRef);
     String callName = node.selector.name;
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return "InvokeMethodDirectly $receiver $callName ($args)";
   }
 
   visitInvokeConstructor(cps_ir.InvokeConstructor node) {
     String className = node.target.enclosingClass.name;
     String callName;
     if (node.target.name.isEmpty) {
       callName = '${className}';
     } else {
       callName = '${className}.${node.target.name}';
     }
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return "InvokeConstructor $callName ($args)";
   }
 
   visitThrow(cps_ir.Throw node) {
     String dummy = names.name(node);
-    String value = formatReference(node.value);
+    String value = formatReference(node.valueRef);
     printStmt(dummy, "Throw $value");
   }
 
   visitRethrow(cps_ir.Rethrow node) {
     String dummy = names.name(node);
     printStmt(dummy, "Rethrow");
   }
 
   visitUnreachable(cps_ir.Unreachable node) {
     String dummy = names.name(node);
     printStmt(dummy, 'Unreachable');
   }
 
   visitLiteralList(cps_ir.LiteralList node) {
-    String values = node.values.map(formatReference).join(', ');
+    String values = node.valueRefs.map(formatReference).join(', ');
     return "LiteralList ($values)";
   }
 
   visitTypeCast(cps_ir.TypeCast node) {
-    String value = formatReference(node.value);
-    String args = node.typeArguments.map(formatReference).join(', ');
+    String value = formatReference(node.valueRef);
+    String args = node.typeArgumentRefs.map(formatReference).join(', ');
     return "TypeCast ($value ${node.dartType} ($args))";
   }
 
   visitInvokeContinuation(cps_ir.InvokeContinuation node) {
     String dummy = names.name(node);
-    String kont = formatReference(node.continuation);
-    String args = node.arguments.map(formatReference).join(', ');
+    String kont = formatReference(node.continuationRef);
+    String args = node.argumentRefs.map(formatReference).join(', ');
     printStmt(dummy, "InvokeContinuation $kont ($args)");
   }
 
   visitBranch(cps_ir.Branch node) {
     String dummy = names.name(node);
-    String condition = formatReference(node.condition);
-    String trueCont = formatReference(node.trueContinuation);
-    String falseCont = formatReference(node.falseContinuation);
+    String condition = formatReference(node.conditionRef);
+    String trueCont = formatReference(node.trueContinuationRef);
+    String falseCont = formatReference(node.falseContinuationRef);
     String strict = node.isStrictCheck ? "Strict" : "NonStrict";
     printStmt(dummy, "Branch $condition ($trueCont, $falseCont) $strict");
   }
 
   visitAwait(cps_ir.Await node) {
-    String value = formatReference(node.input);
+    String value = formatReference(node.inputRef);
     return 'Await $value';
   }
 
   visitYield(cps_ir.Yield node) {
     String name = node.hasStar ? 'YieldStar' : 'Yield';
-    String value = formatReference(node.input);
+    String value = formatReference(node.inputRef);
     return '$name $value';
   }
 
   visitSetMutable(cps_ir.SetMutable node) {
-    String variable = names.name(node.variable.definition);
-    String value = formatReference(node.value);
+    String variable = names.name(node.variable);
+    String value = formatReference(node.valueRef);
     return 'SetMutable $variable := $value';
   }
 
   String formatReference(cps_ir.Reference ref) {
     if (ref == null) return 'null';
     cps_ir.Definition target = ref.definition;
     if (target is cps_ir.Continuation && target.isReturnContinuation) {
       return "return"; // Do not generate a name for the return continuation
     } else {
       return names.name(ref.definition);
@@ skipping 10 matching lines @@
 
   visitMutableVariable(cps_ir.MutableVariable node) {
     return "MutableVariable ${names.name(node)}";
   }
 
   visitContinuation(cps_ir.Continuation node) {
     return "Continuation ${names.name(node)}";
   }
 
   visitSetField(cps_ir.SetField node) {
-    String object = formatReference(node.object);
+    String object = formatReference(node.objectRef);
     String field = node.field.name;
-    String value = formatReference(node.value);
+    String value = formatReference(node.valueRef);
     return 'SetField $object.$field = $value';
   }
 
   visitGetField(cps_ir.GetField node) {
-    String object = formatReference(node.object);
+    String object = formatReference(node.objectRef);
     String field = node.field.name;
     String finalFlag = node.isFinal ? 'final' : 'non-final';
     return 'GetField $object.$field $finalFlag';
   }
 
   visitGetStatic(cps_ir.GetStatic node) {
     String element = node.element.name;
     String finalFlag = node.isFinal ? 'final' : 'non-final';
     return 'GetStatic $element $finalFlag';
   }
 
   visitSetStatic(cps_ir.SetStatic node) {
     String element = node.element.name;
-    String value = formatReference(node.value);
+    String value = formatReference(node.valueRef);
     return 'SetStatic $element = $value';
   }
 
   visitGetLazyStatic(cps_ir.GetLazyStatic node) {
     String element = node.element.name;
     String finalFlag = node.isFinal ? 'final' : 'non-final';
     return "GetLazyStatic $element $finalFlag";
   }
 
   visitCreateBox(cps_ir.CreateBox node) {
     return 'CreateBox';
   }
 
   visitCreateInstance(cps_ir.CreateInstance node) {
     String className = node.classElement.name;
-    String arguments = node.arguments.map(formatReference).join(', ');
-    String typeInformation = formatReference(node.typeInformation);
+    String arguments = node.argumentRefs.map(formatReference).join(', ');
+    String typeInformation = formatReference(node.typeInformationRef);
     return 'CreateInstance $className ($arguments) <$typeInformation>';
   }
 
   visitInterceptor(cps_ir.Interceptor node) {
-    return 'Interceptor(${formatReference(node.input)}, '
+    return 'Interceptor(${formatReference(node.inputRef)}, '
            '${node.interceptedClasses})';
   }
 
   visitGetMutable(cps_ir.GetMutable node) {
-    String variable = names.name(node.variable.definition);
+    String variable = names.name(node.variable);
     return 'GetMutable $variable';
   }
 
   visitReadTypeVariable(cps_ir.ReadTypeVariable node) {
     return "ReadTypeVariable ${node.variable.element} "
-        "${formatReference(node.target)}";
+        "${formatReference(node.targetRef)}";
   }
 
   visitReifyRuntimeType(cps_ir.ReifyRuntimeType node) {
-    return "ReifyRuntimeType ${formatReference(node.value)}";
+    return "ReifyRuntimeType ${formatReference(node.valueRef)}";
   }
 
   visitTypeExpression(cps_ir.TypeExpression node) {
     return "TypeExpression ${node.kindAsString} ${node.dartType}"
-        "${node.arguments.map(formatReference).join(', ')}";
+        "${node.argumentRefs.map(formatReference).join(', ')}";
   }
 
   visitCreateInvocationMirror(cps_ir.CreateInvocationMirror node) {
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return "CreateInvocationMirror(${node.selector.name}, $args)";
   }
 
   visitTypeTest(cps_ir.TypeTest node) {
-    String value = formatReference(node.value);
-    String args = node.typeArguments.map(formatReference).join(', ');
+    String value = formatReference(node.valueRef);
+    String args = node.typeArgumentRefs.map(formatReference).join(', ');
     return "TypeTest ($value ${node.dartType} ($args))";
   }
 
   visitTypeTestViaFlag(cps_ir.TypeTestViaFlag node) {
-    String interceptor = formatReference(node.interceptor);
+    String interceptor = formatReference(node.interceptorRef);
     return "TypeTestViaFlag ($interceptor ${node.dartType})";
   }
 
   visitApplyBuiltinOperator(cps_ir.ApplyBuiltinOperator node) {
     String operator = node.operator.toString();
-    String args = node.arguments.map(formatReference).join(', ');
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return 'ApplyBuiltinOperator $operator ($args)';
   }
 
   visitApplyBuiltinMethod(cps_ir.ApplyBuiltinMethod node) {
     String method = node.method.toString();
-    String receiver = formatReference(node.receiver);
-    String args = node.arguments.map(formatReference).join(', ');
+    String receiver = formatReference(node.receiverRef);
+    String args = node.argumentRefs.map(formatReference).join(', ');
     return 'ApplyBuiltinMethod $method $receiver ($args)';
   }
 
   visitForeignCode(cps_ir.ForeignCode node) {
     String id = names.name(node);
-    String arguments = node.arguments.map(formatReference).join(', ');
+    String arguments = node.argumentRefs.map(formatReference).join(', ');
     printStmt(id,
         "ForeignCode ${node.type} ${node.codeTemplate.source} $arguments");
   }
 
   visitGetLength(cps_ir.GetLength node) {
-    String object = formatReference(node.object);
+    String object = formatReference(node.objectRef);
     String finalFlag = node.isFinal ? 'final' : 'non-final';
     return 'GetLength $object $finalFlag';
   }
 
   visitGetIndex(cps_ir.GetIndex node) {
-    String object = formatReference(node.object);
-    String index = formatReference(node.index);
+    String object = formatReference(node.objectRef);
+    String index = formatReference(node.indexRef);
     return 'GetIndex $object $index';
   }
 
   visitSetIndex(cps_ir.SetIndex node) {
-    String object = formatReference(node.object);
-    String index = formatReference(node.index);
-    String value = formatReference(node.value);
+    String object = formatReference(node.objectRef);
+    String index = formatReference(node.indexRef);
+    String value = formatReference(node.valueRef);
     return 'SetIndex $object $index $value';
   }
 
   visitRefinement(cps_ir.Refinement node) {
     String value = formatReference(node.value);
     return 'Refinement $value ${node.refineType}';
   }
 
   visitBoundsCheck(cps_ir.BoundsCheck node) {
-    String object = formatReference(node.object);
-    String index = node.index == null
+    String object = formatReference(node.objectRef);
+    String index = node.indexRef == null
         ? 'no-index'
-        : formatReference(node.index);
-    String length = node.length == null
+        : formatReference(node.indexRef);
+    String length = node.lengthRef == null
         ? 'no-length'
-        : formatReference(node.length);
+        : formatReference(node.lengthRef);
     return 'BoundsCheck $object $index $length ${node.checkString}';
   }
 
   visitReceiverCheck(cps_ir.ReceiverCheck node) {
-    String value = formatReference(node.value);
-    String condition = formatReference(node.condition);
+    String value = formatReference(node.valueRef);
+    String condition = formatReference(node.conditionRef);
     return 'ReceiverCheck $value $condition ${node.selector} '
         '${node.flagString}';
   }
 }
 
 /**
  * Invents (and remembers) names for Continuations, Parameters, etc.
  * The names must match the conventions used by IR Hydra, e.g.
  * Continuations and Functions must have names of form B### since they
  * are visualized as basic blocks.
@@ skipping 90 matching lines @@
   }
 
   void addEdgeToContinuation(cps_ir.Reference continuation) {
     cps_ir.Definition target = continuation.definition;
     if (target is cps_ir.Continuation && !target.isReturnContinuation) {
       currentBlock.addEdgeTo(getBlock(target));
     }
   }
 
   visitInvokeContinuation(cps_ir.InvokeContinuation exp) {
-    addEdgeToContinuation(exp.continuation);
+    addEdgeToContinuation(exp.continuationRef);
   }
 
   visitInvokeStatic(cps_ir.InvokeStatic node) {
     unexpectedNode(node);
   }
 
   visitInvokeMethod(cps_ir.InvokeMethod node) {
     unexpectedNode(node);
   }
 
@@ skipping 12 matching lines @@
   }
 
   visitUnreachable(cps_ir.Unreachable node) {
   }
 
   visitGetLazyStatic(cps_ir.GetLazyStatic node) {
     unexpectedNode(node);
   }
 
   visitBranch(cps_ir.Branch exp) {
-    cps_ir.Continuation trueTarget = exp.trueContinuation.definition;
+    cps_ir.Continuation trueTarget = exp.trueContinuation;
     if (!trueTarget.isReturnContinuation) {
       currentBlock.addEdgeTo(getBlock(trueTarget));
     }
-    cps_ir.Continuation falseTarget = exp.falseContinuation.definition;
+    cps_ir.Continuation falseTarget = exp.falseContinuation;
     if (!falseTarget.isReturnContinuation) {
       currentBlock.addEdgeTo(getBlock(falseTarget));
     }
   }
 
   visitTypeCast(cps_ir.TypeCast node) {
     unexpectedNode(node);
   }
 
   visitContinuation(cps_ir.Continuation c) {
@@ skipping 122 matching lines @@
   }
 
   visitBoundsCheck(cps_ir.BoundsCheck node) {
     unexpectedNode(node);
   }
 
   visitReceiverCheck(cps_ir.ReceiverCheck node) {
     unexpectedNode(node);
   }
 }