Make ClassMirror.constructors 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 383 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> constructors,
                         Map<String, Mirror> typeVariables)
       : this._simpleName = _s(simpleName),
-        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 110 matching lines @@
 
   Map<Symbol, VariableMirror> get variables {
     if (_variables == null) {
       _variables = _filterMap(
           members,
           (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
-  Map<Symbol, MethodMirror> constructors;
+  Map<Symbol, MethodMirror> _constructors;
+
+  Map<Symbol, MethodMirror> get constructors {
+    if (_constructors == null) {
+      _constructors = _makeMemberMap(_computeConstructors(_reflectee));
+    }
+    return _constructors;
+  }
+
   Map<Symbol, TypeVariableMirror> typeVariables;
 
   Map<Symbol, TypeMirror> get typeArguments {
     throw new UnimplementedError(
         'ClassMirror.typeArguments is not implemented');
   }
 
   bool get isOriginalDeclaration {
     throw new UnimplementedError(
         'ClassMirror.isOriginalDeclaration is not implemented');
@@ skipping 49 matching lines @@
       native "ClassMirror_name";
 
   static _library(reflectee)
       native "ClassMirror_library";
 
   static _supertype(reflectee)
       native "ClassMirror_supertype";
 
   _computeMembers(reflectee)
       native "ClassMirror_members";
+  
+  _computeConstructors(reflectee)
+      native "ClassMirror_constructors";
 
   _invoke(reflectee, memberName, positionalArguments)
       native 'ClassMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'ClassMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'ClassMirror_invokeSetter';
 
@@ skipping 19 matching lines @@
                                simpleName,
                                this._returnType,
                                this.parameters)
       : super(reflectee,
               simpleName,
               true,
               null,
               new _LazyTypeMirror('dart:core', 'Object'),
               [ new _LazyTypeMirror('dart:core', 'Function') ],
               null,
-              const {},
               const {});
 
   Map<Symbol, Mirror> get members => new Map<Symbol,Mirror>();
+  Map<Symbol, MethodMirror> get constructors => new Map<Symbol,MethodMirror>();
 
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
     return _returnType;
   }
 
   final List<ParameterMirror> parameters;
@@ skipping 563 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;
   }
 }