Add support for superSend to the new IR and dart backend.

sdk/lib/_internal/compiler/implementation/ir/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 '../dart2jslib.dart' as dart2js show Constant, ConstructedConstant,
   StringConstant, ListConstant, MapConstant;
@@ skipping 160 matching lines @@
            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;
+
+  InvokeSuperMethod(this.selector,
+                    Continuation cont,
+                    List<Definition> args)
+      : continuation = new Reference(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 GenericType type;
   final FunctionElement target;
   final Reference continuation;
   final List<Reference> arguments;
   final Selector selector;
 
   /// The class being instantiated. This is the same as `target.enclosingClass`
@@ skipping 202 matching lines @@
 
   // Concrete classes.
   T visitFunctionDefinition(FunctionDefinition node) => visitNode(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 visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
   T visitBranch(Branch node) => visitExpression(node);
   T visitAsCast(AsCast node) => visitExpression(node);
 
   // Definitions.
   T visitLiteralList(LiteralList node) => visitPrimitive(node);
   T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
   T visitIsCheck(IsCheck node) => visitPrimitive(node);
   T visitConstant(Constant node) => visitPrimitive(node);
@@ skipping 229 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) {
+    node.arguments.forEach(visitReference);
+  }
+
   void visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitConcatenateStrings(ConcatenateStrings node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitBranch(Branch node) {
     visit(node.condition);
@@ skipping 36 matching lines @@
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }