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;
+  // TODO(ahe): [libraries] should be Map<Uri, LibraryMirror>.
+  Map<Symbol, LibraryMirror> get libraries;
 
   /**
    * 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.
    */
   TypeMirror get dynamicType;
 
   /**
    * A mirror on the [:void:] type.
    */
   TypeMirror get voidType;
+
+  external static String getName(Symbol symbol);
 }
 
 /**
  * Returns a [MirrorSystem] for the current isolate.
  */
 external MirrorSystem currentMirrorSystem();
 
 /**
  * Creates a [MirrorSystem] for the isolate which is listening on
  * the [SendPort].
@@ skipping 44 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 25 matching lines @@
  * For the purposes of the mirrors library, these types are all
  * object-like, in that they support method invocation and field
  * access.  Real Dart objects are represented by the [InstanceMirror]
  * type.
  *
  * See [InstanceMirror], [ClassMirror], and [LibraryMirror].
  */
 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].
+   * 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]);
 
   /**
    * 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].
+   * 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 37 matching lines @@
 
   /**
    * The source code for this closure, if available.  Otherwise null.
    *
    * 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]. 
+   * 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?
    */
+  // TODO(ahe): Change type to [Uri], rename to "uri"?
   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
+ * A [TypeMirror] reflects a Dart language class, typedef,
  * or type variable.
  */
 abstract class TypeMirror implements DeclarationMirror {
 }
 
 /**
  * A [ClassMirror] reflects a Dart language class.
  */
 abstract class ClassMirror implements TypeMirror, ObjectMirror {
   /**
@@ skipping 12 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], 
+   * The arguments must be instances of [InstanceMirror], [num],
+   * [String], or [bool].
    */
   /* 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);
 }