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

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 759 matching lines @@
   }
 
   @override
   Expression visitInvokeMethod(tree.InvokeMethod exp,
                                BuilderContext<Statement> context) {
     Expression receiver = visitExpression(exp.receiver, context);
     return emitMethodCall(exp, receiver, context);
   }
 
   @override
-  Expression visitInvokeSuperMethod(tree.InvokeSuperMethod exp,
-                                    BuilderContext<Statement> context) {
+  Expression visitInvokeMethodDirectly(tree.InvokeMethodDirectly exp,
+                                       BuilderContext<Statement> context) {
+    // When targeting Dart, InvokeMethodDirectly is only used for super calls.
+    // The receiver is known to be `this`, and the target method is a method
+    // on the super class. So we just translate it as a method call with the
+    // super receiver.

[sigurdm, 2015/01/20 10:54:25]

Perhaps put asserts here that the invariant is maintained

[asgerf, 2015/01/20 13:07:50]

Unfortunately there is no good way to do that. If the receiver is a variable, we
can't tell if it is initialized to 'this', and I don't want the validity of code
generation to be dependent on optimization.

     return emitMethodCall(exp, new SuperReceiver(), context);
   }
 
   @override
   Expression visitInvokeConstructor(tree.InvokeConstructor exp,
                                     BuilderContext<Statement> context) {
     List<Argument> args =
         emitArguments(visitArgumentList(exp.arguments, context), exp.selector);
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
@@ skipping 462 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }