Change libraries map to use Uri.

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
@@ skipping 44 matching lines @@
       buf.write(', ');
     }
   }
   if (found_optional_param) {
     buf.write(']');
   }
   buf.write(')');
   return buf.toString();
 }
 
-class _LocalMirrorSystemImpl implements MirrorSystem {
-  // TODO(ahe): [libraries] should be Map<Uri, LibraryMirror>.
+Map<Uri, LibraryMirror> _createLibrariesMap(Map<String, LibraryMirror> map) {
+    var result = new Map<Uri, LibraryMirror>();
+    map.forEach((String url, LibraryMirror mirror) {
+      result[Uri.parse(url)] = mirror;
+    });
+    return result;
+}
+
+class _LocalMirrorSystemImpl extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
   _LocalMirrorSystemImpl(Map<String, LibraryMirror> libraries, this.isolate)
-      : _functionTypes = new Map<String, FunctionTypeMirror>(),
-        this.libraries = _convertStringToSymbolMap(libraries);
+      : this.libraries = _createLibrariesMap(libraries),
+        _functionTypes = new Map<String, FunctionTypeMirror>();
 
-  final Map<Symbol, LibraryMirror> libraries;
+  final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
   TypeMirror _dynamicType = null;
 
   TypeMirror get dynamicType {
     if (_dynamicType == null) {
       _dynamicType =
           new _LocalClassMirrorImpl(
               null, 'dynamic', false, null, null, [], null,
               const {}, const {}, const {});
@@ skipping 311 matching lines @@
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
   static _apply(ref, positionalArguments, async)
       native 'LocalClosureMirrorImpl_apply';
 }
 
 class _LazyTypeMirror {
-  _LazyTypeMirror(String libraryName, String typeName)
-      : this.libraryName = _s(libraryName),
-        this.typeName = _s(typeName);
+  _LazyTypeMirror(String this.libraryUrl, String typeName)
+      : this.typeName = _s(typeName);
 
   TypeMirror resolve(MirrorSystem mirrors) {
-    if (libraryName == null) {
+    if (libraryUrl == null) {
       if (typeName == const Symbol('dynamic')) {
         return mirrors.dynamicType;
       } else if (typeName == const Symbol('void')) {
         return mirrors.voidType;
       } else {
         throw new UnimplementedError(
             "Mirror for type '$typeName' is not implemented");
       }
     }
-    var resolved = mirrors.libraries[libraryName].members[typeName];
+    var resolved = mirrors.libraries[Uri.parse(libraryUrl)].members[typeName];
     if (resolved == null) {
       throw new UnimplementedError(
           "Mirror for type '$typeName' is not implemented");
     }
     return resolved;
   }
 
-  final Symbol libraryName;
+  final String libraryUrl;
   final Symbol typeName;
 }
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(ref,
                         String simpleName,
                         this.isClass,
                         this._owner,
                         this._superclass,
@@ skipping 313 matching lines @@
       _referent = _referent.resolve(mirrors);
     }
     return _referent;
   }
 
   String toString() => "TypedefMirror on '$simpleName'";
 }
 
 
 class _LazyLibraryMirror {
-  _LazyLibraryMirror(String libraryName)
-      : this.libraryName = _s(libraryName);
+  _LazyLibraryMirror(String this.libraryUrl);
 
   LibraryMirror resolve(MirrorSystem mirrors) {
-    return mirrors.libraries[libraryName];
+    return mirrors.libraries[Uri.parse(libraryUrl)];
   }
 
-  final Symbol libraryName;
+  final String libraryUrl;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(ref,
                           String simpleName,
                           String url,
                           Map<String, Mirror> members)
       : this.simpleName = _s(simpleName),
         this.members = _convertStringToSymbolMap(members),
@@ skipping 288 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }