Make ClassMirror.members 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);
 }
 
 Map _filterMap(Map<Symbol, dynamic> old_map, bool filter(Symbol key, value)) {
   Map new_map = new Map<Symbol, dynamic>();
   old_map.forEach((key, value) {
     if (filter(key, value)) {
       new_map[key] = value;
     }
   });
   return new_map;
 }
 
+Map _makeMemberMap(List mirrors) {
+  Map<Symbol, dynamic> result = new Map();

[ahe, 2013/07/24 10:11:54]

I think it is more important to have the type on the right-hand side. This type
is reified and used in checked mode.

+  mirrors.forEach((mirror) => result[mirror.simpleName] = mirror);
+  return result;
+}
+
 String _n(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 Symbol _s(String name) {
   if (name == null) return null;
   return new _symbol_dev.Symbol.unvalidated(name);
 }
 
 Symbol _computeQualifiedName(DeclarationMirror owner, Symbol simpleName) {
   if (owner == null) return simpleName;
   return _s('${_n(owner.qualifiedName)}.${_n(simpleName)}');
@@ skipping 355 matching lines @@
 
 class _LocalClassMirrorImpl extends _LocalObjectMirrorImpl
     implements ClassMirror {
   _LocalClassMirrorImpl(reflectee,
                         String simpleName,
                         this.isClass,
                         this._owner,
                         this._superclass,
                         this._superinterfaces,
                         this._defaultFactory,
-                        Map<String, Mirror> members,
                         Map<String, Mirror> constructors,
                         Map<String, Mirror> typeVariables)
       : this._simpleName = _s(simpleName),
-        this.members = _convertStringToSymbolMap(members),
         this.constructors = _convertStringToSymbolMap(constructors),
         this.typeVariables = _convertStringToSymbolMap(typeVariables),
         super(reflectee);
 
   Symbol _simpleName;
   Symbol get simpleName {
     // dynamic, void and the function types have their names set eagerly in the
     // constructor.
     if(_simpleName == null) {
       _simpleName = _s(_name(_reflectee));
@@ skipping 53 matching lines @@
   }
 
   var _defaultFactory;
   ClassMirror get defaultFactory {
     if (_defaultFactory != null && _defaultFactory is! Mirror) {
       _defaultFactory = _defaultFactory.resolve(mirrors);
     }
     return _defaultFactory;
   }
 
-  final Map<Symbol, Mirror> members;
+  Map<Symbol, Mirror> _members;
+
+  Map<Symbol, Mirror> get members {
+    if (_members == null) {
+      _members = _makeMemberMap(_computeMembers(_reflectee));
+    }
+    return _members;
+  }
 
   Map<Symbol, MethodMirror> _methods = null;
   Map<Symbol, MethodMirror> _getters = null;
   Map<Symbol, MethodMirror> _setters = null;
   Map<Symbol, VariableMirror> _variables = null;
 
   Map<Symbol, MethodMirror> get methods {
     if (_methods == null) {
       _methods = _filterMap(
           members,
@@ skipping 87 matching lines @@
     // reflect() and then make them into a Dart list.
     return _metadata(_reflectee).map(reflect).toList(growable:false);
   }
 
   static _name(reflectee)
       native "ClassMirror_name";
 
   static _library(reflectee)
       native "ClassMirror_library";
 
+  _computeMembers(reflectee)
+      native "ClassMirror_members";
+
   _invoke(reflectee, memberName, positionalArguments)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
   static _invokeConstructor(reflectee, constructorName, positionalArguments)
@@ skipping 19 matching lines @@
                                this._returnType,
                                this.parameters)
       : super(reflectee,
               simpleName,
               true,
               null,
               new _LazyTypeMirror('dart:core', 'Object'),
               [ new _LazyTypeMirror('dart:core', 'Function') ],
               null,
               const {},
-              const {},
               const {});
 
+  Map<Symbol, Mirror> get members => const {};

[ahe, 2013/07/24 10:11:54]

Add type arguments.

+
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
     return _returnType;
   }
 
   final List<ParameterMirror> parameters;
 
@@ skipping 543 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;
   }
 }