dart2js: Add a type parameter to class Reference in the CPS IR.

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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 11 matching lines @@
 
   accept(Visitor visitor);
 }
 
 abstract class Expression extends Node {
   Expression plug(Expression expr) => throw 'impossible';
 }
 
 /// The base class of things that variables can refer to: primitives,
 /// continuations, function and continuation parameters, etc.
-abstract class Definition extends Node {
+abstract class Definition<T extends Definition<T>> extends Node {
   // The head of a linked-list of occurrences, in no particular order.
-  Reference firstRef = null;
+  Reference<T> firstRef;
 
   bool get hasAtMostOneUse  => firstRef == null || firstRef.next == null;
   bool get hasExactlyOneUse => firstRef != null && firstRef.next == null;
   bool get hasAtLeastOneUse => firstRef != null;
   bool get hasMultipleUses  => !hasAtMostOneUse;
 
-  void substituteFor(Definition other) {
+  void substituteFor(Definition<T> other) {
     if (other.firstRef == null) return;
-    Reference previous, current = other.firstRef;
+    Reference<T> previous, current = other.firstRef;
     do {
       current.definition = this;
       previous = current;
       current = current.next;
     } while (current != null);
     previous.next = firstRef;
     if (firstRef != null) firstRef.previous = previous;
     firstRef = other.firstRef;
   }
 }
 
 /// An expression that cannot throw or diverge and has no side-effects.
 /// All primitives are named using the identity of the [Primitive] object.
 ///
 /// Primitives may allocate objects, this is not considered side-effect here.
 ///
 /// Although primitives may not mutate state, they may depend on state.
-abstract class Primitive extends Definition {
+abstract class Primitive extends Definition<Primitive> {
   /// The [VariableElement] or [ParameterElement] from which the primitive
   /// binding originated.
   Element hint;
 
   /// Register in which the variable binding this primitive can be allocated.
   /// Separate register spaces are used for primitives with different [element].
   /// Assigned by [RegisterAllocator], is null before that phase.
   int registerIndex;
 
   /// Use the given element as a hint for naming this primitive.
   ///
   /// Has no effect if this primitive already has a non-null [element].
   void useElementAsHint(Element hint) {
     if (this.hint == null) {
       this.hint = hint;
     }
   }
 }
 
 /// Operands to invocations and primitives are always variables.  They point to
 /// their definition and are doubly-linked into a list of occurrences.
-class Reference {
-  Definition definition;
-  Reference previous = null;
-  Reference next = null;
+class Reference<T extends Definition<T>> {
+  T definition;
+  Reference<T> previous;
+  Reference<T> next;
 
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   Reference(this.definition) {
     next = definition.firstRef;
     if (next != null) next.previous = this;
     definition.firstRef = this;
   }
 
@@ skipping 42 matching lines @@
   Expression plug(Expression expr) {
     assert(continuation != null && continuation.body == null);
     return continuation.body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetCont(this);
 }
 
 abstract class Invoke {
   Selector get selector;
-  List<Reference> get arguments;
+  List<Reference<Primitive>> get arguments;
 }
 
 /// Represents a node with a child node, which can be accessed through the
 /// `body` member. A typical usage is when removing a node from the CPS graph:
 ///
 ///     Node child          = node.body;
 ///     InteriorNode parent = node.parent;
 ///
 ///     child.parent = parent;
 ///     parent.body  = child;
 abstract class InteriorNode implements Node {
   Expression body;
 }
 
 /// Invoke a static function or static field getter/setter.
 class InvokeStatic extends Expression implements Invoke {
   /// [FunctionElement] or [FieldElement].
   final Entity target;
 
   /**
    * The selector encodes how the function is invoked: number of positional
    * arguments, names used in named arguments. This information is required
    * to build the [StaticCallSiteTypeInformation] for the inference graph.
    */
   final Selector selector;
 
-  final Reference continuation;
-  final List<Reference> arguments;
+  final Reference<Continuation> continuation;
+  final List<Reference<Primitive>> arguments;
 
   InvokeStatic(this.target, this.selector, Continuation cont,
-               List<Definition> args)
-      : continuation = new Reference(cont),
+               List<Primitive> args)
+      : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(target is ErroneousElement || selector.name == target.name);
   }
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 }
 
 /// Invoke a method, operator, getter, setter, or index getter/setter.
 /// Converting a method to a function object is treated as a getter invocation.
 class InvokeMethod extends Expression implements Invoke {
-  final Reference receiver;
+  final Reference<Primitive> receiver;
   final Selector selector;
-  final Reference continuation;
-  final List<Reference> arguments;
+  final Reference<Continuation> continuation;
+  final List<Reference<Primitive>> arguments;
 
-  InvokeMethod(Definition receiver,
+  InvokeMethod(Primitive receiver,
                this.selector,
                Continuation cont,
-               List<Definition> args)
-      : receiver = new Reference(receiver),
-        continuation = new Reference(cont),
+               List<Primitive> args)
+      : receiver = new Reference<Primitive>(receiver),
+        continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(selector != null);
     assert(selector.kind == SelectorKind.CALL ||
            selector.kind == SelectorKind.OPERATOR ||
            (selector.kind == SelectorKind.GETTER && arguments.isEmpty) ||
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 /// Invoke a method, operator, getter, setter, or index getter/setter from the
 /// super class in tail position.
 class InvokeSuperMethod extends Expression implements Invoke {
   final Selector selector;
-  final Reference continuation;
-  final List<Reference> arguments;
+  final Reference<Continuation> continuation;
+  final List<Reference<Primitive>> arguments;
 
   InvokeSuperMethod(this.selector,
                     Continuation cont,
-                    List<Definition> args)
-      : continuation = new Reference(cont),
+                    List<Primitive> args)
+      : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(selector != null);
     assert(selector.kind == SelectorKind.CALL ||
            selector.kind == SelectorKind.OPERATOR ||
            (selector.kind == SelectorKind.GETTER && arguments.isEmpty) ||
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeSuperMethod(this);
 }
 
 /// Non-const call to a constructor. The [target] may be a generative
 /// constructor, factory, or redirecting factory.
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
-  final Reference continuation;
-  final List<Reference> arguments;
+  final Reference<Continuation> continuation;
+  final List<Reference<Primitive>> arguments;
   final Selector selector;
 
   /// The class being instantiated. This is the same as `target.enclosingClass`
   /// and `type.element`.
   ClassElement get targetClass => target.enclosingElement;
 
   /// True if this is an invocation of a factory constructor.
   bool get isFactory => target.isFactoryConstructor;
 
   InvokeConstructor(this.type,
                     this.target,
                     this.selector,
                     Continuation cont,
-                    List<Definition> args)
-      : continuation = new Reference(cont),
+                    List<Primitive> args)
+      : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(dart2js.invariant(target,
         target.isErroneous || target.isConstructor,
         message: "Constructor invocation target is not a constructor: "
                  "$target."));
     assert(dart2js.invariant(target,
         target.isErroneous ||
         type.isDynamic ||
         type.element == target.enclosingClass.declaration,
         message: "Constructor invocation type ${type} does not match enclosing "
                  "class of target ${target}."));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// "as" casts and "is" checks.
 // We might want to turn "is"-checks into a [Primitive] as it can never diverge.
 // But then we need to special-case for is-checks with an erroneous .type as
 // these will throw.
 class TypeOperator extends Expression {
-  final Reference receiver;
+  final Reference<Primitive> receiver;
   final DartType type;
-  final Reference continuation;
+  final Reference<Continuation> continuation;
   // TODO(johnniwinther): Use `Operator` class to encapsule the operator type.
   final bool isTypeTest;
 
   TypeOperator(Primitive receiver,
                this.type,
                Continuation cont,
                {bool this.isTypeTest})
-      : this.receiver = new Reference(receiver),
-        this.continuation = new Reference(cont) {
+      : this.receiver = new Reference<Primitive>(receiver),
+        this.continuation = new Reference<Continuation>(cont) {
     assert(isTypeTest != null);
   }
 
   bool get isTypeCast => !isTypeTest;
 
   accept(Visitor visitor) => visitor.visitTypeOperator(this);
 }
 
 /// Invoke [toString] on each argument and concatenate the results.
 class ConcatenateStrings extends Expression {
-  final Reference continuation;
-  final List<Reference> arguments;
+  final Reference<Continuation> continuation;
+  final List<Reference<Primitive>> arguments;
 
-  ConcatenateStrings(Continuation cont, List<Definition> args)
-      : continuation = new Reference(cont),
+  ConcatenateStrings(Continuation cont, List<Primitive> args)
+      : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args);
 
   accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
 /// Gets the value from a closure variable. The identity of the variable is
 /// determined by a [Local].
 ///
 /// Closure variables can be seen as ref cells that are not first-class values.
 /// A [LetPrim] with a [GetClosureVariable] can then be seen as:
@@ skipping 19 matching lines @@
 ///   let [variable] = ref [value] in [body]
 ///
 /// And otherwise, it can be seen as a dereferencing assignment:
 ///
 ///   { ![variable] := [value]; [body] }
 ///
 /// Closure variables without a declaring [SetClosureVariable] are implicitly
 /// declared at the entry to the [variable]'s enclosing function.
 class SetClosureVariable extends Expression implements InteriorNode {
   final Local variable;
-  final Reference value;
+  final Reference<Primitive> value;
   Expression body;
 
   /// If true, this declares a new copy of the closure variable. If so, all
   /// uses of the closure variable must occur in the [body].
   ///
   /// There can be at most one declaration per closure variable. If there is no
   /// declaration, only one copy exists (per function execution). It is best to
   /// avoid declaring closure variables if it is not necessary.
   final bool isDeclaration;
 
   SetClosureVariable(this.variable, Primitive value,
                      {this.isDeclaration : false })
-      : this.value = new Reference(value) {
+      : this.value = new Reference<Primitive>(value) {
     assert(variable != null);
   }
 
   accept(Visitor visitor) => visitor.visitSetClosureVariable(this);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 }
@@ skipping 16 matching lines @@
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitDeclareFunction(this);
 }
 
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends Expression {
-  Reference continuation;
-  List<Reference> arguments;
+  Reference<Continuation> continuation;
+  List<Reference<Primitive>> arguments;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
-  InvokeContinuation(Continuation cont, List<Definition> args,
+  InvokeContinuation(Continuation cont, List<Primitive> args,
                      {recursive: false})
-      : continuation = new Reference(cont),
+      : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args),
         isRecursive = recursive {
     assert(cont.parameters == null ||
         cont.parameters.length == args.length);
     if (recursive) 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({recursive: false})
       : continuation = null,
         arguments = null,
         isRecursive = recursive;
 
   accept(Visitor visitor) => visitor.visitInvokeContinuation(this);
 }
 
 /// The base class of things which can be tested and branched on.
 abstract class Condition extends Node {
 }
 
 class IsTrue extends Condition {
-  final Reference value;
+  final Reference<Primitive> value;
 
-  IsTrue(Definition val) : value = new Reference(val);
+  IsTrue(Primitive val) : value = new Reference<Primitive>(val);
 
   accept(Visitor visitor) => visitor.visitIsTrue(this);
 }
 
 /// Choose between a pair of continuations based on a condition value.
 class Branch extends Expression {
   final Condition condition;
-  final Reference trueContinuation;
-  final Reference falseContinuation;
+  final Reference<Continuation> trueContinuation;
+  final Reference<Continuation> falseContinuation;
 
   Branch(this.condition, Continuation trueCont, Continuation falseCont)
-      : trueContinuation = new Reference(trueCont),
-        falseContinuation = new Reference(falseCont);
+      : trueContinuation = new Reference<Continuation>(trueCont),
+        falseContinuation = new Reference<Continuation>(falseCont);
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
 class Constant extends Primitive {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   values.ConstantValue get value => expression.value;
@@ skipping 15 matching lines @@
   ReifyTypeVar(this.typeVariable);
 
   values.ConstantValue get constant => null;
 
   accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final GenericType type;
-  final List<Reference> values;
+  final List<Reference<Primitive>> values;
 
   LiteralList(this.type, Iterable<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMapEntry {
-  final Reference key;
-  final Reference value;
+  final Reference<Primitive> key;
+  final Reference<Primitive> value;
 
   LiteralMapEntry(Primitive key, Primitive value)
-      : this.key = new Reference(key),
-        this.value = new Reference(value);
+      : this.key = new Reference<Primitive>(key),
+        this.value = new Reference<Primitive>(value);
 }
 
 class LiteralMap extends Primitive {
   final GenericType type;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 }
@@ skipping 11 matching lines @@
   Parameter(Element element) {
     super.hint = element;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
-class Continuation extends Definition implements InteriorNode {
+class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive = false;
 
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters);
 
@@ skipping 26 matching lines @@
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
 
-List<Reference> _referenceList(Iterable<Definition> definitions) {
-  return definitions.map((e) => new Reference(e)).toList();
+List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
+  return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   T visit(Node node) => node.accept(this);
   // Abstract classes.
   T visitNode(Node node) => null;
   T visitExpression(Expression node) => visitNode(node);
   T visitDefinition(Definition node) => visitNode(node);
   T visitPrimitive(Primitive node) => visitDefinition(node);
   T visitCondition(Condition node) => visitNode(node);
@@ skipping 355 matching lines @@
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }