Handle super-method invocations in CPS->JS backend.

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 179 matching lines @@
         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<Primitive> receiver;
+  Reference<Primitive> receiver;
   final Selector selector;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
 
   InvokeMethod(Primitive receiver,
                Selector selector,
                Continuation cont,
                List<Primitive> args)
       : this.internal(new Reference<Primitive>(receiver),
                       selector,
@@ skipping 11 matching lines @@
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
   bool get isIntercepted => receiver.definition is Interceptor;
 
   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 {
+/// 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.
+///
+/// When targeting Dart, this instruction is used to represent super calls.
+/// Here, [receiver] must always be a reference to `this`, and [target] must be
+/// a method that is available in the super class.
+class InvokeMethodDirectly extends Expression implements Invoke {
+  Reference<Primitive> receiver;
+  final Element target;
   final Selector selector;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
 
-  InvokeSuperMethod(this.selector,
-                    Continuation cont,
-                    List<Primitive> args)
-      : continuation = new Reference<Continuation>(cont),
+  InvokeMethodDirectly(Primitive receiver,
+                       this.target,
+                       this.selector,
+                       Continuation cont,
+                       List<Primitive> args)
+      : this.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.visitInvokeSuperMethod(this);
+  accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(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> continuation;
   final List<Reference<Primitive>> arguments;
   final Selector selector;
@@ skipping 540 matching lines @@
   T visitInitializer(Initializer node) => visitNode(node);
   T visitFieldInitializer(FieldInitializer node) => visitInitializer(node);
   T visitSuperInitializer(SuperInitializer node) => visitInitializer(node);
 
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
-  T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
+  T visitInvokeMethodDirectly(InvokeMethodDirectly node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitTypeOperator(TypeOperator node) => visitExpression(node);
   T visitSetClosureVariable(SetClosureVariable node) => visitExpression(node);
   T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
   T visitSetField(SetField node) => visitExpression(node);
 
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
@@ skipping 108 matching lines @@
   }
 
   processInvokeMethod(InvokeMethod node) {}
   visitInvokeMethod(InvokeMethod node) {
     processInvokeMethod(node);
     processReference(node.receiver);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
-  processInvokeSuperMethod(InvokeSuperMethod node) {}
-  visitInvokeSuperMethod(InvokeSuperMethod node) {
-    processInvokeSuperMethod(node);
+  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);
   }
@@ skipping 251 matching lines @@
 
   void visitInvokeContinuation(InvokeContinuation node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     visitReference(node.receiver);
     node.arguments.forEach(visitReference);
   }
 
-  void visitInvokeSuperMethod(InvokeSuperMethod node) {
+  void visitInvokeMethodDirectly(InvokeMethodDirectly node) {
+    visitReference(node.receiver);
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitConcatenateStrings(ConcatenateStrings node) {
     node.arguments.forEach(visitReference);
   }
@@ skipping 83 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }