Make LibraryMirror.members an internal native and lazy.

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 775 matching lines @@
     return mirrors.libraries[Uri.parse(libraryUrl)];
   }
 
   final String libraryUrl;
 }
 
 class _LocalLibraryMirrorImpl extends _LocalObjectMirrorImpl
     implements LibraryMirror {
   _LocalLibraryMirrorImpl(reflectee,
                           String simpleName,
-                          String url,
-                          Map<String, Mirror> members)
+                          String url)
       : this.simpleName = _s(simpleName),
-        this.members = _convertStringToSymbolMap(members),
         this.uri = Uri.parse(url),
         super(reflectee);
 
   final Symbol simpleName;
 
   // The simple name and the qualified name are the same for a library.
   Symbol get qualifiedName => simpleName;
 
   // Always null for libraries.
   final DeclarationMirror owner = null;
 
   // Always false for libraries.
   final bool isPrivate = false;
 
   // Always false for libraries.
   final bool isTopLevel = false;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'LibraryMirror.location is not implemented');
   }
 
   final Uri uri;
-  final Map<Symbol, Mirror> members;
+
+  Map<Symbol, Mirror> _members;
+
+  Map<Symbol, Mirror> get members {
+    if (_members == null) {
+      _members = _makeMemberMap(_computeMembers(_reflectee));
+    }
+    return _members;

[ahe, 2013/07/25 08:27:19]

You need to return something that is immutable.

_makeMemberMap creates a mutable map.

But don't sweat it, we're planning to use lists instead of maps.  It is easier
to create an immutable list.

[rmacnak, 2013/07/25 16:31:09]

Yeah, we're holding the status quo here.

+  }
 
   Map<Symbol, ClassMirror> _classes = null;
   Map<Symbol, MethodMirror> _functions = null;
   Map<Symbol, MethodMirror> _getters = null;
   Map<Symbol, MethodMirror> _setters = null;
   Map<Symbol, VariableMirror> _variables = null;
 
   Map<Symbol, ClassMirror> get classes {
     if (_classes == null) {
       _classes = _filterMap(members,
@@ skipping 43 matching lines @@
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'LibraryMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'LibraryMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
+
+  _computeMembers(reflectee)
+      native "LibraryMirror_members";
 }
 
 class _LocalMethodMirrorImpl extends _LocalDeclarationMirrorImpl
     implements MethodMirror {
   _LocalMethodMirrorImpl(reflectee,
                          this._owner,
                          this.parameters,
                          this.isStatic,
                          this.isAbstract,
                          this.isGetter,
@@ skipping 296 matching lines @@
   static Expando<ClassMirror> _classMirrorCache = new Expando("ClassMirror");
   static ClassMirror reflectClass(Type key) {
     var classMirror = _classMirrorCache[key];
     if (classMirror == null) {
       classMirror = makeLocalClassMirror(key);
       _classMirrorCache[key] = classMirror;
     }
     return classMirror;
   }
 }