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

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 728 matching lines @@
       receiver = visitReceiver(node.receiver);
       List<ir.Primitive> arguments = new List<ir.Primitive>();
       if (selector.isIndex) {
         index = visit(node.arguments.head);
         arguments.add(index);
       }
 
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.INDEX);
       if (isSuperCall(node)) {
-        result = irBuilder.buildSuperInvocation(selector, arguments);
+        result = irBuilder.buildSuperInvocation(element, selector, arguments);
       } else {
         result =
             irBuilder.buildDynamicInvocation(receiver, selector, arguments);
       }
     } else if (element.isField || element.isGetter || element.isErroneous ||
                element.isSetter) {
       // TODO(johnniwinther): Change handling of setter selectors.
       // Access to a static field or getter (non-static case handled above).
       // Even if there is only a setter, we compile as if it was a getter,
       // so the vm can fail at runtime.
@@ skipping 80 matching lines @@
         node.arguments.mapToList(visit, growable:false);
     return irBuilder.buildStaticInvocation(element, selector, arguments);
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(irBuilder.isOpen);
     if (node.isPropertyAccess) {
       return visitGetterSend(node);
     } else {
       Selector selector = elements.getSelector(node);
+      Element target = elements[node];
       List<ir.Primitive> arguments = new List<ir.Primitive>();
       for (ast.Node n in node.arguments) {
         arguments.add(visit(n));
       }
-      return irBuilder.buildSuperInvocation(selector, arguments);
+      return irBuilder.buildSuperInvocation(target, selector, arguments);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
     assert(irBuilder.isOpen);
     // If the user is trying to invoke the type literal or variable,
@@ skipping 82 matching lines @@
                 Elements.isStaticOrTopLevel(element)) {
       irBuilder.buildStaticSet(
           element, elements.getSelector(node), valueToStore);
     } else {
       // Setter or index-setter invocation
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.SETTER ||
           selector.kind == SelectorKind.INDEX);
       if (selector.isIndexSet) {
         if (isSuperCall(node)) {
-          irBuilder.buildSuperIndexSet(index, valueToStore);
+          irBuilder.buildSuperIndexSet(element, index, valueToStore);
         } else {
           irBuilder.buildDynamicIndexSet(receiver, index, valueToStore);
         }
       } else {
         if (isSuperCall(node)) {
-          irBuilder.buildSuperSet(selector, valueToStore);
+          irBuilder.buildSuperSet(element, selector, valueToStore);
         } else {
           irBuilder.buildDynamicSet(receiver, selector, valueToStore);
         }
       }
     }
 
     if (node.isPostfix) {
       assert(originalValue != null);
       return originalValue;
     } else {
@@ skipping 176 matching lines @@
     currentFunction = elements[node];
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }