Change signature of noSuchMethod to take an InvocationMirror.

lib/core/errors.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.
 
 class Error {
   const Error();
 }
 
 class AssertionError implements Error {
 }
@@ skipping 47 matching lines @@
   String toString() => "Cannot instantiate abstract class: '$_className'";
 }
 
 /**
  * Error thrown by the default implementation of [:noSuchMethod:] on [Object].
  */
 class NoSuchMethodError implements Error {
   final Object _receiver;
   final String _functionName;
   final List _arguments;
+  final Map<String,Dynamic> _namedArguments;

[floitsch, 2012/10/23 13:04:35]

String, Dynamic (space)

[regis, 2012/10/25 02:27:56]

dynamic is now lower case.

[Lasse Reichstein Nielsen, 2012/10/25 06:17:35]

I actually have come to prefer it without spaces. I'll argue at length about
that offline :)

   final List _existingArgumentNames;
 
   /**
    * Create a [NoSuchMethodError] corresponding to a failed method call.
    *
    * The first parameter is the receiver of the method call.

[regis, 2012/10/25 02:27:56]

What is the value of the first parameter when a NoSuchMethodError is thrown
after an invoked static function is not found? Is it null?

What about the case when a constructor is not found? Do you pass the allocated
but uninitialized object as 'this'?

Related question, can you forward a constructor call via noSuchMethod using the
InvocationMirror? In other words, do you keep the implicit arguments? 

Same questions for factories.

Invoking a method on null results in a NullPointerException, a subclass of
NoSuchMethodError. Do you declare NullPointerException elsewhere?

For a NoSuchMethodError resulting from a non-closure object being called, I
suppose that the value of functionName will be "call" and the value of 'this'
will be the non-closure object. Should this be documented here?

For a NoSuchMethodError resulting from a closure object being called with
incompatible arguments, I suppose that the value of functionName will be "call"
and the value of 'this' will be the closure object. The arguments will be set
accordingly to the explicit arguments, but what about the hidden context? This
question relates more to the noSuchMethod itself. In other words, can you
forward a closure call via noSuchMethod?

[Lasse Reichstein Nielsen, 2012/10/25 06:17:35]

Goooood question. Spec is silent on this.
For consistency, I'd suggest treating the global scope (for top-level
functions), or the class (for static methods) as a pseudo-object, and use the
name that was attempted called as the name in the NoSuchMethodError.
For the 'this' value, I'd use null for the top-level 'object' and the Type of
the class as the class 'object'. The need for the Type object is statically
deducible, so it shouldn't force dart2js to include runtime-types unnecessarily.
If the constructor is not found, there should be no uninitialized object (you
don't know if the missing constructor is generative or a factory). Even if there
was, an uninitialized object should never be revealed.
You can't get an InvocationMirror for static calls or constructor calls, since
there is no object with a noSuchMethod method to catch it. They always throw.
It's deliberate that the NoSuchMethodError does not contain an InvocationMirror
- you only need an InvocationMirror for user-defined noSuchMethod methods.
Same answer, they are essentially static.
I suggest removing/stop using NullPointerException and just throwing a
NoSuchMethodError for calls on null as well. The spec allows it, and it's
simpler than worrying about null.
NullPointerException is defined in the core library, but isn't currently a
subclass of NoSuchMethodError (which the spec requires).

 
It could be, for documentation. It's a consequence of how the spec is written
that foo() is equivalent to foo.call().
Which hidden context?
The InvocationMirror does not contain the 'this' value of the call, just the
name and argument values, so there is no context in there at all. 
The noSuchMethod has a this that is the object for method calls and the closure
for closure calls (where the method is implicitly "call" on the closure).

It is interesting that for obj of class X{bar(int x){} noSuchMethod(x){}}:
 obj.bar(2,3)  will trigger obj's noSuchMethod with a mirri with name 'bar' and
positional arguments [2,3], but
 (obj.bar)(2,3)  will trigger obj.bar (the closure)'s noSuchMethod inherited
from Object and throw a NoSuchMethodError with name 'call'. It's really same as
obj.bar.call(2,3).

I'll forward that to Gilad and see if it's acceptable :)

[regis, 2012/10/25 17:47:16]

That sounds reasonable. By 'this' value, you probably mean the first element of
the _arguments list and not _receiver? And by 'object', you actually mean
_receiver? Otherwise I do not understand your reply. Sorry, my question was not
very clear either.

I do not see the need to insert a null as 'this' as the first element of
_arguments. _arguments should match what was passed to the static call.

So, to be clear, in the case of a static call error, _receiver should be the
type of the class owning the static function, or null if the static function is
top level or not resolved. The _arguments should not be tempered with. 

The comment on line 74 could be made clearer:
The first parameter is the receiver of the method call or the first argument of
the static call.
Agreed. In other words, implicit arguments should be removed from _arguments.
It would be awesome to remove NullPointerException. Hopefully Gilad has no issue
with it.
The context is part of the closure object itself. That answers my dumb question.

Thinking about it some more, I realize that it is not possible to forward a
closure call via noSuchMethod, since it is not possible for the user to add a
noSuchMethod to a closure class, which is generated by the compiler. Never mind.
That makes sense.

    * The second parameter is the name of the called method.
    * The third parameter is the positional arguments that the method was
    * called with.
    * The optional [exisitingArgumentNames] is the expected parameters of a
    * method with the same name on the receiver, if available. This is
    * the method that would have been called if the parameters had matched.
    *
    * TODO(lrn): This will be rewritten to use mirrors when they are available.
    */
   const NoSuchMethodError(Object this._receiver,
                           String this._functionName,
                           List this._arguments,
+                          Map<String,Dynamic> this._namedArguments,

[floitsch, 2012/10/23 13:04:35]

no need to type. the type comes from the field.

[Lasse Reichstein Nielsen, 2012/10/25 06:17:35]

True. And dynamic is lower-case now.

                           [List existingArgumentNames = null])
       : this._existingArgumentNames = existingArgumentNames;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
-    for (int i = 0; i < _arguments.length; i++) {
-      if (i > 0) {
-        sb.add(", ");
+    int i = 0;
+    if (_arguments != null) {
+      for (; i < _arguments.length; i++) {
+        if (i > 0) {
+          sb.add(", ");
+        }
+        sb.add(safeToString(_arguments[i]));
       }
-      sb.add(safeToString(_arguments[i]));
+    }
+    if (_namedArguments != null) {
+      _namedArguments.forEach((String key, var value) {
+        if (i > 0) {
+          sb.add(", ");
+        }
+        sb.add(key);
+        sb.add(": ");
+        sb.add(safeToString(value));
+        i++;
+      });
     }
     if (_existingArgumentNames === null) {
       return "NoSuchMethodError : method not found: '$_functionName'\n"
           "Receiver: ${safeToString(_receiver)}\n"
           "Arguments: [$sb]";
     } else {
       String actualParameters = sb.toString();
       sb = new StringBuffer();
       for (int i = 0; i < _existingArgumentNames.length; i++) {
         if (i > 0) {
@@ skipping 33 matching lines @@
 
 class OutOfMemoryError implements Error {
   const OutOfMemoryError();
   String toString() => "Out of Memory";
 }
 
 class StackOverflowError implements Error {
   const StackOverflowError();
   String toString() => "Stack Overflow";
 }