Mirrors memory usage tweaks.

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.
 
 import "dart:collection" show UnmodifiableListView, UnmodifiableMapView;
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new UnmodifiableMapView({});
 
 class _InternalMirrorError {
   final String _msg;
   const _InternalMirrorError(String this._msg);
   String toString() => _msg;
 }
 
-Map _makeMemberMap(List mirrors) {
-  return new UnmodifiableMapView<Symbol, DeclarationMirror>(
-      new Map<Symbol, DeclarationMirror>.fromIterable(
-          mirrors, key: (e) => e.simpleName));
-}
-
 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 581 matching lines @@
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
   DeclarationMirror get owner {
     if (_owner == null) {
-      _owner = _library(_reflectee);
+      var uri = _LocalClassMirror._libraryUri(_reflectee);
+      _owner = currentMirrorSystem().libraries[Uri.parse(uri)];
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
-  final bool isTopLevel = true;
+  bool get isTopLevel => true;
 
   SourceLocation get location {
     return _location(_reflectee);
   }
 
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
       Type supertype = isOriginalDeclaration
           ? _supertype(_reflectedType)
@@ skipping 107 matching lines @@
       });
       _cachedInstanceMembers =
           new UnmodifiableMapView<Symbol, MethodMirror>(result);
     }
     return _cachedInstanceMembers;
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
+
     var decls = new Map<Symbol, DeclarationMirror>();
-    decls.addAll(_members);
-    decls.addAll(_constructors);
-    typeVariables.forEach((tv) => decls[tv.simpleName] = tv);
+
+    var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
+    var members = mixin._computeMembers(_instantiator,
+                                        whoseMembers.mixin._reflectee);
+    for (var member in members) {
+      decls[member.simpleName] = member;
+    }
+
+    var constructors = _computeConstructors(_instantiator, _reflectee);
+    var stringName = _n(simpleName);
+    for (var constructor in constructors) {
+      constructor._patchConstructorName(stringName);
+      decls[constructor.simpleName] = constructor;
+    }
+
+    for (var typeVariable in typeVariables) {
+      decls[typeVariable.simpleName] = typeVariable;
+    }
+
     return _declarations =
         new UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
 
-  Map<Symbol, Mirror> _cachedMembers;
-  Map<Symbol, Mirror> get _members {
-    if (_cachedMembers == null) {
-      var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
-      _cachedMembers = _makeMemberMap(mixin._computeMembers(
-          _instantiator, whoseMembers.mixin._reflectee));
-    }
-    return _cachedMembers;
-  }
-
-  Map<Symbol, MethodMirror> _cachedConstructors;
-  Map<Symbol, MethodMirror> get _constructors {
-    if (_cachedConstructors == null) {
-      var constructorsList = _computeConstructors(_instantiator, _reflectee);
-      var stringName = _n(simpleName);
-      constructorsList.forEach((c) => c._patchConstructorName(stringName));
-      _cachedConstructors =
-          new Map.fromIterable(constructorsList, key: (e) => e.simpleName);
-    }
-    return _cachedConstructors;
-  }
-
   bool get _isAnonymousMixinApplication {
     if (_isMixinAlias) return false;  // Named mixin application.
     if (mixin == this) return false;  // Not a mixin application.
     return true;
   }
 
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
     if (_typeVariables == null) {
       if (_isAnonymousMixinApplication) return _typeVariables = emptyList;
@@ skipping 97 matching lines @@
     ClassMirror otherDeclaration = other.originalDeclaration;
     ClassMirror c = this;
     while (c != null) {
       c = c.originalDeclaration;
       if (c == otherDeclaration) return true;
       c = c.superclass;
     }
     return false;
   }
 
-  static _library(reflectee)
-      native "ClassMirror_library";
+  static _libraryUri(reflectee)
+      native "ClassMirror_libraryUri";
 
   static _supertype(reflectedType)
       native "ClassMirror_supertype";
 
   static _supertypeInstantiated(reflectedType)
       native "ClassMirror_supertype_instantiated";
 
   static _nativeInterfaces(reflectedType)
       native "ClassMirror_interfaces";
 
@@ skipping 208 matching lines @@
                       this._isGeneric,
                       this._isGenericDeclaration,
                       this._owner)
       : super(reflectee, _s(simpleName));
 
   bool get isTopLevel => true;
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
-      _owner = _LocalClassMirror._library(_reflectee);
+      var uri = _LocalClassMirror._libraryUri(_reflectee);
+      _owner = currentMirrorSystem().libraries[Uri.parse(uri)];
     }
     return _owner;
   }
 
   TypeMirror _referent = null;
   TypeMirror get referent {
     if (_referent == null) {
       _referent = _nativeReferent(_reflectedType);
       _referent._instantiator = _reflectedType;
     }
@@ skipping 92 matching lines @@
   DeclarationMirror get owner => null;
 
   bool get isPrivate => false;
   bool get isTopLevel => false;
 
   Type get _instantiator => null;
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
+
+    var decls = new Map<Symbol, DeclarationMirror>();
+    var members = _computeMembers(_reflectee);
+    for (var member in members) {
+      decls[member.simpleName] = member;
+    }
+
     return _declarations =
-        new UnmodifiableMapView<Symbol, DeclarationMirror>(_members);
-  }
-
-  Map<Symbol, Mirror> _cachedMembers;
-  Map<Symbol, Mirror> get _members {
-    if (_cachedMembers == null) {
-      _cachedMembers = _makeMemberMap(_computeMembers(_reflectee));
-    }
-    return _cachedMembers;
+        new UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
 
   SourceLocation get location {
     return _location(_reflectee);
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
@@ skipping 62 matching lines @@
   _LocalCombinatorMirror(identifierString, this.isShow)
       : this.identifiers = [_s(identifierString)];
 
   bool get isHide => !isShow;
 }
 
 class _LocalMethodMirror extends _LocalDeclarationMirror
     implements MethodMirror {
   final Type _instantiator;
   final bool isStatic;
-  final bool isAbstract;
-  final bool isGetter;
-  final bool isSetter;
-  final bool isConstructor;
-  final bool isConstConstructor;
-  final bool isGenerativeConstructor;
-  final bool isRedirectingConstructor;
-  final bool isFactoryConstructor;
-  final bool isOperator;
-
-  static const _operators = const ["%", "&", "*", "+", "-", "/", "<", "<<",
-      "<=", "==", ">", ">=", ">>", "[]", "[]=", "^", "|", "~", "unary-", "~/"];
+  final int _kindFlags;
 
   _LocalMethodMirror(reflectee,
                      String simpleName,
                      this._owner,
                      this._instantiator,
                      this.isStatic,
-                     this.isAbstract,
-                     this.isGetter,
-                     this.isSetter,
-                     this.isConstructor,
-                     this.isConstConstructor,
-                     this.isGenerativeConstructor,
-                     this.isRedirectingConstructor,
-                     this.isFactoryConstructor)
-      : this.isOperator = _operators.contains(simpleName),
-        super(reflectee, _s(simpleName));
+                     this._kindFlags)
+      : super(reflectee, _s(simpleName));
+
+  static const kAbstract = 0;
+  static const kGetter = 1;
+  static const kSetter = 2;
+  static const kConstructor = 3;
+  static const kConstCtor = 4;
+  static const kGenerativeCtor = 5;
+  static const kRedirectingCtor = 6;
+  static const kFactoryCtor = 7;
+
+  // These offsets much be kept in sync with those in mirrors.h.
+  bool get isAbstract =>               0 != (_kindFlags & (1 << kAbstract));
+  bool get isGetter =>                 0 != (_kindFlags & (1 << kGetter));
+  bool get isSetter =>                 0 != (_kindFlags & (1 << kSetter));
+  bool get isConstructor =>            0 != (_kindFlags & (1 << kConstructor));
+  bool get isConstConstructor =>       0 != (_kindFlags & (1 << kConstCtor));
+  bool get isGenerativeConstructor =>  0 != (_kindFlags & (1 << kGenerativeCtor));
+  bool get isRedirectingConstructor => 0 != (_kindFlags & (1 << kRedirectingCtor));
+  bool get isFactoryConstructor =>     0 != (_kindFlags & (1 << kFactoryCtor));
+
+  static const _operators = const ["%", "&", "*", "+", "-", "/", "<", "<<",
+      "<=", "==", ">", ">=", ">>", "[]", "[]=", "^", "|", "~", "unary-", "~/"];
+  bool get isOperator => _operators.contains(_n(simpleName));
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     // For nested closures it is possible, that the mirror for the owner has not
     // been created yet.
     if (_owner == null) {
       _owner = _MethodMirror_owner(_reflectee, _instantiator);
     }
     return _owner;
   }
@@ skipping 43 matching lines @@
           LibraryMirror definingLibrary = owner.owner;
           _constructorName = MirrorSystem.getSymbol(parts[1], definingLibrary);
         } else {
           _constructorName = _s('');
         }
       }
     }
     return _constructorName;
   }
 
-  String _source = null;
-  String get source {
-    if (_source == null) {
-      _source = _MethodMirror_source(_reflectee);
-    }
-    return _source;
-  }
+  String get source => _MethodMirror_source(_reflectee);
 
   void _patchConstructorName(ownerName) {
     var cn = _n(constructorName);
-    if(cn == ''){
+    if (cn == '') {
       _simpleName = _s(ownerName);
     } else {
       _simpleName = _s(ownerName + "." + cn);
     }
   }
 
   String toString() => "MethodMirror on '${MirrorSystem.getName(simpleName)}'";
 
   static dynamic _MethodMirror_owner(reflectee, instantiator)
       native "MethodMirror_owner";
@@ skipping 208 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }