Change the field and constructor parameter types of NoSuchMethodError to Symbol.

sdk/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.
 
 part of dart.core;
 
 class Error {
   /**
    * Safely convert a value to a [String] description.
    *
@@ skipping 136 matching lines @@
   FallThroughError();
 }
 
 
 class AbstractClassInstantiationError extends Error {
   final String _className;
   AbstractClassInstantiationError(String this._className);
   String toString() => "Cannot instantiate abstract class: '$_className'";
 }
 
+
 /**
  * Error thrown by the default implementation of [:noSuchMethod:] on [Object].
  */
 class NoSuchMethodError extends Error {
   final Object _receiver;
-  final String _memberName;
+  final Symbol _memberName;
   final List _arguments;
-  final Map<String,dynamic> _namedArguments;
+  final Map<Symbol, dynamic> _namedArguments;
   final List _existingArgumentNames;
 
   /**
    * Create a [NoSuchMethodError] corresponding to a failed method call.
    *
-   * The first parameter to this constructor is the receiver of the method call.
+   * The [receiver] is the receiver of the method call.
    * That is, the object on which the method was attempted called.
-   * The second parameter is the name of the called method or accessor.
-   * The third parameter is a list of the positional arguments that the method
-   * was called with.
-   * The fourth parameter is a map from [String] names to the values of named
+   * If this is `null`, it is interpreted as a call to a top-level function
+   * of a library.
+   *
+   * The [memberNamed] is a [Symbol] representing the name of the called method
+   * or accessor. It should not be `null`.
+   *
+   * The [positionalArguments] is a list of the positional arguments that the
+   * method was called with. If `null`, it is considered equivalent to the
+   * empty list.
+   *
+   * The [namedArguments] is a map from [Symbol]s to the values of named
    * 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.
+   * the signature of the method that would have been called if the parameters
+   * had matched.
    */
-  NoSuchMethodError(Object this._receiver,
-                    String this._memberName,
-                    List this._arguments,
-                    Map<String,dynamic> this._namedArguments,
+  NoSuchMethodError(Object receiver,

[ahe, 2013/08/30 06:46:35]

FWIW, this constructor is somewhat useless for dart2js, and so are the private
fields.

We need to implement the interface of this class, but that should cause type
warnings as we cannot implement the private fields.

[Lasse Reichstein Nielsen, 2013/08/30 14:06:02]

I agree that this is an odd signature for a class that may need different
implementations.

We should probably switch this to be an abstract class with an external
constructor.
If we need the constructor at all - it's only here because the specification
uses it to specify what is thrown in no-such-method cases. It could equally well
specify that "some error is thrown", and let each implementation handle it the
best way it can.

We can still do that, and keep an abstract interface and a default
user-accessible implementation.

+                    Symbol memberName,
+                    List positionalArguments,
+                    Map<Symbol ,dynamic> namedArguments,
                     [List existingArgumentNames = null])
-      : this._existingArgumentNames = existingArgumentNames;
+      : _receiver = receiver,

[ahe, 2013/08/30 06:46:35]

Why not use "this" parameters?

[Lasse Reichstein Nielsen, 2013/08/30 14:06:02]

This is a public constructor, so that would make the documented name of a
"this._memberName" parameter the private name "_memberName".
For documentation, I prefer to use public names for parameters of public
functions and constructors, and only use "this.foo" if the foo field itself is
also public.

+        _memberName = memberName,
+        _arguments = positionalArguments,
+        _namedArguments = namedArguments,
+        _existingArgumentNames = existingArgumentNames;
 
   external String toString();
 }
 
 
 /**
  * The operation was not allowed by the object.
  *
  * This [Error] is thrown when an instance cannot implement one of the methods
  * in its signature.
@@ skipping 82 matching lines @@
  * the first time it is read. If evaluating the initializer expression causes
  * another read of the variable, this error is thrown.
  */
 class CyclicInitializationError extends Error {
   final String variableName;
   CyclicInitializationError([this.variableName]);
   String toString() => variableName == null
       ? "Reading static variable during its initialization"
       : "Reading static variable '$variableName' during its initialization";
 }