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

sdk/lib/_internal/compiler/implementation/dart_backend/dart_codegen.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 dart_codegen;
 
 import 'dart_tree.dart' as tree;
 import 'dart_printer.dart';
 import 'dart_tree_printer.dart' show TreePrinter;
 import '../tree/tree.dart' as frontend;
@@ skipping 147 matching lines @@
 
   Parameter emitParameter(tree.Variable param) {
     return emitParameterFromElement(param.element, getVariableName(param));
   }
 
   Parameters emitParameters(List<tree.Variable> params) {
     return new Parameters(params.map(emitParameter).toList(growable:false));
   }
 
   /// True if the two expressions are a reference to the same variable.
-  bool isSameVariable(Expression e1, Expression e2) {
+  bool isSameVariable(Receiver e1, Receiver e2) {
     // TODO(asgerf): Using the annotated element isn't the best way to do this
     // since elements are supposed to go away from codegen when we discard the
     // old backend.
     return e1 is Identifier &&
            e2 is Identifier &&
            e1.element is VariableElement &&
            e1.element == e2.element;
   }
 
   Expression makeAssignment(Expression target, Expression value) {
@@ skipping 265 matching lines @@
 
       case SelectorKind.CALL:
         return new CallStatic(null, exp.target.name, emitArguments(exp))
                    ..element = exp.target;
 
       default:
         throw "Unexpected selector kind: ${exp.selector.kind}";
     }
   }
 
-  Expression visitInvokeMethod(tree.InvokeMethod exp) {
-    Expression receiver = visitExpression(exp.receiver);
+  Expression emitMethodCall(tree.Invoke exp, Receiver receiver) {
     List<Argument> args = emitArguments(exp);
     switch (exp.selector.kind) {
       case SelectorKind.CALL:
         if (exp.selector.name == "call") {
           return new CallFunction(receiver, args);
         }
         return new CallMethod(receiver, exp.selector.name, args);
 
       case SelectorKind.OPERATOR:
         if (args.length == 0) {
@@ skipping 18 matching lines @@
         if (args.length == 2) {
           e = makeAssignment(e, args[1]);
         }
         return e;
 
       default:
         throw "Unexpected selector in InvokeMethod: ${exp.selector.kind}";
     }
   }
 
+  Expression visitInvokeMethod(tree.InvokeMethod exp) {
+    Expression receiver = visitExpression(exp.receiver);
+    return emitMethodCall(exp, receiver);
+  }
+
+  Expression visitInvokeSuperMethod(tree.InvokeSuperMethod exp) {
+    return emitMethodCall(exp, new SuperReceiver());
+  }
+
   Expression visitInvokeConstructor(tree.InvokeConstructor exp) {
     List args = emitArguments(exp);
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
     return new CallNew(emitType(exp.type),
                        args,
                        constructorName: name,
                        isConst: exp.constant != null)
                ..constructor = constructor
                ..dartType = exp.type;
@@ skipping 127 matching lines @@
     return new Identifier(name)
                ..element = exp.element;
   }
 
   Expression visitFunction(FunctionConstExp exp) {
     return new Identifier(exp.element.name)
                ..element = exp.element;
   }
 
 }