dart2js cps: Refactor CallExpressions into Primitives.

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 '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 105 matching lines @@
     assert(parent == null);
     assert(body == null);
     Expression child = newParent.body;
     newParent.body = this;
     this.body = child;
     child.parent = this;
     this.parent = newParent;
   }
 }
 
-/// An expression that passes a continuation to a call.
-abstract class CallExpression extends Expression {
-  Reference<Continuation> get continuation;
-  Expression get next => continuation.definition.body;
-}
-
 /// An expression without a continuation or a subexpression body.
 ///
 /// These break straight-line control flow and can be thought of as ending a
 /// basic block.
 abstract class TailExpression extends Expression {
   Expression get next => null;
 }
 
 /// The base class of things that variables can refer to: primitives,
 /// continuations, function and continuation parameters, etc.
 abstract class Definition<T extends Definition<T>> extends Node {
   // The head of a linked-list of occurrences, in no particular order.
   Reference<T> firstRef;
 
   bool get hasAtMostOneUse  => firstRef == null || firstRef.next == null;
   bool get hasExactlyOneUse => firstRef != null && firstRef.next == null;
   bool get hasNoUses => firstRef == null;
   bool get hasAtLeastOneUse => firstRef != null;
   bool get hasMultipleUses  => !hasAtMostOneUse;
 
-  void substituteFor(Definition<T> other) {
-    if (other == this) return;
-    if (other.hasNoUses) return;
-    Reference<T> previous, current = other.firstRef;
+  void replaceUsesWith(Definition<T> newDefinition) {
+    if (newDefinition == this) return;
+    if (hasNoUses) return;
+    Reference<T> previous, current = firstRef;
     do {
-      current.definition = this;
+      current.definition = newDefinition;
       previous = current;
       current = current.next;
     } while (current != null);
-    previous.next = firstRef;
-    if (firstRef != null) firstRef.previous = previous;
-    firstRef = other.firstRef;
-    other.firstRef = null;
+    previous.next = newDefinition.firstRef;
+    if (newDefinition.firstRef != null) {
+      newDefinition.firstRef.previous = previous;
+    }
+    newDefinition.firstRef = firstRef;
+    firstRef = null;
   }
 }
 
 class EffectiveUseIterator extends Iterator<Reference<Primitive>> {
   Reference<Primitive> current;
   Reference<Primitive> next;
   final List<Refinement> stack = <Refinement>[];
 
   EffectiveUseIterator(Primitive prim) : next = prim.firstRef;
 
@@ skipping 86 matching lines @@
 
   bool get hasNoEffectiveUses {
     return effectiveUses.isEmpty;
   }
 
   /// Unlinks all references contained in this node.
   void destroy() {
     assert(hasNoUses);
     RemovalVisitor.remove(this);
   }
+
+  /// Replaces this definition, both at the binding site and at all uses sites.
+  ///
+  /// This can be thought of as changing the definition of a `let` while
+  /// preserving the variable name:
+  ///
+  ///     let x = OLD in BODY
+  ///       ==>
+  ///     let x = NEW in BODY
+  ///
+  void replaceWith(Primitive newDefinition) {
+    assert(this is! Parameter);
+    assert(newDefinition is! Parameter);
+    assert(newDefinition.parent == null);
+    replaceUsesWith(newDefinition);
+    destroy();
+    LetPrim let = parent;
+    let.primitive = newDefinition;
+    newDefinition.parent = let;
+    newDefinition.useElementAsHint(hint);
+  }
+}
+
+/// A primitive that is generally not safe for elimination, but may be marked
+/// as safe by type propagation
+//
+// TODO(asgerf): Store the flag in a bitmask in [Primitive] and get rid of this
+//               class.
+abstract class UnsafePrimitive extends Primitive {
+  bool isSafeForElimination = false;
+  bool isSafeForReordering = false;
 }
 
 /// Operands to invocations and primitives are always variables.  They point to
 /// their definition and are doubly-linked into a list of occurrences.
 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.
@@ skipping 147 matching lines @@
 }
 
 /// 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 CallExpression {
+class InvokeStatic extends UnsafePrimitive {
   final FunctionElement target;
   final Selector selector;
   final List<Reference<Primitive>> arguments;
-  final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
                List<Primitive> args,
-               Continuation cont,
                [this.sourceInformation])
-      : arguments = _referenceList(args),
-        continuation = new Reference<Continuation>(cont);
+      : arguments = _referenceList(args);
 
   InvokeStatic.byReference(this.target,
                            this.selector,
                            this.arguments,
-                           this.continuation,
                            [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
-    continuation.parent = this;
   }
 }
 
+enum CallingConvention {
+  /// JS receiver is the Dart receiver, there are no extra arguments.
+  ///
+  /// For example: `foo.bar$1(x)`
+  Normal,
+
+  /// JS receiver is an interceptor, the first argument is the Dart receiver.
+  ///
+  /// For example: `getInterceptor(foo).bar$1(foo, x)`
+  Intercepted,
+
+  /// JS receiver is the Dart receiver, the first argument is a dummy value.
+  ///
+  /// For example: `foo.bar$1(0, x)`
+  DummyIntercepted,
+}
+
 /// 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 CallExpression {
+class InvokeMethod extends UnsafePrimitive {
   Reference<Primitive> receiver;
   Selector selector;
   TypeMask mask;
   final List<Reference<Primitive>> arguments;
-  final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
-  /// If true, the [receiver] is intercepted and the actual receiver is in
-  /// the first argument. Otherwise, the [receiver] is the actual receiver.
-  ///
-  /// This flag is always false for non-intercepted selectors, but it may also
-  /// be false for intercepted selectors after dummy receiver optimization
-  /// (in this case the first argument is a dummy value).
-  ///
-  /// It is always false before the unsugaring pass, where interceptors have
-  /// not yet been introduced.
-  bool receiverIsIntercepted = false;
+  CallingConvention callingConvention = CallingConvention.Normal;
+
+  Reference<Primitive> get dartReceiverReference {
+    return callingConvention == CallingConvention.Intercepted
+        ? arguments[0]
+        : receiver;
+  }
+
+  Primitive get dartReceiver => dartReceiverReference.definition;
+
+  Reference<Primitive> dartArgumentReference(int n) {
+    return callingConvention == CallingConvention.Normal
+        ? arguments[n]
+        : arguments[n + 1];
+  }
+
+  Primitive dartArgument(int n) => dartArgumentReference(n).definition;
 
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
   InvokeMethod(Primitive receiver,
                this.selector,
                this.mask,
                List<Primitive> arguments,
-               Continuation continuation,
                [this.sourceInformation])
       : this.receiver = new Reference<Primitive>(receiver),
-        this.arguments = _referenceList(arguments),
-        this.continuation = new Reference<Continuation>(continuation);
+        this.arguments = _referenceList(arguments);
 
   InvokeMethod.byReference(this.receiver,
                            this.selector,
                            this.mask,
                            this.arguments,
-                           this.continuation,
                            this.sourceInformation);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, this);
-    continuation.parent = 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 CallExpression {
+class InvokeMethodDirectly extends UnsafePrimitive {
   Reference<Primitive> receiver;
   final FunctionElement target;
   final Selector selector;
   final List<Reference<Primitive>> arguments;
-  final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
+  CallingConvention callingConvention = CallingConvention.Normal;
+
+  Reference<Primitive> get dartReceiverReference {
+    return callingConvention == CallingConvention.Intercepted
+        ? arguments[0]
+        : receiver;
+  }
+
+  Primitive get dartReceiver => dartReceiverReference.definition;
+
+  Reference<Primitive> dartArgumentReference(int n) {
+    return callingConvention == CallingConvention.Normal
+        ? arguments[n]
+        : arguments[n + 1];
+  }
+
+  Primitive dartArgument(int n) => dartArgumentReference(n).definition;
+
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
                        List<Primitive> arguments,
-                       Continuation continuation,
                        this.sourceInformation)
       : this.receiver = new Reference<Primitive>(receiver),
-        this.arguments = _referenceList(arguments),
-        this.continuation = new Reference<Continuation>(continuation);
+        this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, this);
-    continuation.parent = this;
   }
 }
 
 /// 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 CallExpression {
+class InvokeConstructor extends UnsafePrimitive {
   final DartType dartType;
   final ConstructorElement target;
   final List<Reference<Primitive>> arguments;
-  final Reference<Continuation> continuation;
   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,
-                    Continuation cont,
                     this.sourceInformation,
                     {this.allocationSiteType})
-      : arguments = _referenceList(args),
-        continuation = new Reference<Continuation>(cont);
+      : arguments = _referenceList(args);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
-    continuation.parent = 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 87 matching lines @@
 /// 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 CallExpression {
+class TypeCast extends UnsafePrimitive {
   Reference<Primitive> value;
   final DartType dartType;
 
   /// See the corresponding field on [TypeTest].
   final List<Reference<Primitive>> typeArguments;
-  final Reference<Continuation> continuation;
 
   TypeCast(Primitive value,
            this.dartType,
-           List<Primitive> typeArguments,
-           Continuation cont)
+           List<Primitive> typeArguments)
       : this.value = new Reference<Primitive>(value),
-        this.typeArguments = _referenceList(typeArguments),
-        this.continuation = new Reference<Continuation>(cont);
+        this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeCast(this);
 
   void setParentPointers() {
     value.parent = this;
+    _setParentsOnList(typeArguments, 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;
   final SourceInformation sourceInformation;
@@ skipping 367 matching lines @@
 
   void setParentPointers() {
     value.parent = this;
   }
 }
 
 /// 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.
-///
-/// [continuation] is then invoked with the value of the field as argument.
-class GetLazyStatic extends CallExpression {
+class GetLazyStatic extends UnsafePrimitive {
   final FieldElement element;
-  final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
-  GetLazyStatic(this.element,
-                Continuation continuation,
-                [this.sourceInformation])
-      : continuation = new Reference<Continuation>(continuation);
+  GetLazyStatic(this.element, [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitGetLazyStatic(this);
 
   void setParentPointers() {
-    continuation.parent = this;
   }
 }
 
 /// Creates an object for holding boxed variables captured by a closure.
 class CreateBox extends Primitive {
   accept(Visitor visitor) => visitor.visitCreateBox(this);
 
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
@@ skipping 141 matching lines @@
   accept(Visitor visitor) => visitor.visitCreateInvocationMirror(this);
 
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
-class ForeignCode extends CallExpression {
+class ForeignCode extends UnsafePrimitive {
   final js.Template codeTemplate;
   final TypeMask type;
   final List<Reference<Primitive>> arguments;
   final native.NativeBehavior nativeBehavior;
   final FunctionElement dependency;
-  final Reference<Continuation> continuation;
 
   ForeignCode(this.codeTemplate, this.type, List<Primitive> arguments,
-      this.nativeBehavior, Continuation continuation, {this.dependency})
-      : this.arguments = _referenceList(arguments),
-        this.continuation = new Reference<Continuation>(continuation);
+      this.nativeBehavior, {this.dependency})
+      : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
-    continuation.parent = this;
   }
 }
 
 class Constant extends Primitive {
   final values.ConstantValue value;
   final SourceInformation sourceInformation;
 
   Constant(this.value, {this.sourceInformation}) {
     assert(value != null);
   }
@@ skipping 235 matching lines @@
   }
 
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
-class Await extends CallExpression {
+class Await extends UnsafePrimitive {
   final Reference<Primitive> input;
-  final Reference<Continuation> continuation;
 
-  Await(Primitive input, Continuation continuation)
-    : this.input = new Reference<Primitive>(input),
-      this.continuation = new Reference<Continuation>(continuation);
+  Await(Primitive input)
+    : this.input = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitAwait(this);
   }
 
   void setParentPointers() {
     input.parent = this;
-    continuation.parent = this;
   }
 }
 
-class Yield extends CallExpression {
+class Yield extends UnsafePrimitive {
   final Reference<Primitive> input;
-  final Reference<Continuation> continuation;
   final bool hasStar;
 
-  Yield(Primitive input, this.hasStar, Continuation continuation)
-    : this.input = new Reference<Primitive>(input),
-      this.continuation = new Reference<Continuation>(continuation);
+  Yield(Primitive input, this.hasStar)
+    : this.input = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitYield(this);
   }
 
   void setParentPointers() {
     input.parent = this;
-    continuation.parent = this;
   }
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 void _setParentsOnNodes(List<Node> nodes, Node parent) {
   for (Node node in nodes) {
     node.parent = parent;
@@ skipping 128 matching lines @@
   visitLetMutable(LetMutable node) {
     processLetMutable(node);
     visit(node.variable);
     processReference(node.value);
     visit(node.body);
   }
 
   processInvokeStatic(InvokeStatic node) {}
   visitInvokeStatic(InvokeStatic node) {
     processInvokeStatic(node);
-    processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeContinuation(InvokeContinuation node) {}
   visitInvokeContinuation(InvokeContinuation node) {
     processInvokeContinuation(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeMethod(InvokeMethod node) {}
   visitInvokeMethod(InvokeMethod node) {
     processInvokeMethod(node);
     processReference(node.receiver);
-    processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {}
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     processInvokeMethodDirectly(node);
     processReference(node.receiver);
-    processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeConstructor(InvokeConstructor node) {}
   visitInvokeConstructor(InvokeConstructor node) {
     processInvokeConstructor(node);
-    processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processThrow(Throw node) {}
   visitThrow(Throw node) {
     processThrow(node);
     processReference(node.value);
   }
 
   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);
   }
 
   processTypeCast(TypeCast node) {}
   visitTypeCast(TypeCast node) {
     processTypeCast(node);
-    processReference(node.continuation);
     processReference(node.value);
     node.typeArguments.forEach(processReference);
   }
 
   processTypeTest(TypeTest node) {}
   visitTypeTest(TypeTest node) {
     processTypeTest(node);
     processReference(node.value);
     if (node.interceptor != null) processReference(node.interceptor);
     node.typeArguments.forEach(processReference);
   }
 
   processTypeTestViaFlag(TypeTestViaFlag node) {}
   visitTypeTestViaFlag(TypeTestViaFlag node) {
     processTypeTestViaFlag(node);
     processReference(node.interceptor);
   }
 
   processSetMutable(SetMutable node) {}
   visitSetMutable(SetMutable node) {
     processSetMutable(node);
     processReference(node.variable);
     processReference(node.value);
   }
 
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
     processGetLazyStatic(node);
-    processReference(node.continuation);
   }
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
     node.values.forEach(processReference);
   }
 
   processLiteralMap(LiteralMap node) {}
   visitLiteralMap(LiteralMap node) {
@@ skipping 106 matching lines @@
   processApplyBuiltinMethod(ApplyBuiltinMethod node) {}
   visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     processApplyBuiltinMethod(node);
     processReference(node.receiver);
     node.arguments.forEach(processReference);
   }
 
   processForeignCode(ForeignCode node) {}
   visitForeignCode(ForeignCode node) {
     processForeignCode(node);
-    if (node.continuation != null) {
-      processReference(node.continuation);
-    }
     node.arguments.forEach(processReference);
   }
 
   processUnreachable(Unreachable node) {}
   visitUnreachable(Unreachable node) {
     processUnreachable(node);
   }
 
   processAwait(Await node) {}
   visitAwait(Await node) {
     processAwait(node);
     processReference(node.input);
-    processReference(node.continuation);
   }
 
   processYield(Yield node) {}
   visitYield(Yield node) {
     processYield(node);
     processReference(node.input);
-    processReference(node.continuation);
   }
 
   processGetLength(GetLength node) {}
   visitGetLength(GetLength node) {
     processGetLength(node);
     processReference(node.object);
   }
 
   processGetIndex(GetIndex node) {}
   visitGetIndex(GetIndex node) {
@@ skipping 141 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends TrampolineRecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }