dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
@@ skipping 249 matching lines @@
   bool get isSafeForElimination;
 
   /// True if time-of-evaluation is irrelevant for the given primitive,
   /// assuming its inputs are the same values.
   bool get isSafeForReordering;
 
   /// The source information associated with this primitive.
   // TODO(johnniwinther): Require source information for all primitives.
   SourceInformation get sourceInformation => null;
 
-  /// If this is a [Refinement], [BoundsCheck] or [ReceiverCheck] node, returns the
-  /// value being refined, the indexable object being checked, or the value
+  /// If this is a [Refinement], [BoundsCheck] or [ReceiverCheck] node, returns
+  /// the value being refined, the indexable object being checked, or the value
   /// that was checked to be non-null, respectively.
   ///
   /// Those instructions all return the corresponding operand directly, and
   /// this getter can be used to get (closer to) where the value came from.
   //
   // TODO(asgerf): Also do this for [TypeCast]?
   Primitive get effectiveDefinition => this;
 
   /// Like [effectiveDefinition] but only unfolds [Refinement] nodes.
   Primitive get unrefined => this;
@@ skipping 207 matching lines @@
 ///
 /// let mutable v = P in E
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  They are therefore not [Primitive]s and not bound by [LetPrim]
 /// to prevent unrestricted use of references to them.  During one-pass
 /// construction, a [LetMutable] with an empty body is use to represent the
 /// one-hole context 'let mutable v = P in []'.
 class LetMutable extends InteriorExpression {
   final MutableVariable variable;
-  final Reference<Primitive> value;
+  final Reference<Primitive> valueRef;

[sra1, 2016/03/01 17:59:53]

valueReference

   Expression body;
 
+  Primitive get value => valueRef.definition;
+
   LetMutable(this.variable, Primitive value)
-      : this.value = new Reference<Primitive>(value);
+      : this.valueRef = new Reference<Primitive>(value);
 
   Expression plug(Expression expr) {
     return body = expr;
   }
 
   accept(BlockVisitor visitor) => visitor.visitLetMutable(this);
 
   void setParentPointers() {
     variable.parent = this;
-    value.parent = this;
+    valueRef.parent = this;
     if (body != null) body.parent = this;
   }
 }
 
 enum CallingConvention {
   /// JS receiver is the Dart receiver, there are no extra arguments.
   ///
   /// This includes cases (e.g., static functions, constructors) where there
   /// is no receiver.
   ///
@@ skipping 13 matching lines @@
   /// JS receiver is the Dart receiver, there are no extra arguments.
   ///
   /// Compiles to a one-shot interceptor, e.g: `J.bar$1(foo, x)`
   OneShotIntercepted,
 }
 
 /// Base class of function invocations.
 ///
 /// This class defines the common interface of function invocations.
 abstract class InvocationPrimitive extends UnsafePrimitive {
-  Reference<Primitive> get receiver => null;
-  List<Reference<Primitive>> get arguments;
-  SourceInformation get sourceInformation;
+  Reference<Primitive> get receiverRef => null;

[sra1, 2016/03/01 17:59:53]

receiverReference

+  Primitive get receiver => receiverRef?.definition;
 
-  Reference<Primitive> get dartReceiverReference => null;
-  Primitive get dartReceiver => dartReceiverReference.definition;
+  List<Reference<Primitive>> get argumentRefs;

[sra1, 2016/03/01 17:59:53]

argumentReferences

+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);

[sra1, 2016/03/01 17:59:53]

I find it a surprising API choice that `arguments` is not indexable.
I understand why but if I was learning this code it would be confusing.

+
+  Reference<Primitive> get dartReceiverRef => null;
+  Primitive get dartReceiver => dartReceiverRef?.definition;
 
   CallingConvention get callingConvention => CallingConvention.Normal;
 
   Reference<Primitive> dartArgumentReference(int n) {
     switch (callingConvention) {
       case CallingConvention.Normal:
       case CallingConvention.OneShotIntercepted:
-        return arguments[n];
+        return argumentRefs[n];
 
       case CallingConvention.Intercepted:
       case CallingConvention.DummyIntercepted:
-        return arguments[n + 1];
+        return argumentRefs[n + 1];
     }
   }
 
   Primitive dartArgument(int n) => dartArgumentReference(n).definition;
 
   int get dartArgumentsLength =>
-      arguments.length -
+      argumentRefs.length -
       (callingConvention == CallingConvention.Intercepted ||
           callingConvention == CallingConvention.DummyIntercepted ? 1 : 0);
+
+  SourceInformation get sourceInformation;
 }
 
 /// Invoke a static function.
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur at the end of [arguments] list, in normalized order.
 ///
 /// Discussion:
 /// All information in the [selector] is technically redundant; it will likely
 /// be removed.
 class InvokeStatic extends InvocationPrimitive {
   final FunctionElement target;
   final Selector selector;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
                List<Primitive> args,
                [this.sourceInformation])
-      : arguments = _referenceList(args);
+      : argumentRefs = _referenceList(args);
 
   InvokeStatic.byReference(this.target,
                            this.selector,
-                           this.arguments,
+                           this.argumentRefs,
                            [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 }
 
 /// Invoke a method on an object.
 ///
 /// This includes getters, setters, operators, and index getter/setters.
 ///
 /// Tearing off a method is treated like a getter invocation (getters and
 /// tear-offs cannot be distinguished at compile-time).
 ///
 /// The [selector] records the names of named arguments. The value of named
 /// arguments occur at the end of the [arguments] list, in normalized order.
 class InvokeMethod extends InvocationPrimitive {
-  Reference<Primitive> receiver;
+  Reference<Primitive> receiverRef;
   Selector selector;
   TypeMask mask;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
   CallingConvention callingConvention = CallingConvention.Normal;
 
-  Reference<Primitive> get dartReceiverReference {
+  Reference<Primitive> get dartReceiverRef {
     return callingConvention == CallingConvention.Intercepted
-        ? arguments[0]
-        : receiver;
+        ? argumentRefs[0]
+        : receiverRef;
   }
 
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
   InvokeMethod(Primitive receiver,
                this.selector,
                this.mask,
                List<Primitive> arguments,
                {this.sourceInformation,
                 this.callingConvention: CallingConvention.Normal})
-      : this.receiver = new Reference<Primitive>(receiver),
-        this.arguments = _referenceList(arguments);
+      : this.receiverRef = new Reference<Primitive>(receiver),
+        this.argumentRefs = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    receiver.parent = this;
-    _setParentsOnList(arguments, this);
+    receiverRef.parent = this;
+    _setParentsOnList(argumentRefs, this);
   }
 }
 
 /// Invoke [target] on [receiver], bypassing dispatch and override semantics.
 ///
 /// That is, if [receiver] is an instance of a class that overrides [target]
 /// with a different implementation, the overriding implementation is bypassed
 /// and [target]'s implementation is invoked.
 ///
 /// As with [InvokeMethod], this can be used to invoke a method, operator,
 /// getter, setter, or index getter/setter.
 ///
 /// If it is known that [target] does not use its receiver argument, then
 /// [receiver] may refer to a null constant primitive. This happens for direct
 /// invocations to intercepted methods, where the effective receiver is instead
 /// passed as a formal parameter.
 ///
 /// TODO(sra): Review. A direct call to a method that is mixed into a native
 /// class will still require an explicit argument.
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur at the end of [arguments] list, in normalized order.
 class InvokeMethodDirectly extends InvocationPrimitive {
-  Reference<Primitive> receiver;
+  Reference<Primitive> receiverRef;
   final FunctionElement target;
   final Selector selector;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
   CallingConvention callingConvention;
 
-  Reference<Primitive> get dartReceiverReference {
+  Reference<Primitive> get dartReceiverRef {
     return callingConvention == CallingConvention.Intercepted
-        ? arguments[0]
-        : receiver;
+        ? argumentRefs[0]
+        : receiverRef;
   }
 
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
                        List<Primitive> arguments,
                        this.sourceInformation,
                        {this.callingConvention: CallingConvention.Normal})
-      : this.receiver = new Reference<Primitive>(receiver),
-        this.arguments = _referenceList(arguments);
+      : this.receiverRef = new Reference<Primitive>(receiver),
+        this.argumentRefs = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    receiver.parent = this;
-    _setParentsOnList(arguments, this);
+    receiverRef.parent = this;
+    _setParentsOnList(argumentRefs, this);
   }
 
   bool get isConstructorBodyCall => target is ConstructorBodyElement;
   bool get isTearOff => selector.isGetter && !target.isGetter;
 }
 
 /// Non-const call to a constructor.
 ///
 /// The [target] may be a generative constructor (forwarding or normal)
 /// or a non-redirecting factory.
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur in the [arguments] list, in normalized order.
 ///
 /// Last in the [arguments] list, after the mandatory and optional arguments,
 /// the internal representation of each type argument occurs, unless it could
 /// be determined at build-time that the constructed class has no need for its
 /// runtime type information.
 ///
 /// Note that [InvokeConstructor] does it itself allocate an object.
 /// The invoked constructor will do that using [CreateInstance].
 class InvokeConstructor extends InvocationPrimitive {
   final DartType dartType;
   final ConstructorElement target;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
   final Selector selector;
   final SourceInformation sourceInformation;
 
   /// If non-null, this is an allocation site-specific type that is potentially
   /// better than the inferred return type of [target].
   ///
   /// In particular, container type masks depend on the allocation site and
   /// can therefore not be inferred solely based on the call target.
   TypeMask allocationSiteType;
 
   InvokeConstructor(this.dartType,
                     this.target,
                     this.selector,
                     List<Primitive> args,
                     this.sourceInformation,
                     {this.allocationSiteType})
-      : arguments = _referenceList(args);
+      : argumentRefs = _referenceList(args);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 }
 
 /// An alias for [value] in a context where the value is known to satisfy
 /// [type].
 ///
 /// Refinement nodes are inserted before the type propagator pass and removed
 /// afterwards, so as not to complicate passes that don't reason about types,
 /// but need to reason about value references being identical (i.e. referring
 /// to the same primitive).
@@ skipping 43 matching lines @@
 ///
 /// The [index] reference may be null if there are no checks to perform,
 /// and the [length] reference may be null if there is no upper bound or
 /// emptiness check.
 ///
 /// If a separate code motion guard for the index is required, e.g. because it
 /// must be known to be non-negative in an operator that does not involve
 /// [object], a [Refinement] can be created for it with the non-negative integer
 /// type.
 class BoundsCheck extends Primitive {
-  final Reference<Primitive> object;
-  Reference<Primitive> index;
-  Reference<Primitive> length;
+  final Reference<Primitive> objectRef;
+  Reference<Primitive> indexRef;
+  Reference<Primitive> lengthRef;
   int checks;
   final SourceInformation sourceInformation;
 
+  Primitive get object => objectRef.definition;
+  Primitive get index => indexRef?.definition;
+  Primitive get length => lengthRef?.definition;
+
   /// If true, check that `index >= 0`.
   bool get hasLowerBoundCheck => checks & LOWER_BOUND != 0;
 
   /// If true, check that `index < object.length`.
   bool get hasUpperBoundCheck => checks & UPPER_BOUND != 0;
 
   /// If true, check that `object.length !== 0`.
   ///
   /// Equivalent to a lower bound check with `object.length - 1` as the index,
   /// but this check is faster.
@@ skipping 13 matching lines @@
 
   static const int UPPER_BOUND = 1 << 0;
   static const int LOWER_BOUND = 1 << 1;
   static const int EMPTINESS = 1 << 2; // See [hasEmptinessCheck].
   static const int INTEGER = 1 << 3; // Check if index is an int.
   static const int BOTH_BOUNDS = UPPER_BOUND | LOWER_BOUND;
   static const int NONE = 0;
 
   BoundsCheck(Primitive object, Primitive index, Primitive length,
       [this.checks = BOTH_BOUNDS, this.sourceInformation])
-      : this.object = new Reference<Primitive>(object),
-        this.index = new Reference<Primitive>(index),
-        this.length = length == null ? null : new Reference<Primitive>(length);
+      : this.objectRef = new Reference<Primitive>(object),
+        this.indexRef = new Reference<Primitive>(index),
+        this.lengthRef = _optionalReference(length);
 
   BoundsCheck.noCheck(Primitive object, [this.sourceInformation])
-      : this.object = new Reference<Primitive>(object),
+      : this.objectRef = new Reference<Primitive>(object),
         this.checks = NONE;
 
   accept(Visitor visitor) => visitor.visitBoundsCheck(this);
 
   void setParentPointers() {
-    object.parent = this;
-    if (index != null) {
-      index.parent = this;
+    objectRef.parent = this;
+    if (indexRef != null) {
+      indexRef.parent = this;
     }
-    if (length != null) {
-      length.parent = this;
+    if (lengthRef != null) {
+      lengthRef.parent = this;
     }
   }
 
   String get checkString {
     if (hasNoChecks) return 'no-check';
     return [hasUpperBoundCheck ? 'upper' : null,
         hasLowerBoundCheck ? 'lower' : null,
         hasEmptinessCheck ? 'emptiness' : null,
         hasIntegerCheck ? 'integer' : null,
         'check']
         .where((x) => x != null).join('-');
   }
 
   bool get isSafeForElimination => checks == NONE;
   bool get isSafeForReordering => false;
   bool get hasValue => true; // Can be referenced to restrict code motion.
 
-  Primitive get effectiveDefinition => object.definition.effectiveDefinition;
+  Primitive get effectiveDefinition => object.effectiveDefinition;
 }
 
 /// Throw a [NoSuchMethodError] if [value] cannot respond to [selector].
 ///
 /// Returns [value] so this can be used to restrict code motion.
 ///
 /// The check can take one of three forms:
 ///
 ///     value.toString;
 ///     value.selectorName;
 ///     value.selectorName();    (should only be used if check always fails)
 ///
 /// The first two forms are used when it is known that only null fails the
 /// check.  Additionally, the check may be guarded by a [condition], allowing
 /// for three more forms:
 ///
 ///     if (condition) value.toString;          (this form is valid but unused)
 ///     if (condition) value.selectorName;
 ///     if (condition) value.selectorName();
 ///
 /// The condition must be true if and only if the check should fail. It should
 /// ideally be of a form understood by JS engines, e.g. a `typeof` test.
 ///
 /// If [useSelector] is false, the first form instead becomes `value.toString;`.
 /// This form is faster when the value is non-null and the accessed property has
 /// been removed by tree shaking.
 ///
 /// [selector] may not be one of the selectors implemented by the null object.
 class ReceiverCheck extends Primitive {
-  final Reference<Primitive> value;
+  final Reference<Primitive> valueRef;
   final Selector selector;
   final SourceInformation sourceInformation;
-  final Reference<Primitive> condition;
+  final Reference<Primitive> conditionRef;
   final int _flags;
 
+  Primitive get value => valueRef.definition;
+  Primitive get condition => conditionRef?.definition;
+
   static const int _USE_SELECTOR = 1 << 0;
   static const int _NULL_CHECK = 1 << 1;
 
   /// True if the selector name should be used in the check; otherwise
   /// `toString` will be used.
   bool get useSelector => _flags & _USE_SELECTOR != 0;
 
   /// True if null is the only possible input that cannot respond to [selector].
   bool get isNullCheck => _flags & _NULL_CHECK != 0;
 
 
   /// Constructor for creating checks in arbitrary configurations.
   ///
   /// Consider using one of the named constructors instead.
   ///
   /// [useSelector] and [isNullCheck] are mandatory named arguments.
   ReceiverCheck(Primitive value, this.selector, this.sourceInformation,
         {Primitive condition, bool useSelector, bool isNullCheck})
-      : value = new Reference<Primitive>(value),
-        condition = _optionalReference(condition),
+      : valueRef = new Reference<Primitive>(value),
+        conditionRef = _optionalReference(condition),
         _flags = (useSelector ? _USE_SELECTOR : 0) |
                  (isNullCheck ? _NULL_CHECK : 0);
 
   /// Simplified constructor for building null checks.
   ///
   /// Null must be the only possible input value that does not respond to
   /// [selector].
   ReceiverCheck.nullCheck(
         Primitive value,
         Selector selector,
@@ skipping 22 matching lines @@
             useSelector: true,
             isNullCheck: false);
 
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
   bool get hasValue => true;
 
   accept(Visitor visitor) => visitor.visitReceiverCheck(this);
 
   void setParentPointers() {
-    value.parent = this;
-    if (condition != null) {
-      condition.parent = this;
+    valueRef.parent = this;
+    if (conditionRef != null) {
+      conditionRef.parent = this;
     }
   }
 
-  Primitive get effectiveDefinition => value.definition.effectiveDefinition;
+  Primitive get effectiveDefinition => value.effectiveDefinition;
 
   String get nullCheckString => isNullCheck ? 'null-check' : 'general-check';
   String get useSelectorString => useSelector ? 'use-selector' : 'no-selector';
   String get flagString => '$nullCheckString $useSelectorString';
 }
 
 /// An "is" type test.
 ///
 /// Returns `true` if [value] is an instance of [dartType].
 ///
 /// [type] must not be the [Object], `dynamic` or [Null] types (though it might
 /// be a type variable containing one of these types). This design is chosen
 /// to simplify code generation for type tests.
 class TypeTest extends Primitive {
-  Reference<Primitive> value;
+  Reference<Primitive> valueRef;
   final DartType dartType;
 
   /// If [dartType] is an [InterfaceType], this holds the internal
   /// representation of the type arguments to [dartType]. Since these may
   /// reference type variables from the enclosing class, they are not constant.
   ///
   /// If [dartType] is a [TypeVariableType], this is a singleton list with the
   /// internal representation of the type held in that type variable.
   ///
   /// If [dartType] is a [FunctionType], this is a singleton list with the
   /// internal representation of that type,
   ///
   /// Otherwise the list is empty.
-  final List<Reference<Primitive>> typeArguments;
+  final List<Reference<Primitive>> typeArgumentRefs;
+
+  Primitive get value => valueRef.definition;
+  Primitive typeArgument(int n) => typeArgumentRefs[n].definition;
+  Iterable<Primitive> get typeArguments => _dereferenceList(typeArgumentRefs);
 
   TypeTest(Primitive value,
            this.dartType,
            List<Primitive> typeArguments)
-      : this.value = new Reference<Primitive>(value),
-        this.typeArguments = _referenceList(typeArguments);
+      : this.valueRef = new Reference<Primitive>(value),
+        this.typeArgumentRefs = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeTest(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    value.parent = this;
-    _setParentsOnList(typeArguments, this);
+    valueRef.parent = this;
+    _setParentsOnList(typeArgumentRefs, this);
   }
 }
 
 /// An "is" type test for a raw type, performed by testing a flag property.
 ///
 /// Returns `true` if [interceptor] is for [dartType].
 class TypeTestViaFlag extends Primitive {
-  Reference<Primitive> interceptor;
+  Reference<Primitive> interceptorRef;
   final DartType dartType;
 
+  Primitive get interceptor => interceptorRef.definition;
+
   TypeTestViaFlag(Primitive interceptor, this.dartType)
-      : this.interceptor = new Reference<Primitive>(interceptor);
+      : this.interceptorRef = new Reference<Primitive>(interceptor);
 
   accept(Visitor visitor) => visitor.visitTypeTestViaFlag(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    interceptor.parent = this;
+    interceptorRef.parent = this;
   }
 }
 
 /// An "as" type cast.
 ///
 /// If [value] is `null` or is an instance of [type], [continuation] is invoked
 /// with [value] as argument. Otherwise, a [CastError] is thrown.
 ///
 /// Discussion:
 /// The parameter to [continuation] is redundant since it will always equal
 /// [value], which is typically in scope in the continuation. However, it might
 /// simplify type propagation, since a better type can be computed for the
 /// continuation parameter without needing flow-sensitive analysis.
 class TypeCast extends UnsafePrimitive {
-  Reference<Primitive> value;
+  Reference<Primitive> valueRef;
   final DartType dartType;
 
   /// See the corresponding field on [TypeTest].
-  final List<Reference<Primitive>> typeArguments;
+  final List<Reference<Primitive>> typeArgumentRefs;
+
+  Primitive get value => valueRef.definition;
+  Primitive typeArgument(int n) => typeArgumentRefs[n].definition;
+  Iterable<Primitive> get typeArguments => _dereferenceList(typeArgumentRefs);
 
   TypeCast(Primitive value,
            this.dartType,
            List<Primitive> typeArguments)
-      : this.value = new Reference<Primitive>(value),
-        this.typeArguments = _referenceList(typeArguments);
+      : this.valueRef = new Reference<Primitive>(value),
+        this.typeArgumentRefs = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeCast(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    value.parent = this;
-    _setParentsOnList(typeArguments, this);
+    valueRef.parent = this;
+    _setParentsOnList(typeArgumentRefs, this);
   }
 }
 
 /// Apply a built-in operator.
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinOperator extends Primitive {
   BuiltinOperator operator;
-  List<Reference<Primitive>> arguments;
+  List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
+
   ApplyBuiltinOperator(this.operator,
                        List<Primitive> arguments,
                        this.sourceInformation)
-      : this.arguments = _referenceList(arguments);
+      : this.argumentRefs = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitApplyBuiltinOperator(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 }
 
 /// Apply a built-in method.
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinMethod extends Primitive {
   BuiltinMethod method;
-  Reference<Primitive> receiver;
-  List<Reference<Primitive>> arguments;
+  Reference<Primitive> receiverRef;
+  List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
+  Primitive get receiver => receiverRef.definition;
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
+
   bool receiverIsNotNull;
 
   ApplyBuiltinMethod(this.method,
                      Primitive receiver,
                      List<Primitive> arguments,
                      this.sourceInformation,
                      {this.receiverIsNotNull: false})
-      : this.receiver = new Reference<Primitive>(receiver),
-        this.arguments = _referenceList(arguments);
+      : this.receiverRef = new Reference<Primitive>(receiver),
+        this.argumentRefs = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitApplyBuiltinMethod(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
-    receiver.parent = this;
-    _setParentsOnList(arguments, this);
+    receiverRef.parent = this;
+    _setParentsOnList(argumentRefs, this);
   }
 
   int get effects => getEffectsOfBuiltinMethod(method);
 }
 
 /// Throw a value.
 ///
 /// Throw is an expression, i.e., it always occurs in tail position with
 /// respect to a body or expression.
 class Throw extends TailExpression {
-  Reference<Primitive> value;
+  Reference<Primitive> valueRef;
 
-  Throw(Primitive value) : value = new Reference<Primitive>(value);
+  Primitive get value => valueRef.definition;
+
+  Throw(Primitive value) : valueRef = new Reference<Primitive>(value);
 
   accept(BlockVisitor visitor) => visitor.visitThrow(this);
 
   void setParentPointers() {
-    value.parent = this;
+    valueRef.parent = this;
   }
 }
 
 /// Rethrow
 ///
 /// Rethrow can only occur inside a continuation bound by [LetHandler].  It
 /// implicitly throws the exception parameter of the enclosing handler with
 /// the same stack trace as the enclosing handler.
 class Rethrow extends TailExpression {
   accept(BlockVisitor visitor) => visitor.visitRethrow(this);
@@ skipping 10 matching lines @@
 }
 
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutable extends Primitive {
-  final Reference<MutableVariable> variable;
+  final Reference<MutableVariable> variableRef;
+
+  MutableVariable get variable => variableRef.definition;
 
   GetMutable(MutableVariable variable)
-      : this.variable = new Reference<MutableVariable>(variable);
+      : this.variableRef = new Reference<MutableVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitGetMutable(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
-    variable.parent = this;
+    variableRef.parent = this;
   }
 }
 
 /// Assign a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  This can be seen as a dereferencing assignment:
 ///
 ///   { [variable] := [value]; [body] }
 class SetMutable extends Primitive {
-  final Reference<MutableVariable> variable;
-  final Reference<Primitive> value;
+  final Reference<MutableVariable> variableRef;
+  final Reference<Primitive> valueRef;
+
+  MutableVariable get variable => variableRef.definition;
+  Primitive get value => valueRef.definition;
 
   SetMutable(MutableVariable variable, Primitive value)
-      : this.variable = new Reference<MutableVariable>(variable),
-        this.value = new Reference<Primitive>(value);
+      : this.variableRef = new Reference<MutableVariable>(variable),
+        this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutable(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
-    variable.parent = this;
-    value.parent = this;
+    variableRef.parent = this;
+    valueRef.parent = this;
   }
 }
 
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends TailExpression {
-  Reference<Continuation> continuation;
-  List<Reference<Primitive>> arguments;
+  Reference<Continuation> continuationRef;
+  List<Reference<Primitive>> argumentRefs;
   SourceInformation sourceInformation;
 
+  Continuation get continuation => continuationRef.definition;
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
+
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
   /// True if this invocation escapes from the body of a [LetHandler]
   /// (i.e. a try block). Notably, such an invocation cannot be inlined.
   bool isEscapingTry;
 
   InvokeContinuation(Continuation cont, List<Primitive> args,
                      {this.isRecursive: false,
                       this.isEscapingTry: false,
                       this.sourceInformation})
-      : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
+      : continuationRef = new Reference<Continuation>(cont),
+        argumentRefs = _referenceList(args) {
     assert(cont.parameters == null || cont.parameters.length == args.length);
     if (isRecursive) cont.isRecursive = true;
   }
 
   /// A continuation invocation whose target and arguments will be filled
   /// in later.
   ///
   /// Used as a placeholder for a jump whose target is not yet created
   /// (e.g., in the translation of break and continue).
   InvokeContinuation.uninitialized({this.isRecursive: false,
                                     this.isEscapingTry: false})
-      : continuation = null,
-        arguments = null,
+      : continuationRef = null,
+        argumentRefs = null,
         sourceInformation = null;
 
   accept(BlockVisitor visitor) => visitor.visitInvokeContinuation(this);
 
   void setParentPointers() {
-    if (continuation != null) continuation.parent = this;
-    if (arguments != null) _setParentsOnList(arguments, this);
+    if (continuationRef != null) continuationRef.parent = this;
+    if (argumentRefs != null) _setParentsOnList(argumentRefs, this);
   }
 }
 
 /// Choose between a pair of continuations based on a condition value.
 ///
 /// The two continuations must not declare any parameters.
 class Branch extends TailExpression {
-  final Reference<Primitive> condition;
-  final Reference<Continuation> trueContinuation;
-  final Reference<Continuation> falseContinuation;
+  final Reference<Primitive> conditionRef;
+  final Reference<Continuation> trueContinuationRef;
+  final Reference<Continuation> falseContinuationRef;
+
+  Primitive get condition => conditionRef.definition;
+  Continuation get trueContinuation => trueContinuationRef.definition;
+  Continuation get falseContinuation => falseContinuationRef.definition;
 
   /// If true, only the value `true` satisfies the condition. Otherwise, any
   /// truthy value satisfies the check.
   ///
   /// Non-strict checks are preferable when the condition is known to be a
   /// boolean.
   bool isStrictCheck;
 
   Branch(Primitive condition,
          Continuation trueCont,
          Continuation falseCont,
          {bool strict})
-      : this.condition = new Reference<Primitive>(condition),
-        trueContinuation = new Reference<Continuation>(trueCont),
-        falseContinuation = new Reference<Continuation>(falseCont),
+      : this.conditionRef = new Reference<Primitive>(condition),
+        trueContinuationRef = new Reference<Continuation>(trueCont),
+        falseContinuationRef = new Reference<Continuation>(falseCont),
         isStrictCheck = strict {
     assert(strict != null);
   }
 
   Branch.strict(Primitive condition,
                 Continuation trueCont,
                 Continuation falseCont)
         : this(condition, trueCont, falseCont, strict: true);
 
   Branch.loose(Primitive condition,
                Continuation trueCont,
                Continuation falseCont)
       : this(condition, trueCont, falseCont, strict: false);
 
   accept(BlockVisitor visitor) => visitor.visitBranch(this);
 
   void setParentPointers() {
-    condition.parent = this;
-    trueContinuation.parent = this;
-    falseContinuation.parent = this;
+    conditionRef.parent = this;
+    trueContinuationRef.parent = this;
+    falseContinuationRef.parent = this;
   }
 }
 
 /// Directly assigns to a field on a given object.
 class SetField extends Primitive {
-  final Reference<Primitive> object;
+  final Reference<Primitive> objectRef;
   FieldElement field;
-  final Reference<Primitive> value;
+  final Reference<Primitive> valueRef;
+
+  Primitive get object => objectRef.definition;
+  Primitive get value => valueRef.definition;
 
   SetField(Primitive object, this.field, Primitive value)
-      : this.object = new Reference<Primitive>(object),
-        this.value = new Reference<Primitive>(value);
+      : this.objectRef = new Reference<Primitive>(object),
+        this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetField(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
-    object.parent = this;
-    value.parent = this;
+    objectRef.parent = this;
+    valueRef.parent = this;
   }
 
   int get effects => Effects.changesInstanceField;
 }
 
 /// Directly reads from a field on a given object.
 ///
 /// The [object] must either be `null` or an object that has [field].
 class GetField extends Primitive {
-  final Reference<Primitive> object;
+  final Reference<Primitive> objectRef;
   FieldElement field;
 
   /// True if the field never changes value.
   final bool isFinal;
 
   /// True if the object is known not to be null.
   // TODO(asgerf): This is a placeholder until we agree on how to track
   //               side effects.
   bool objectIsNotNull = false;
 
+  Primitive get object => objectRef.definition;
+
   GetField(Primitive object, this.field, {this.isFinal: false})
-      : this.object = new Reference<Primitive>(object);
+      : this.objectRef = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   toString() => 'GetField($field)';
 
   void setParentPointers() {
-    object.parent = this;
+    objectRef.parent = this;
   }
 
   int get effects => isFinal ? 0 : Effects.dependsOnInstanceField;
 }
 
 /// Get the length of a string or native list.
 class GetLength extends Primitive {
-  final Reference<Primitive> object;
+  final Reference<Primitive> objectRef;
 
   /// True if the length of the given object can never change.
   bool isFinal;
 
   /// True if the object is known not to be null.
   bool objectIsNotNull = false;
 
+  Primitive get object => objectRef.definition;
+
   GetLength(Primitive object, {this.isFinal: false})
-      : this.object = new Reference<Primitive>(object);
+      : this.objectRef = new Reference<Primitive>(object);
 
   bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitGetLength(this);
 
   void setParentPointers() {
-    object.parent = this;
+    objectRef.parent = this;
   }
 
   int get effects => isFinal ? 0 : Effects.dependsOnIndexableLength;
 }
 
 /// Read an entry from an indexable object.
 ///
 /// [object] must be null or an indexable object, and [index] must be
 /// an integer where `0 <= index < object.length`.
 class GetIndex extends Primitive {
-  final Reference<Primitive> object;
-  final Reference<Primitive> index;
+  final Reference<Primitive> objectRef;
+  final Reference<Primitive> indexRef;
 
   /// True if the object is known not to be null.
   bool objectIsNotNull = false;
 
+  Primitive get object => objectRef.definition;
+  Primitive get index => indexRef.definition;
+
   GetIndex(Primitive object, Primitive index)
-      : this.object = new Reference<Primitive>(object),
-        this.index = new Reference<Primitive>(index);
+      : this.objectRef = new Reference<Primitive>(object),
+        this.indexRef = new Reference<Primitive>(index);
 
   bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitGetIndex(this);
 
   void setParentPointers() {
-    object.parent = this;
-    index.parent = this;
+    objectRef.parent = this;
+    indexRef.parent = this;
   }
 
   int get effects => Effects.dependsOnIndexableContent;
 }
 
 /// Set an entry on a native list.
 ///
 /// [object] must be null or a native list, and [index] must be an integer
 /// within the bounds of the indexable object.
 ///
 /// [SetIndex] may not be used to alter the length of a JS array.
 ///
 /// The primitive itself has no value and may not be referenced.
 class SetIndex extends Primitive {
-  final Reference<Primitive> object;
-  final Reference<Primitive> index;
-  final Reference<Primitive> value;
+  final Reference<Primitive> objectRef;
+  final Reference<Primitive> indexRef;
+  final Reference<Primitive> valueRef;
+
+  Primitive get object => objectRef.definition;
+  Primitive get index => indexRef.definition;
+  Primitive get value => valueRef.definition;
 
   SetIndex(Primitive object, Primitive index, Primitive value)
-      : this.object = new Reference<Primitive>(object),
-        this.index = new Reference<Primitive>(index),
-        this.value = new Reference<Primitive>(value);
+      : this.objectRef = new Reference<Primitive>(object),
+        this.indexRef = new Reference<Primitive>(index),
+        this.valueRef = new Reference<Primitive>(value);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitSetIndex(this);
 
   void setParentPointers() {
-    object.parent = this;
-    index.parent = this;
-    value.parent = this;
+    objectRef.parent = this;
+    indexRef.parent = this;
+    valueRef.parent = this;
   }
 
   int get effects => Effects.changesIndexableContent;
 }
 
 /// Reads the value of a static field or tears off a static method.
 ///
 /// If [GetStatic] is used to load a lazily initialized static field, it must
 /// have been initialized beforehand, and a [witness] must be set to restrict
 /// code motion.
 class GetStatic extends Primitive {
   /// Can be [FieldElement] or [FunctionElement].
   final Element element;
   final SourceInformation sourceInformation;
 
   /// True if the field never changes value.
   final bool isFinal;
 
   /// If reading a lazily initialized field, [witness] must refer to a node
   /// that initializes the field or always occurs after the field initializer.
   ///
   /// The value of the witness is not used.
-  Reference<Primitive> witness;
+  Reference<Primitive> witnessRef;
+
+  Primitive get witness => witnessRef.definition;
 
   GetStatic(this.element, {this.isFinal: false, this.sourceInformation});
 
   /// Read a lazily initialized static field that is known to have been
   /// initialized by [witness] or earlier.
   GetStatic.witnessed(this.element, Primitive witness, {this.sourceInformation})
-      : witness = witness == null ? null : new Reference<Primitive>(witness),
+      : witnessRef = _optionalReference(witness),
         isFinal = false;
 
   accept(Visitor visitor) => visitor.visitGetStatic(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => isFinal;
 
   void setParentPointers() {
-    if (witness != null) {
-      witness.parent = this;
+    if (witnessRef != null) {
+      witnessRef.parent = this;
     }
   }
 
   int get effects => isFinal ? 0 : Effects.dependsOnStaticField;
 }
 
 /// Sets the value of a static field.
 class SetStatic extends Primitive {
   final FieldElement element;
-  final Reference<Primitive> value;
+  final Reference<Primitive> valueRef;
   final SourceInformation sourceInformation;
 
+  Primitive get value => valueRef.definition;
+
   SetStatic(this.element, Primitive value, [this.sourceInformation])
-      : this.value = new Reference<Primitive>(value);
+      : this.valueRef = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetStatic(this);
 
   bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
-    value.parent = this;
+    valueRef.parent = this;
   }
 
   int get effects => Effects.changesStaticField;
 }
 
 /// Reads the value of a lazily initialized static field.
 ///
 /// If the field has not yet been initialized, its initializer is evaluated
 /// and assigned to the field.
 class GetLazyStatic extends UnsafePrimitive {
@@ skipping 26 matching lines @@
   void setParentPointers() {}
 }
 
 /// Creates an instance of a class and initializes its fields and runtime type
 /// information.
 class CreateInstance extends Primitive {
   final ClassElement classElement;
 
   /// Initial values for the fields on the class.
   /// The order corresponds to the order of fields on the class.
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
 
   /// The runtime type information structure which contains the type arguments.
   ///
   /// May be `null` to indicate that no type information is needed because the
   /// compiler determined that the type information for instances of this class
   /// is not needed at runtime.
-  final Reference<Primitive> typeInformation;
+  final Reference<Primitive> typeInformationRef;
 
   final SourceInformation sourceInformation;
 
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
+  Primitive get typeInformation => typeInformationRef?.definition;
+
   CreateInstance(this.classElement, List<Primitive> arguments,
       Primitive typeInformation,
       this.sourceInformation)
-      : this.arguments = _referenceList(arguments),
-        this.typeInformation = typeInformation == null
-            ? null
-            : new Reference<Primitive>(typeInformation);
+      : this.argumentRefs = _referenceList(arguments),
+        this.typeInformationRef = _optionalReference(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   toString() => 'CreateInstance($classElement)';
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
-    if (typeInformation != null) typeInformation.parent = this;
+    _setParentsOnList(argumentRefs, this);
+    if (typeInformationRef != null) typeInformationRef.parent = this;
   }
 }
 
 /// Obtains the interceptor for the given value.  This is a method table
 /// corresponding to the Dart class of the value.
 ///
 /// All values are either intercepted or self-intercepted.  The interceptor for
 /// an "intercepted value" is one of the subclasses of Interceptor.
 /// The interceptor for a "self-intercepted value" is the value itself.
 ///
 /// If the input is an intercepted value, and any of its superclasses is in
 /// [interceptedClasses], the method table for the input is returned.
 /// Otherwise, the input itself is returned.
 ///
 /// There are thus three significant cases:
 /// - the input is a self-interceptor
 /// - the input is an intercepted value and is caught by [interceptedClasses]
 /// - the input is an intercepted value but is bypassed by [interceptedClasses]
 ///
 /// The [flags] field indicates which of the above cases may happen, with
 /// additional special cases for null (which can either by intercepted or
 /// bypassed).
 class Interceptor extends Primitive {
-  final Reference<Primitive> input;
+  final Reference<Primitive> inputRef;
   final Set<ClassElement> interceptedClasses = new Set<ClassElement>();
   final SourceInformation sourceInformation;
 
+  Primitive get input => inputRef.definition;
+
   Interceptor(Primitive input, this.sourceInformation)
-      : this.input = new Reference<Primitive>(input);
+      : this.inputRef = new Reference<Primitive>(input);
 
   accept(Visitor visitor) => visitor.visitInterceptor(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    input.parent = this;
+    inputRef.parent = this;
   }
 }
 
 /// Create an instance of [Invocation] for use in a call to `noSuchMethod`.
 class CreateInvocationMirror extends Primitive {
   final Selector selector;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
+
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
 
   CreateInvocationMirror(this.selector, List<Primitive> arguments)
-      : this.arguments = _referenceList(arguments);
+      : this.argumentRefs = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitCreateInvocationMirror(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 }
 
 class ForeignCode extends UnsafePrimitive {
   final js.Template codeTemplate;
   final TypeMask storedType;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
   final native.NativeBehavior nativeBehavior;
   final FunctionElement dependency;
 
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
+
   ForeignCode(this.codeTemplate, this.storedType, List<Primitive> arguments,
       this.nativeBehavior, {this.dependency})
-      : this.arguments = _referenceList(arguments) {
+      : this.argumentRefs = _referenceList(arguments) {
     effects = Effects.from(nativeBehavior.sideEffects);
   }
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 
   bool isNullGuardOnNullFirstArgument() {
-    if (arguments.length < 1) return false;
+    if (argumentRefs.length < 1) return false;
     // TODO(sra): Fix NativeThrowBehavior to distinguish MAY from
     // throws-nsm-on-null-followed-by-MAY and remove
     // [isNullGuardForFirstArgument].
     if (nativeBehavior.throwBehavior.isNullNSMGuard) return true;
     return js.isNullGuardOnFirstArgument(codeTemplate);
   }
 }
 
 class Constant extends Primitive {
   final values.ConstantValue value;
   final SourceInformation sourceInformation;
 
   Constant(this.value, {this.sourceInformation}) {
     assert(value != null);
   }
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final InterfaceType dartType;
-  final List<Reference<Primitive>> values;
+  final List<Reference<Primitive>> valueRefs;
 
   /// If non-null, this is an allocation site-specific type for the list
   /// created here.
   TypeMask allocationSiteType;
 
+  Primitive value(int n) => valueRefs[n].definition;
+  Iterable<Primitive> get values => _dereferenceList(valueRefs);
+
   LiteralList(this.dartType, List<Primitive> values, {this.allocationSiteType})
-      : this.values = _referenceList(values);
+      : this.valueRefs = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    _setParentsOnList(values, this);
+    _setParentsOnList(valueRefs, this);
   }
 }
 
 class Parameter extends Primitive {
   Parameter(Entity hint) {
     super.hint = hint;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 
@@ skipping 104 matching lines @@
     returnContinuation.parent = this;
     if (body != null) body.parent = this;
   }
 }
 
 /// Converts the internal representation of a type to a Dart object of type
 /// [Type].
 class ReifyRuntimeType extends Primitive {
   /// Reference to the internal representation of a type (as produced, for
   /// example, by [ReadTypeVariable]).
-  final Reference<Primitive> value;
+  final Reference<Primitive> valueRef;
 
   final SourceInformation sourceInformation;
 
+  Primitive get value => valueRef.definition;
+
   ReifyRuntimeType(Primitive value, this.sourceInformation)
-    : this.value = new Reference<Primitive>(value);
+    : this.valueRef = new Reference<Primitive>(value);
 
   @override
   accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    value.parent = this;
+    valueRef.parent = this;
   }
 }
 
 /// Read the value the type variable [variable] from the target object.
 ///
 /// The resulting value is an internal representation (and not neccessarily a
 /// Dart object), and must be reified by [ReifyRuntimeType], if it should be
 /// used as a Dart value.
 class ReadTypeVariable extends Primitive {
   final TypeVariableType variable;
-  final Reference<Primitive> target;
+  final Reference<Primitive> targetRef;
   final SourceInformation sourceInformation;
 
+  Primitive get target => targetRef.definition;
+
   ReadTypeVariable(this.variable, Primitive target, this.sourceInformation)
-      : this.target = new Reference<Primitive>(target);
+      : this.targetRef = new Reference<Primitive>(target);
 
   @override
   accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    target.parent = this;
+    targetRef.parent = this;
   }
 }
 
 enum TypeExpressionKind {
   COMPLETE,
   INSTANCE
 }
 
 /// Constructs a representation of a closed or ground-term type (that is, a type
 /// without type variables).
@@ skipping 41 matching lines @@
 ///            TypeExpression(COMPLETE,  // E3 = List<T>
 ///                dartType: List<E2>,
 ///                ReadTypeVariable(this, T)))) // E2 = T
 //
 // TODO(sra): The INSTANCE form requires the actual instance for full
 // interpretation. I want to move to a representation where the INSTANCE form is
 // also a complete form (possibly the same).
 class TypeExpression extends Primitive {
   final TypeExpressionKind kind;
   final DartType dartType;
-  final List<Reference<Primitive>> arguments;
+  final List<Reference<Primitive>> argumentRefs;
+
+  Primitive argument(int n) => argumentRefs[n].definition;
+  Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
 
   TypeExpression(this.kind,
                  this.dartType,
                  List<Primitive> arguments)
-      : this.arguments = _referenceList(arguments) {
+      : this.argumentRefs = _referenceList(arguments) {
     assert(kind == TypeExpressionKind.INSTANCE
            ? dartType == (dartType.element as ClassElement).thisType
            : true);
   }
 
   @override
   accept(Visitor visitor) {
     return visitor.visitTypeExpression(this);
   }
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
-    _setParentsOnList(arguments, this);
+    _setParentsOnList(argumentRefs, this);
   }
 
   String get kindAsString {
     switch (kind) {
       case TypeExpressionKind.COMPLETE: return 'COMPLETE';
       case TypeExpressionKind.INSTANCE: return 'INSTANCE';
     }
   }
 }
 
 class Await extends UnsafePrimitive {
-  final Reference<Primitive> input;
+  final Reference<Primitive> inputRef;
+
+  Primitive get input => inputRef.definition;
 
   Await(Primitive input)
-    : this.input = new Reference<Primitive>(input);
+    : this.inputRef = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitAwait(this);
   }
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    input.parent = this;
+    inputRef.parent = this;
   }
 }
 
 class Yield extends UnsafePrimitive {
-  final Reference<Primitive> input;
+  final Reference<Primitive> inputRef;
   final bool hasStar;
 
+  Primitive get input => inputRef.definition;
+
   Yield(Primitive input, this.hasStar)
-    : this.input = new Reference<Primitive>(input);
+    : this.inputRef = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitYield(this);
   }
 
   bool get hasValue => true;
 
   void setParentPointers() {
-    input.parent = this;
+    inputRef.parent = this;
   }
 }
 
 Reference<Primitive> _reference(Primitive definition) {
   return new Reference<Primitive>(definition);
 }
 
 Reference<Primitive> _optionalReference(Primitive definition) {
   return definition == null
       ? null
       : new Reference<Primitive>(definition);
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
+Iterable<Primitive> _dereferenceList(List<Reference<Primitive>> references) {
+  return references.map((ref) => ref.definition);
+}
+
 void _setParentsOnNodes(List<Node> nodes, Node parent) {
   for (Node node in nodes) {
     node.parent = parent;
   }
 }
 
 void _setParentsOnList(List<Reference> nodes, Node parent) {
   for (Reference node in nodes) {
     node.parent = parent;
   }
@@ skipping 189 matching lines @@
   visitLetHandler(LetHandler node) {
     processLetHandler(node);
     visit(node.handler);
     visit(node.body);
   }
 
   processLetMutable(LetMutable node) {}
   visitLetMutable(LetMutable node) {
     processLetMutable(node);
     visit(node.variable);
-    processReference(node.value);
+    processReference(node.valueRef);
     visit(node.body);
   }
 
   processInvokeStatic(InvokeStatic node) {}
   visitInvokeStatic(InvokeStatic node) {
     processInvokeStatic(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processInvokeContinuation(InvokeContinuation node) {}
   visitInvokeContinuation(InvokeContinuation node) {
     processInvokeContinuation(node);
-    processReference(node.continuation);
-    node.arguments.forEach(processReference);
+    processReference(node.continuationRef);
+    node.argumentRefs.forEach(processReference);
   }
 
   processInvokeMethod(InvokeMethod node) {}
   visitInvokeMethod(InvokeMethod node) {
     processInvokeMethod(node);
-    processReference(node.receiver);
-    node.arguments.forEach(processReference);
+    processReference(node.receiverRef);
+    node.argumentRefs.forEach(processReference);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {}
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     processInvokeMethodDirectly(node);
-    processReference(node.receiver);
-    node.arguments.forEach(processReference);
+    processReference(node.receiverRef);
+    node.argumentRefs.forEach(processReference);
   }
 
   processInvokeConstructor(InvokeConstructor node) {}
   visitInvokeConstructor(InvokeConstructor node) {
     processInvokeConstructor(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processThrow(Throw node) {}
   visitThrow(Throw node) {
     processThrow(node);
-    processReference(node.value);
+    processReference(node.valueRef);
   }
 
   processRethrow(Rethrow node) {}
   visitRethrow(Rethrow node) {
     processRethrow(node);
   }
 
   processBranch(Branch node) {}
   visitBranch(Branch node) {
     processBranch(node);
-    processReference(node.trueContinuation);
-    processReference(node.falseContinuation);
-    processReference(node.condition);
+    processReference(node.trueContinuationRef);
+    processReference(node.falseContinuationRef);
+    processReference(node.conditionRef);
   }
 
   processTypeCast(TypeCast node) {}
   visitTypeCast(TypeCast node) {
     processTypeCast(node);
-    processReference(node.value);
-    node.typeArguments.forEach(processReference);
+    processReference(node.valueRef);
+    node.typeArgumentRefs.forEach(processReference);
   }
 
   processTypeTest(TypeTest node) {}
   visitTypeTest(TypeTest node) {
     processTypeTest(node);
-    processReference(node.value);
-    node.typeArguments.forEach(processReference);
+    processReference(node.valueRef);
+    node.typeArgumentRefs.forEach(processReference);
   }
 
   processTypeTestViaFlag(TypeTestViaFlag node) {}
   visitTypeTestViaFlag(TypeTestViaFlag node) {
     processTypeTestViaFlag(node);
-    processReference(node.interceptor);
+    processReference(node.interceptorRef);
   }
 
   processSetMutable(SetMutable node) {}
   visitSetMutable(SetMutable node) {
     processSetMutable(node);
-    processReference(node.variable);
-    processReference(node.value);
+    processReference(node.variableRef);
+    processReference(node.valueRef);
   }
 
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
     processGetLazyStatic(node);
   }
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
-    node.values.forEach(processReference);
+    node.valueRefs.forEach(processReference);
   }
 
   processConstant(Constant node) {}
   visitConstant(Constant node)  {
     processConstant(node);
   }
 
   processMutableVariable(node) {}
   visitMutableVariable(MutableVariable node) {
     processMutableVariable(node);
   }
 
   processGetMutable(GetMutable node) {}
   visitGetMutable(GetMutable node) {
     processGetMutable(node);
-    processReference(node.variable);
+    processReference(node.variableRef);
   }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) {
     processParameter(node);
   }
 
   processInterceptor(Interceptor node) {}
   visitInterceptor(Interceptor node) {
     processInterceptor(node);
-    processReference(node.input);
+    processReference(node.inputRef);
   }
 
   processCreateInstance(CreateInstance node) {}
   visitCreateInstance(CreateInstance node) {
     processCreateInstance(node);
-    node.arguments.forEach(processReference);
-    if (node.typeInformation != null) processReference(node.typeInformation);
+    node.argumentRefs.forEach(processReference);
+    if (node.typeInformationRef != null) {
+      processReference(node.typeInformationRef);
+    }
   }
 
   processSetField(SetField node) {}
   visitSetField(SetField node) {
     processSetField(node);
-    processReference(node.object);
-    processReference(node.value);
+    processReference(node.objectRef);
+    processReference(node.valueRef);
   }
 
   processGetField(GetField node) {}
   visitGetField(GetField node) {
     processGetField(node);
-    processReference(node.object);
+    processReference(node.objectRef);
   }
 
   processGetStatic(GetStatic node) {}
   visitGetStatic(GetStatic node) {
     processGetStatic(node);
-    if (node.witness != null) {
-      processReference(node.witness);
+    if (node.witnessRef != null) {
+      processReference(node.witnessRef);
     }
   }
 
   processSetStatic(SetStatic node) {}
   visitSetStatic(SetStatic node) {
     processSetStatic(node);
-    processReference(node.value);
+    processReference(node.valueRef);
   }
 
   processCreateBox(CreateBox node) {}
   visitCreateBox(CreateBox node) {
     processCreateBox(node);
   }
 
   processReifyRuntimeType(ReifyRuntimeType node) {}
   visitReifyRuntimeType(ReifyRuntimeType node) {
     processReifyRuntimeType(node);
-    processReference(node.value);
+    processReference(node.valueRef);
   }
 
   processReadTypeVariable(ReadTypeVariable node) {}
   visitReadTypeVariable(ReadTypeVariable node) {
     processReadTypeVariable(node);
-    processReference(node.target);
+    processReference(node.targetRef);
   }
 
   processTypeExpression(TypeExpression node) {}
   visitTypeExpression(TypeExpression node) {
     processTypeExpression(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processCreateInvocationMirror(CreateInvocationMirror node) {}
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     processCreateInvocationMirror(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processApplyBuiltinOperator(ApplyBuiltinOperator node) {}
   visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     processApplyBuiltinOperator(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processApplyBuiltinMethod(ApplyBuiltinMethod node) {}
   visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     processApplyBuiltinMethod(node);
-    processReference(node.receiver);
-    node.arguments.forEach(processReference);
+    processReference(node.receiverRef);
+    node.argumentRefs.forEach(processReference);
   }
 
   processForeignCode(ForeignCode node) {}
   visitForeignCode(ForeignCode node) {
     processForeignCode(node);
-    node.arguments.forEach(processReference);
+    node.argumentRefs.forEach(processReference);
   }
 
   processUnreachable(Unreachable node) {}
   visitUnreachable(Unreachable node) {
     processUnreachable(node);
   }
 
   processAwait(Await node) {}
   visitAwait(Await node) {
     processAwait(node);
-    processReference(node.input);
+    processReference(node.inputRef);
   }
 
   processYield(Yield node) {}
   visitYield(Yield node) {
     processYield(node);
-    processReference(node.input);
+    processReference(node.inputRef);
   }
 
   processGetLength(GetLength node) {}
   visitGetLength(GetLength node) {
     processGetLength(node);
-    processReference(node.object);
+    processReference(node.objectRef);
   }
 
   processGetIndex(GetIndex node) {}
   visitGetIndex(GetIndex node) {
     processGetIndex(node);
-    processReference(node.object);
-    processReference(node.index);
+    processReference(node.objectRef);
+    processReference(node.indexRef);
   }
 
   processSetIndex(SetIndex node) {}
   visitSetIndex(SetIndex node) {
     processSetIndex(node);
-    processReference(node.object);
-    processReference(node.index);
-    processReference(node.value);
+    processReference(node.objectRef);
+    processReference(node.indexRef);
+    processReference(node.valueRef);
   }
 
   processRefinement(Refinement node) {}
   visitRefinement(Refinement node) {
     processRefinement(node);
     processReference(node.value);
   }
 
   processBoundsCheck(BoundsCheck node) {}
   visitBoundsCheck(BoundsCheck node) {
     processBoundsCheck(node);
-    processReference(node.object);
-    if (node.index != null) {
-      processReference(node.index);
+    processReference(node.objectRef);
+    if (node.indexRef != null) {
+      processReference(node.indexRef);
     }
-    if (node.length != null) {
-      processReference(node.length);
+    if (node.lengthRef != null) {
+      processReference(node.lengthRef);
     }
   }
 
   processNullCheck(ReceiverCheck node) {}
   visitReceiverCheck(ReceiverCheck node) {
     processNullCheck(node);
-    processReference(node.value);
-    if (node.condition != null) {
-      processReference(node.condition);
+    processReference(node.valueRef);
+    if (node.conditionRef != null) {
+      processReference(node.conditionRef);
     }
   }
 }
 
 typedef void StackAction();
 
 /// Calls `process*` for all nodes in a tree.
 /// For simple usage, only override the `process*` methods.
 ///
 /// To avoid deep recursion, this class uses an "action stack" containing
@@ skipping 75 matching lines @@
 
   Expression traverseLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     return node.body;
   }
 
   Expression traverseLetMutable(LetMutable node) {
     processLetMutable(node);
     visit(node.variable);
-    processReference(node.value);
+    processReference(node.valueRef);
     return node.body;
   }
 
   void _trampoline(Expression node, {int initialHeight}) {
     initialHeight = initialHeight ?? _stack.length;
     _processBlock(node);
     while (_stack.length > initialHeight) {
       StackAction callback = _stack.removeLast();
       callback();
     }
@@ skipping 74 matching lines @@
   visitLetHandler(LetHandler node) {}
   visitLetMutable(LetMutable node) {}
   visitInvokeContinuation(InvokeContinuation node) {}
   visitThrow(Throw node) {}
   visitRethrow(Rethrow node) {}
   visitBranch(Branch node) {}
   visitUnreachable(Unreachable node) {}
   visitContinuation(Continuation node) {}
 
   Definition visitInvokeStatic(InvokeStatic node) {
-    return new InvokeStatic(node.target, node.selector, getList(node.arguments),
-        node.sourceInformation);
+    return new InvokeStatic(node.target, node.selector,
+        getList(node.argumentRefs), node.sourceInformation);
   }
 
   Definition visitInvokeMethod(InvokeMethod node) {
-    return new InvokeMethod(getCopy(node.receiver), node.selector, node.mask,
-        getList(node.arguments),
+    return new InvokeMethod(getCopy(node.receiverRef), node.selector, node.mask,
+        getList(node.argumentRefs),
         sourceInformation: node.sourceInformation,
         callingConvention: node.callingConvention);
   }
 
   Definition visitInvokeMethodDirectly(InvokeMethodDirectly node) {
-    return new InvokeMethodDirectly(getCopy(node.receiver), node.target,
+    return new InvokeMethodDirectly(getCopy(node.receiverRef), node.target,
         node.selector,
-        getList(node.arguments),
+        getList(node.argumentRefs),
         node.sourceInformation,
         callingConvention: node.callingConvention);
   }
 
   Definition visitInvokeConstructor(InvokeConstructor node) {
     return new InvokeConstructor(node.dartType, node.target, node.selector,
-        getList(node.arguments),
+        getList(node.argumentRefs),
         node.sourceInformation)
         ..allocationSiteType = node.allocationSiteType;
   }
 
   Definition visitTypeCast(TypeCast node) {
-    return new TypeCast(getCopy(node.value), node.dartType,
-        getList(node.typeArguments));
+    return new TypeCast(getCopy(node.valueRef), node.dartType,
+        getList(node.typeArgumentRefs));
   }
 
   Definition visitSetMutable(SetMutable node) {
-    return new SetMutable(getCopy(node.variable), getCopy(node.value));
+    return new SetMutable(getCopy(node.variableRef), getCopy(node.valueRef));
   }
 
   Definition visitSetStatic(SetStatic node) {
-    return new SetStatic(node.element, getCopy(node.value),
+    return new SetStatic(node.element, getCopy(node.valueRef),
         node.sourceInformation);
   }
 
   Definition visitSetField(SetField node) {
-    return new SetField(getCopy(node.object), node.field, getCopy(node.value));
+    return new SetField(getCopy(node.objectRef), node.field,
+        getCopy(node.valueRef));
   }
 
   Definition visitGetLazyStatic(GetLazyStatic node) {
     return new GetLazyStatic(node.element,
         isFinal: node.isFinal,
         sourceInformation: node.sourceInformation);
   }
 
   Definition visitAwait(Await node) {
-    return new Await(getCopy(node.input));
+    return new Await(getCopy(node.inputRef));
   }
 
   Definition visitYield(Yield node) {
-    return new Yield(getCopy(node.input), node.hasStar);
+    return new Yield(getCopy(node.inputRef), node.hasStar);
   }
 
   Definition visitLiteralList(LiteralList node) {
-    return new LiteralList(node.dartType, getList(node.values))
+    return new LiteralList(node.dartType, getList(node.valueRefs))
         ..allocationSiteType = node.allocationSiteType;
   }
 
   Definition visitConstant(Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Definition visitGetMutable(GetMutable node) {
-    return new GetMutable(getCopy(node.variable));
+    return new GetMutable(getCopy(node.variableRef));
   }
 
   Definition visitParameter(Parameter node) {
     return new Parameter(node.hint);
   }
 
   Definition visitMutableVariable(MutableVariable node) {
     return new MutableVariable(node.hint);
   }
 
   Definition visitGetStatic(GetStatic node) {
-    if (node.witness != null) {
+    if (node.witnessRef != null) {
       return new GetStatic.witnessed(node.element,
-          getCopy(node.witness),
+          getCopy(node.witnessRef),
           sourceInformation: node.sourceInformation);
     } else {
       return new GetStatic(node.element,
           isFinal: node.isFinal,
           sourceInformation: node.sourceInformation);
     }
   }
 
   Definition visitInterceptor(Interceptor node) {
-    return new Interceptor(getCopy(node.input), node.sourceInformation)
+    return new Interceptor(getCopy(node.inputRef), node.sourceInformation)
         ..interceptedClasses.addAll(node.interceptedClasses);
   }
 
   Definition visitCreateInstance(CreateInstance node) {
     return new CreateInstance(
         node.classElement,
-        getList(node.arguments),
-        node.typeInformation == null ? null : getCopy(node.typeInformation),
+        getList(node.argumentRefs),
+        getCopyOrNull(node.typeInformationRef),
         node.sourceInformation);
   }
 
   Definition visitGetField(GetField node) {
-    return new GetField(getCopy(node.object), node.field,
+    return new GetField(getCopy(node.objectRef), node.field,
         isFinal: node.isFinal);
   }
 
   Definition visitCreateBox(CreateBox node) {
     return new CreateBox();
   }
 
   Definition visitReifyRuntimeType(ReifyRuntimeType node) {
-    return new ReifyRuntimeType(getCopy(node.value), node.sourceInformation);
+    return new ReifyRuntimeType(getCopy(node.valueRef), node.sourceInformation);
   }
 
   Definition visitReadTypeVariable(ReadTypeVariable node) {
-    return new ReadTypeVariable(node.variable, getCopy(node.target),
+    return new ReadTypeVariable(node.variable, getCopy(node.targetRef),
         node.sourceInformation);
   }
 
   Definition visitTypeExpression(TypeExpression node) {
     return new TypeExpression(
-        node.kind, node.dartType, getList(node.arguments));
+        node.kind, node.dartType, getList(node.argumentRefs));
   }
 
   Definition visitCreateInvocationMirror(CreateInvocationMirror node) {
-    return new CreateInvocationMirror(node.selector, getList(node.arguments));
+    return new CreateInvocationMirror(node.selector,
+        getList(node.argumentRefs));
   }
 
   Definition visitTypeTest(TypeTest node) {
-    return new TypeTest(getCopy(node.value), node.dartType,
-        getList(node.typeArguments));
+    return new TypeTest(getCopy(node.valueRef), node.dartType,
+        getList(node.typeArgumentRefs));
   }
 
   Definition visitTypeTestViaFlag(TypeTestViaFlag node) {
-    return new TypeTestViaFlag(getCopy(node.interceptor), node.dartType);
+    return new TypeTestViaFlag(getCopy(node.interceptorRef), node.dartType);
   }
 
   Definition visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
-    return new ApplyBuiltinOperator(node.operator, getList(node.arguments),
+    return new ApplyBuiltinOperator(node.operator, getList(node.argumentRefs),
         node.sourceInformation);
   }
 
   Definition visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
-    return new ApplyBuiltinMethod(node.method, getCopy(node.receiver),
-        getList(node.arguments),
+    return new ApplyBuiltinMethod(node.method, getCopy(node.receiverRef),
+        getList(node.argumentRefs),
         node.sourceInformation,
         receiverIsNotNull: node.receiverIsNotNull);
   }
 
   Definition visitGetLength(GetLength node) {
-    return new GetLength(getCopy(node.object), isFinal: node.isFinal);
+    return new GetLength(getCopy(node.objectRef), isFinal: node.isFinal);
   }
 
   Definition visitGetIndex(GetIndex node) {
-    return new GetIndex(getCopy(node.object), getCopy(node.index));
+    return new GetIndex(getCopy(node.objectRef), getCopy(node.indexRef));
   }
 
   Definition visitSetIndex(SetIndex node) {
-    return new SetIndex(getCopy(node.object), getCopy(node.index),
-        getCopy(node.value));
+    return new SetIndex(getCopy(node.objectRef), getCopy(node.indexRef),
+        getCopy(node.valueRef));
   }
 
   Definition visitRefinement(Refinement node) {
     return new Refinement(getCopy(node.value), node.refineType);
   }
 
   Definition visitBoundsCheck(BoundsCheck node) {
     if (node.hasNoChecks) {
-      return new BoundsCheck.noCheck(getCopy(node.object),
+      return new BoundsCheck.noCheck(getCopy(node.objectRef),
           node.sourceInformation);
     } else {
-      return new BoundsCheck(getCopy(node.object), getCopy(node.index),
-          getCopyOrNull(node.length),
+      return new BoundsCheck(getCopy(node.objectRef), getCopy(node.indexRef),
+          getCopyOrNull(node.lengthRef),
           node.checks,
           node.sourceInformation);
     }
   }
 
   Definition visitReceiverCheck(ReceiverCheck node) {
-    return new ReceiverCheck(getCopy(node.value),
+    return new ReceiverCheck(getCopy(node.valueRef),
         node.selector,
         node.sourceInformation,
-        condition: getCopyOrNull(node.condition),
+        condition: getCopyOrNull(node.conditionRef),
         useSelector: node.useSelector,
         isNullCheck: node.isNullCheck);
   }
 
   Definition visitForeignCode(ForeignCode node) {
     return new ForeignCode(node.codeTemplate, node.storedType,
-        getList(node.arguments),
+        getList(node.argumentRefs),
         node.nativeBehavior,
         dependency: node.dependency);
   }
 }
 
 /// A trampolining visitor to copy [FunctionDefinition]s.
 class CopyingVisitor extends TrampolineRecursiveVisitor {
   // The visitor maintains a map from original continuations to their copies.
   Map<Continuation, Continuation> _copies = <Continuation, Continuation>{};
 
@@ skipping 92 matching lines @@
     return node.body;
   }
 
   Expression traverseLetPrim(LetPrim node) {
     plug(new LetPrim(_definitions.copy(node.primitive)));
     return node.body;
   }
 
   Expression traverseLetMutable(LetMutable node) {
     plug(new LetMutable(_definitions.copy(node.variable),
-        _definitions.getCopy(node.value)));
+        _definitions.getCopy(node.valueRef)));
     return node.body;
   }
 
   // Tail expressions do not have references, so we do not need to map them
   // to their copies.
   visitInvokeContinuation(InvokeContinuation node) {
-    plug(new InvokeContinuation(_copies[node.continuation.definition],
-        _definitions.getList(node.arguments),
+    plug(new InvokeContinuation(_copies[node.continuation],
+        _definitions.getList(node.argumentRefs),
         isRecursive: node.isRecursive,
         isEscapingTry: node.isEscapingTry,
         sourceInformation: node.sourceInformation));
   }
 
   visitThrow(Throw node) {
-    plug(new Throw(_definitions.getCopy(node.value)));
+    plug(new Throw(_definitions.getCopy(node.valueRef)));
   }
 
   visitRethrow(Rethrow node) {
     plug(new Rethrow());
   }
 
   visitBranch(Branch node) {
-    plug(new Branch.loose(_definitions.getCopy(node.condition),
-        _copies[node.trueContinuation.definition],
-        _copies[node.falseContinuation.definition])
+    plug(new Branch.loose(_definitions.getCopy(node.conditionRef),
+        _copies[node.trueContinuation],
+        _copies[node.falseContinuation])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }