noSuchMethod generated for super calls

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2615 matching lines @@
 
   void pushInvokeHelper4(Element helper, HInstruction a0, HInstruction a1,
                          HInstruction a2, HInstruction a3) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3];
     HInstruction result = new HInvokeStatic(inputs);
     push(result);
   }
 
+  void pushInvokeHelper5(Element helper, HInstruction a0, HInstruction a1,
+                         HInstruction a2, HInstruction a3, HInstruction a4) {
+    HInstruction reference = new HStatic(helper);
+    add(reference);
+    List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3, a4];
+    HInstruction result = new HInvokeStatic(inputs);
+    push(result);
+  }
+
   visitOperatorSend(node) {
     assert(node.selector is Operator);
     if (!methodInterceptionEnabled) {
       visitDynamicSend(node);
       return;
     }
 
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
       HStatic target = new HStatic(interceptors.getIndexInterceptor());
@@ skipping 378 matching lines @@
     } else if (name == const SourceString('JS_CALL_IN_ISOLATE')) {
       handleForeignJsCallInIsolate(node);
     } else if (name == const SourceString('DART_CLOSURE_TO_JS')) {
       handleForeignDartClosureToJs(node);
     } else {
       throw "Unknown foreign: ${selector}";
     }
   }
 
   generateSuperNoSuchMethodSend(Send node) {
+    Selector selector = elements.getSelector(node);
+    SourceString name = selector.name;
+    compiler.enqueuer.codegen.registerDynamicInvocation(name, selector);

[ngeoffray, 2012/12/06 22:46:09]

Why do you need this? Because you're creating an invocation mirror? What if the
invocation mirror is not being used? Wouldn't that lead to compiling unused
methods?

If I'm right, I think you can avoid it by just checking that the super class
implements noSuchMethod.

[Johnni Winther, 2012/12/11 14:26:41]

Removed.

+
     ClassElement cls = work.element.getEnclosingClass();
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     HStatic target = new HStatic(element);
     add(target);
     HInstruction self = localsHandler.readThis();
-    Identifier identifier = node.selector.asIdentifier();
-    String name = identifier.source.slowToString();
-    // TODO(ahe): Add the arguments to this list.
-    push(new HLiteralList([]));
-    Constant nameConstant =
-        constantSystem.createString(new DartString.literal(name), node);
+    Constant nameConstant = constantSystem.createString(
+        new DartString.literal(name.slowToString()), node);
+
+    String internalName = backend.namer.instanceMethodInvocationName(
+        currentLibrary, name, selector);
+    Constant internalNameConstant =
+        constantSystem.createString(new DartString.literal(internalName), node);
+
+    Element createInvocationMirror =
+        compiler.findHelper(Compiler.CREATE_INVOCATION_MIRROR);
+
+    var arguments = new List<HInstruction>();
+    addGenericSendArgumentsToList(node.arguments, arguments);
+    var argumentsInstruction = new HLiteralList(arguments);
+    add(argumentsInstruction);
+
+    var argumentNames = new List<HInstruction>();
+    for (SourceString argumentName in selector.namedArguments) {
+      Constant argumentNameConstant =
+          constantSystem.createString(new DartString.literal(
+              argumentName.slowToString()), node);
+      argumentNames.add(graph.addConstant(argumentNameConstant));
+    }
+    var argumentNamesInstruction = new HLiteralList(argumentNames);
+    add(argumentNamesInstruction);
+
+    Constant kindConstant =
+        constantSystem.createInt(selector.invocationMirrorKind);
+
+    pushInvokeHelper5(createInvocationMirror,
+                      graph.addConstant(nameConstant),
+                      graph.addConstant(internalNameConstant),
+                      graph.addConstant(kindConstant),
+                      argumentsInstruction,
+                      argumentNamesInstruction);
+
     var inputs = <HInstruction>[
         target,
         self,
-        graph.addConstant(nameConstant),
         pop()];
     push(new HInvokeSuper(inputs));
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (element != null && identical(element, work.element)) {
       graph.isRecursiveMethod = true;
     }
     super.visitSend(node);
@@ skipping 1898 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }