Update dart:mirrors to use Symbol.

dart/sdk/lib/mirrors/mirrors.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.
 
 // For the purposes of the mirrors library, we adopt a naming
 // convention with respect to getters and setters.  Specifically, for
 // some variable or field...
 //
 //   var myField;
 //
@@ skipping 16 matching lines @@
  * of libraries which are not running -- perhaps at compile-time.  In
  * this case, all available reflective functionality would be
  * supported, but runtime functionality (such as invoking a function
  * or inspecting the contents of a variable) would fail dynamically.
  */
 abstract class MirrorSystem {
   /**
    * An immutable map from from library names to mirrors for all
    * libraries known to this mirror system.
    */
-  Map<String, LibraryMirror> get libraries;
+  Map<Symbol, LibraryMirror> get libraries;

[gbracha, 2013/04/11 18:12:20]

So, didn't we just change this to be a map of URIs to library mirrors? After
discussing with Ivan, I am satisfied that this will work.

[ahe, 2013/04/11 20:12:27]

The CL from Johnni was to modify the copy of this API that dartdoc uses.  Johnni
has not yet been able to consolidate the two (I'm not sure what remains).

I think I have a way to modify the the Dart code so this returns a Map<Uri,
LibraryMirror>.  Let me know if you want me to address that.

Also, I have added a TODO regarding LibraryMirror.url.  I think the type should
be Uri, and it should be renamed to LibraryMirror.uri (that is an i (eye)
instead of an l (ell)).

 
   /**
    * A mirror on the isolate associated with this [MirrorSystem].
    * This may be null if this mirror system is not running.
    */
   IsolateMirror get isolate;
 
   /**
    * A mirror on the [:dynamic:] type.
    */
@@ skipping 60 matching lines @@
  * A [DeclarationMirror] reflects some entity declared in a Dart program.
  */
 abstract class DeclarationMirror implements Mirror {
   /**
    * The simple name for this Dart language entity.
    *
    * The simple name is in most cases the the identifier name of the
    * entity, such as 'method' for a method [:void method() {...}:] or
    * 'mylibrary' for a [:#library('mylibrary');:] declaration.
    */
-  String get simpleName;
+  Symbol get simpleName;
 
   /**
    * The fully-qualified name for this Dart language entity.
    *
    * This name is qualified by the name of the owner. For instance,
    * the qualified name of a method 'method' in class 'Class' in
    * library 'library' is 'library.Class.method'.
    *
    * TODO(turnidge): Specify whether this name is unique.  Currently
    * this is a gray area due to lack of clarity over whether library
    * names are unique.
    */
-  String get qualifiedName;
+  Symbol get qualifiedName;
 
   /**
    * A mirror on the owner of this function.  This is the declaration
    * immediately surrounding the reflectee.
    *
    * Note that for libraries, the owner will be [:null:].
    */
   DeclarationMirror get owner;
 
   /**
@@ skipping 32 matching lines @@
 abstract class ObjectMirror implements Mirror {
   /**
    * Invokes the named function and returns a mirror on the result.
    * The arguments must be instances of [InstanceMirror], [num], 
    * [String] or [bool].
    */
   /* TODO(turnidge): Properly document.
    * TODO(turnidge): Handle ambiguous names.
    * TODO(turnidge): Handle optional & named arguments.
    */
-  Future<InstanceMirror> invokeAsync(String memberName,
+  Future<InstanceMirror> invokeAsync(Symbol memberName,
                                      List<Object> positionalArguments,
-                                     [Map<String,Object> namedArguments]);
+                                     [Map<Symbol,Object> namedArguments]);

[gbracha, 2013/04/11 18:12:20]

Just an observation: this is an excellent example of how the use of Symbol
without language support makes the API hard to use. Until now, you could use a
literal map as an argument, but since our literal maps only work with string
keys, that is no longer possible.

[ahe, 2013/04/11 20:12:27]

I agree.  I had the same issue when updating Function.apply.  Fortunately, there
only seems to be two tests that use Function.apply.

Kasper and Lars has promised me that they'll bring up revising the map literal
syntax to allow more general expressions as keys on the next language meeting.

 
   /**
    * Invokes a getter and returns a mirror on the result. The getter
    * can be the implicit getter for a field or a user-defined getter
    * method.
    */
   /* TODO(turnidge): Handle ambiguous names.*/
-  Future<InstanceMirror> getFieldAsync(String fieldName);
+  Future<InstanceMirror> getFieldAsync(Symbol fieldName);
 
   /**
    * Invokes a setter and returns a mirror on the result. The setter
    * may be either the implicit setter for a non-final field or a
    * user-defined setter method.
    * The argument must be an instance of either [InstanceMirror], [num], 
    * [String] or [bool].
    */
   /* TODO(turnidge): Handle ambiguous names.*/
-  Future<InstanceMirror> setFieldAsync(String fieldName, Object value);
+  Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value);
 }
 
 /**
  * An [InstanceMirror] reflects an instance of a Dart language object.
  */
 abstract class InstanceMirror implements ObjectMirror {
   /**
    * A mirror on the type of the reflectee.
    */
   ClassMirror get type;
@@ skipping 41 matching lines @@
    * TODO(turnidge): Would this just be available in function?
    */
   String get source;
 
   /**
    * Executes the closure.
    * The arguments must be instances of [InstanceMirror], [num], 
    * [String] or [bool]. 
    */
   Future<InstanceMirror> applyAsync(List<Object> positionalArguments,
-                                    [Map<String,Object> namedArguments]);
+                                    [Map<Symbol,Object> namedArguments]);
 
   /**
    * Looks up the value of a name in the scope of the closure. The
    * result is a mirror on that value.
    */
-  Future<InstanceMirror> findInContext(String name);
+  Future<InstanceMirror> findInContext(Symbol name);
 }
 
 /**
  * A [LibraryMirror] reflects a Dart language library, providing
  * access to the variables, functions, and classes of the
  * library.
  */
 abstract class LibraryMirror implements DeclarationMirror, ObjectMirror {
   /**
    * The url of the library.
    *
    * TODO(turnidge): Document where this url comes from.  Will this
    * value be sensible?
    */
   String get url;
 
   /**
    * An immutable map from from names to mirrors for all members in
    * this library.
    *
    * The members of a library are its top-level classes,
    * functions, variables, getters, and setters.
    */
-  Map<String, Mirror> get members;
+  Map<Symbol, Mirror> get members;
 
   /**
    * An immutable map from names to mirrors for all class
    * declarations in this library.
    */
-  Map<String, ClassMirror> get classes;
+  Map<Symbol, ClassMirror> get classes;
 
   /**
    * An immutable map from names to mirrors for all function, getter,
    * and setter declarations in this library.
    */
-  Map<String, MethodMirror> get functions;
+  Map<Symbol, MethodMirror> get functions;
 
   /**
    * An immutable map from names to mirrors for all getter
    * declarations in this library.
    */
-  Map<String, MethodMirror> get getters;
+  Map<Symbol, MethodMirror> get getters;
 
   /**
    * An immutable map from names to mirrors for all setter
    * declarations in this library.
    */
-  Map<String, MethodMirror> get setters;
+  Map<Symbol, MethodMirror> get setters;
 
   /**
    * An immutable map from names to mirrors for all variable
    * declarations in this library.
    */
-  Map<String, VariableMirror> get variables;
+  Map<Symbol, VariableMirror> get variables;
 }
 
 /**
  * A [TypeMirror] reflects a Dart language class, typedef
  * or type variable.
  */
 abstract class TypeMirror implements DeclarationMirror {
 }
 
 /**
@@ skipping 16 matching lines @@
   /**
    * An immutable map from from names to mirrors for all members of
    * this type.
    *
    * The members of a type are its methods, fields, getters, and
    * setters.  Note that constructors and type variables are not
    * considered to be members of a type.
    *
    * This does not include inherited members.
    */
-  Map<String, Mirror> get members;
+  Map<Symbol, Mirror> get members;
 
   /**
    * An immutable map from names to mirrors for all method,
    * declarations for this type.  This does not include getters and
    * setters.
    */
-  Map<String, MethodMirror> get methods;
+  Map<Symbol, MethodMirror> get methods;
 
   /**
    * An immutable map from names to mirrors for all getter
    * declarations for this type.
    */
-  Map<String, MethodMirror> get getters;
+  Map<Symbol, MethodMirror> get getters;
 
   /**
    * An immutable map from names to mirrors for all setter
    * declarations for this type.
    */
-  Map<String, MethodMirror> get setters;
+  Map<Symbol, MethodMirror> get setters;
 
   /**
    * An immutable map from names to mirrors for all variable
    * declarations for this type.
    */
-  Map<String, VariableMirror> get variables;
+  Map<Symbol, VariableMirror> get variables;
 
   /**
    * An immutable map from names to mirrors for all constructor
    * declarations for this type.
    */
-   Map<String, MethodMirror> get constructors;
+   Map<Symbol, MethodMirror> get constructors;
 
   /**
    * An immutable map from names to mirrors for all type variables for
    * this type.
    *
    * This map preserves the order of declaration of the type variables.
    */
-   Map<String, TypeVariableMirror> get typeVariables;
+   Map<Symbol, TypeVariableMirror> get typeVariables;
 
   /**
    * An immutable map from names to mirrors for all type arguments for
    * this type.
    *
    * This map preserves the order of declaration of the type variables.
    */
-  Map<String, TypeMirror> get typeArguments;
+  Map<Symbol, TypeMirror> get typeArguments;
 
   /**
    * Is this the original declaration of this type?
    *
    * For most classes, they are their own original declaration.  For
    * generic classes, however, there is a distinction between the
    * original class declaration, which has unbound type variables, and
    * the instantiations of generic classes, which have bound type
    * variables.
    */
   bool get isOriginalDeclaration;
 
   /**
    * A mirror on the original declaration of this type.
    *
    * For most classes, they are their own original declaration.  For
    * generic classes, however, there is a distinction between the
    * original class declaration, which has unbound type variables, and
    * the instantiations of generic classes, which have bound type
    * variables.
    */
   ClassMirror get originalDeclaration;
 
   /**
    * Invokes the named constructor and returns a mirror on the result.
    * The arguments must be instances of [InstanceMirror], [num], 
    */
   /* TODO(turnidge): Properly document.*/
-  Future<InstanceMirror> newInstanceAsync(String constructorName,
+  Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
                                           List<Object> positionalArguments,
-                                          [Map<String,Object> namedArguments]);
+                                          [Map<Symbol,Object> namedArguments]);
 
   /**
    * Does this mirror represent a class?
    *
    * TODO(turnidge): This functions goes away after the
    * class/interface changes.
    */
   bool get isClass;
 
   /**
@@ skipping 110 matching lines @@
 
   /**
    * The constructor name for named constructors and factory methods.
    *
    * For unnamed constructors, this is the empty string.  For
    * non-constructors, this is the empty string.
    *
    * For example, [:'bar':] is the constructor name for constructor
    * [:Foo.bar:] of type [:Foo:].
    */
-  String get constructorName;
+  Symbol get constructorName;
 
   /**
    * Is the reflectee a const constructor?
    */
   bool get isConstConstructor;
 
   /**
    * Is the reflectee a generative constructor?
    */
   bool get isGenerativeConstructor;
@@ skipping 51 matching lines @@
    */
   bool get isNamed;
 
   /**
    * Does this parameter have a default value?
    */
   bool get hasDefaultValue;
 
   /**
    * A mirror on the default value for this parameter, if it exists.
-   *
-   * TODO(turnidge): String may not be a good representation of this
-   * at runtime.
    */
+  // TODO(ahe): This should return an InstanceMirror.
   String get defaultValue;
 }
 
 /**
  * A [SourceLocation] describes the span of an entity in Dart source code.
  */
 abstract class SourceLocation {
 }
 
 /**
@@ skipping 98 matching lines @@
   /**
    * Is [:true:] if this comment is a documentation comment.
    *
    * That is, that the comment is either enclosed in [: /** ... */ :] or starts
    * with [: /// :].
    */
   final bool isDocComment;
 
   const Comment(this.text, this.trimmedText, this.isDocComment);
 }