Make unmatched static call a runtime error.

lib/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;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 2282 matching lines @@
 
   void pushInvokeHelper3(Element helper, HInstruction a0, HInstruction a1,
                          HInstruction a2) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2];
     HInstruction result = new HInvokeStatic(inputs);
     push(result);
   }
 
+  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);
+  }
+
   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 413 matching lines @@
     // creating an [HStatic].
     HInstruction target = new HStatic(element.declaration);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (node.isPropertyAccess) {
       push(new HInvokeSuper(inputs));
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
+      FunctionElement function = element.implementation;
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
-                                                    element.implementation,
-                                                    inputs);
+                                                    function, inputs);
       if (!succeeded) {
-        // TODO(ngeoffray): Match the VM behavior and throw an
-        // exception at runtime.
-        compiler.cancel('Unimplemented non-matching static call', node: node);
+        generateWrongArgumentCountError(node, element, node.arguments);
+      } else {
+        push(new HInvokeSuper(inputs));
       }
-      push(new HInvokeSuper(inputs));
     } else {
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
@@ skipping 178 matching lines @@
     HInstruction target = new HStatic(constructor.declaration);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor.implementation,
                                                   inputs);
     if (!succeeded) {
-      // TODO(ngeoffray): Match the VM behavior and throw an
-      // exception at runtime.
-      compiler.cancel('Unimplemented non-matching static call', node: node);
+      generateWrongArgumentCountError(node, constructor, node.arguments);
+      return;
     }
 
     TypeAnnotation annotation = node.getTypeAnnotation();
     if (annotation == null) {
       compiler.internalError("malformed send in new expression");
     }
     InterfaceType type = elements.getType(annotation);
     if (type.element.modifiers.isAbstract() &&
         constructor.isGenerativeConstructor()) {
       generateAbstractClassInstantiationError(node, type.name.slowToString());
@@ skipping 20 matching lines @@
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element.isErroneous()) {
       generateThrowNoSuchMethod(node,
                                 getTargetName(element),
                                 argumentNodes: node.arguments);
       return;
     }
-    if (identical(element, compiler.assertMethod) && !compiler.enableUserAssertions) {
+    if (identical(element, compiler.assertMethod)
+        && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(constantSystem));
       return;
     }
     compiler.ensure(!element.isGenerativeConstructor());
     if (element.isFunction()) {
       if (tryInlineMethod(element, selector, node.arguments)) {
         return;
       }
 
       HInstruction target = new HStatic(element);
       add(target);
       var inputs = <HInstruction>[target];
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
-        // TODO(ngeoffray): Match the VM behavior and throw an
-        // exception at runtime.
-        compiler.cancel('Unimplemented non-matching static call', node: node);
+        generateWrongArgumentCountError(node, element, node.arguments);
+        return;
       }
 
       // TODO(kasperl): Try to use the general inlining infrastructure for
       // inlining the identical function.
       if (identical(element, compiler.identicalFunction)) {
         pushWithPosition(new HIdentity(target, inputs[1], inputs[2]), node);
         return;
       }
 
       HInvokeStatic instruction = new HInvokeStatic(inputs);
@@ skipping 35 matching lines @@
 
   void generateAbstractClassInstantiationError(Node node, String message) {
     generateError(node,
                   message,
                   interceptors.getThrowAbstractClassInstantiationError());
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  {Link<Node> argumentNodes,
-                                  List<HInstruction> argumentValues}) {
+                                  List<HInstruction> argumentValues,
+                                  List<String> existingArguments}) {
     Element helper =
         compiler.findHelper(const SourceString('throwNoSuchMethod'));
     Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
     HInstruction name = graph.addConstant(nameConstant);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
     HInstruction arguments = new HLiteralList(argumentValues);
     add(arguments);
-    pushInvokeHelper3(helper, receiver, name, arguments);
+    HInstruction existingNamesList;
+    if (existingArguments != null) {
+      List<HInstruction> existingNames = <HInstruction>[];
+      for (String name in existingArguments) {
+        HInstruction nameConstant =
+            graph.addConstantString(new DartString.literal(name),
+                                    diagnosticNode, constantSystem);
+        existingNames.add(nameConstant);
+      }
+      existingNamesList = new HLiteralList(existingNames);
+      add(existingNamesList);
+    } else {
+      existingNamesList = graph.addConstantNull(constantSystem);
+    }
+    pushInvokeHelper4(helper, receiver, name, arguments, existingNamesList);
+  }
+
+  /**
+   * Generate code to throw a [NoSuchMethodError] exception for calling a
+   * method with a wrong number of arguments or mismatching named optional
+   * arguments.
+   */
+  void generateWrongArgumentCountError(Node diagnosticNode,
+                                       FunctionElement function,
+                                       Link<Node> argumentNodes) {
+    List<String> existingArguments = <String>[];
+    FunctionSignature signature = function.computeSignature(compiler);
+    signature.forEachParameter((Element parameter) {
+      existingArguments.add(parameter.name.slowToString());
+    });
+    generateThrowNoSuchMethod(diagnosticNode,
+                              function.name.slowToString(),
+                              argumentNodes: argumentNodes,
+                              existingArguments: existingArguments);
   }
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
@@ skipping 1415 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;
   }
 }