dart2js cps: Fuse tear-off and call invocation.

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 '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../types/types.dart' show TypeMask;
@@ skipping 77 matching lines @@
     if (this.hint == null) {
       this.hint = hint;
     }
   }
 
   /// True if the primitive can be removed, assuming it has no uses
   /// (this getter does not check if there are any uses).
   ///
   /// False must be returned for primitives that may throw, diverge, or have
   /// observable side-effects.
-  bool get isSafeForElimination => true;
+  bool get isSafeForElimination;
+
+  /// True if time-of-evaluation is irrelevant for the given primitive,
+  /// assuming its inputs are the same values.
+  bool get isSafeForReordering;
 }
 
 /// 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 150 matching lines @@
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
                List<Primitive> args,
                Continuation cont,
                [this.sourceInformation])
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
+  InvokeStatic.byReference(this.target,
+                           this.selector,
+                           this.arguments,
+                           this.continuation,
+                           [this.sourceInformation]);
+
   accept(Visitor visitor) => visitor.visitInvokeStatic(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).
 ///
@@ skipping 13 matching lines @@
   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);
 
+  InvokeMethod.byReference(this.receiver,
+                           this.selector,
+                           this.mask,
+                           this.arguments,
+                           this.continuation,
+                           [this.sourceInformation]);
+
   accept(Visitor visitor) => visitor.visitInvokeMethod(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,
@@ skipping 85 matching lines @@
   /// Otherwise the list is empty.
   final List<Reference<Primitive>> typeArguments;
 
   TypeTest(Primitive value,
            this.type,
            List<Primitive> typeArguments)
   : this.value = new Reference<Primitive>(value),
     this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeTest(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// 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
@@ skipping 22 matching lines @@
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinOperator extends Primitive {
   BuiltinOperator operator;
   List<Reference<Primitive>> arguments;
 
   ApplyBuiltinOperator(this.operator, List<Primitive> arguments)
       : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitApplyBuiltinOperator(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// 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 Expression {
   Reference<Primitive> value;
 
   Throw(Primitive value) : value = new Reference<Primitive>(value);
@@ skipping 15 matching lines @@
 /// The CPS translation of an expression produces a primitive as the value
 /// of the expression.  For convenience in the implementation of the
 /// translation, a [NonTailThrow] is used as that value.  A cleanup pass
 /// removes these and replaces them with [Throw] expressions.
 class NonTailThrow extends Primitive {
   final Reference<Primitive> value;
 
   NonTailThrow(Primitive value) : value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitNonTailThrow(this);
+
+  bool get isSafeForElimination => false;
+  bool get isSafeForReordering => false;
 }
 
 /// An expression that is known to be unreachable.
 ///
 /// This can be placed as the body of a call continuation, when the caller is
 /// known never to invoke it, e.g. because the calling expression always throws.
 class Unreachable extends Expression {
   accept(Visitor visitor) => visitor.visitUnreachable(this);
 }
 
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutableVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutableVariable extends Primitive {
   final Reference<MutableVariable> variable;
 
   GetMutableVariable(MutableVariable variable)
       : this.variable = new Reference<MutableVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitGetMutableVariable(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => false;
 }
 
 /// 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 SetMutableVariable extends Expression implements InteriorNode {
   final Reference<MutableVariable> variable;
@@ skipping 97 matching lines @@
   /// 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;
 
   GetField(Primitive object, this.field)
       : this.object = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 
-  @override
   bool get isSafeForElimination => objectIsNotNull;
+  bool get isSafeForReordering => objectIsNotNull && field.isFinal;
 }
 
 /// Reads the value of a static field or tears off a static method.
+///
+/// Note that lazily initialized fields should be read using GetLazyStatic.
 class GetStatic extends Primitive {
   /// Can be [FieldElement] or [FunctionElement].
   final Element element;
   final SourceInformation sourceInformation;
 
   GetStatic(this.element, [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitGetStatic(this);
+  
+  bool get isSafeForElimination {
+    return true;
+  }
+  bool get isSafeForReordering {
+    return element is FunctionElement || element.isFinal;
+  }
 }
 
 /// Sets the value of a static field.
 class SetStatic extends Expression implements InteriorNode {
   final FieldElement element;
   final Reference<Primitive> value;
   Expression body;
   final SourceInformation sourceInformation;
 
   SetStatic(this.element, Primitive value, [this.sourceInformation])
@@ skipping 22 matching lines @@
                 Continuation continuation,
                 [this.sourceInformation])
       : continuation = new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitGetLazyStatic(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;
 }
 
 /// 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;
 
   /// 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 List<Reference<Primitive>> typeInformation;
 
   CreateInstance(this.classElement, List<Primitive> arguments,
       List<Primitive> typeInformation)
       : this.arguments = _referenceList(arguments),
         this.typeInformation = _referenceList(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 class Interceptor extends Primitive {
   final Reference<Primitive> input;
   final Set<ClassElement> interceptedClasses;
   Interceptor(Primitive input, this.interceptedClasses)
       : this.input = new Reference<Primitive>(input);
   accept(Visitor visitor) => visitor.visitInterceptor(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// Create an instance of [Invocation] for use in a call to `noSuchMethod`.
 class CreateInvocationMirror extends Primitive {
   final Selector selector;
   final List<Reference<Primitive>> arguments;
 
   CreateInvocationMirror(this.selector, List<Primitive> arguments)
       : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitCreateInvocationMirror(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 class ForeignCode extends Expression {
   final js.Template codeTemplate;
   final TypeMask type;
   final List<Reference<Primitive>> arguments;
   final native.NativeBehavior nativeBehavior;
   final FunctionElement dependency;
 
   /// The continuation, if the foreign code is not a JavaScript 'throw',
   /// otherwise null.
   final Reference<Continuation> continuation;
 
   ForeignCode(this.codeTemplate, this.type, List<Primitive> arguments,
       this.nativeBehavior, {Continuation continuation, this.dependency})
       : arguments = _referenceList(arguments),
         continuation = continuation == null ? null
             : new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 }
 
 class Constant extends Primitive {
   final values.ConstantValue value;
 
   Constant(this.value);
 
   accept(Visitor visitor) => visitor.visitConstant(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final InterfaceType type;
   final List<Reference<Primitive>> values;
 
   LiteralList(this.type, List<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 class LiteralMapEntry {
   final Reference<Primitive> key;
   final Reference<Primitive> value;
 
   LiteralMapEntry(Primitive key, Primitive value)
       : this.key = new Reference<Primitive>(key),
         this.value = new Reference<Primitive>(value);
 }
 
 class LiteralMap extends Primitive {
   final InterfaceType type;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// Currently unused.
 ///
 /// Nested functions (from Dart code) are translated to classes by closure
 /// conversion, hence they are instantiated with [CreateInstance].
 ///
 /// We keep this around for now because it might come in handy when we
 /// handle async/await in the CPS IR.
 ///
 /// Instantiates a nested function. [MutableVariable]s are in scope in the
 /// inner function, but primitives are not shared across function boundaries.
 class CreateFunction extends Primitive {
   final FunctionDefinition definition;
 
   CreateFunction(this.definition);
 
   accept(Visitor visitor) => visitor.visitCreateFunction(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 class Parameter extends Primitive {
   Parameter(Entity hint) {
     super.hint = hint;
   }
 
   // In addition to a parent pointer to the containing Continuation or
   // FunctionDefinition, parameters have an index into the list of parameters
   // bound by the parent.  This gives constant-time access to the continuation
   // from the parent.
   int parentIndex;
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 
   String toString() => 'Parameter(${hint == null ? null : hint.name})';
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// 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<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
   // In addition to a parent pointer to the containing LetCont, continuations
@@ skipping 46 matching lines @@
 /// [Type].
 class ReifyRuntimeType extends Primitive {
   /// Reference to the internal representation of a type (as produced, for
   /// example, by [ReadTypeVariable]).
   final Reference<Primitive> value;
   ReifyRuntimeType(Primitive value)
     : this.value = new Reference<Primitive>(value);
 
   @override
   accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// 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;
 
   ReadTypeVariable(this.variable, Primitive target)
       : this.target = new Reference<Primitive>(target);
 
   @override
   accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 /// Representation of a closed type (that is, a type without type variables).
 ///
 /// The resulting value is constructed from [dartType] by replacing the type
 /// variables with consecutive values from [arguments], in the order generated
 /// by [DartType.forEachTypeVariable].  The type variables in [dartType] are
 /// treated as 'holes' in the term, which means that it must be ensured at
 /// construction, that duplicate occurences of a type variable in [dartType]
 /// are assigned the same value.
 class TypeExpression extends Primitive {
   final DartType dartType;
   final List<Reference<Primitive>> arguments;
 
   TypeExpression(this.dartType,
                  [List<Primitive> arguments = const <Primitive>[]])
       : this.arguments = _referenceList(arguments);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitTypeExpression(this);
   }
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node);
@@ skipping 339 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }