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

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
@@ skipping 141 matching lines @@
   InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeMethod(this, arg);
   }
 }
 
-class InvokeSuperMethod extends Expression implements Invoke {
+/// Invoke [target] on [receiver], bypassing ordinary dispatch semantics.
+class InvokeMethodDirectly extends Expression implements Invoke {
+  Expression receiver;
+  final Element target;
   final Selector selector;
   final List<Expression> arguments;
 
-  InvokeSuperMethod(this.selector, this.arguments);
+  InvokeMethodDirectly(this.receiver, this.target, this.selector,
+      this.arguments);
 
-  accept(ExpressionVisitor visitor) => visitor.visitInvokeSuperMethod(this);
+  accept(ExpressionVisitor visitor) => visitor.visitInvokeMethodDirectly(this);
   accept1(ExpressionVisitor1 visitor, arg) {
-    return visitor.visitInvokeSuperMethod(this, arg);
+    return visitor.visitInvokeMethodDirectly(this, arg);
   }
 }
 
 /**
  * Call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
   final List<Expression> arguments;
@@ skipping 509 matching lines @@
 
   accept(StatementVisitor visitor) => visitor.visitSetField(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
-  E visitInvokeSuperMethod(InvokeSuperMethod node);
+  E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitFieldInitializer(FieldInitializer node);
   E visitSuperInitializer(SuperInitializer node);
   E visitGetField(GetField node);
   E visitCreateBox(CreateBox node);
   E visitCreateClosureClass(CreateClosureClass node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression e, A arg) => e.accept1(this, arg);
   E visitVariable(Variable node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
-  E visitInvokeSuperMethod(InvokeSuperMethod node, A arg);
+  E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
@@ skipping 57 matching lines @@
 
   visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethod(InvokeMethod node) {
     visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
-  visitInvokeSuperMethod(InvokeSuperMethod node) {
+  visitInvokeMethodDirectly(InvokeMethodDirectly node) {
+    visitExpression(node.receiver);
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitConcatenateStrings(ConcatenateStrings node) {
     node.arguments.forEach(visitExpression);
   }
@@ skipping 101 matching lines @@
     visitStatement(node.next);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateClosureClass(CreateClosureClass node) {
     node.arguments.forEach(visitExpression);
   }
 }