Move non-caching fields to the top of mirror classes.

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";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
 
-// Copied from js_mirrors, in turn copied from the package
-// "unmodifiable_collection".
 // TODO(14314): Move to dart:collection.
 class _UnmodifiableMapView<K, V> implements Map<K, V> {
-   Map<K, V> _source;
+  Map<K, V> _source;
+
   _UnmodifiableMapView(Map<K, V> source) : _source = source;
 
  static void _throw() {
     throw new UnsupportedError("Cannot modify an unmodifiable Map");
   }
 
   int get length => _source.length;
-
   bool get isEmpty => _source.isEmpty;
-
   bool get isNotEmpty => _source.isNotEmpty;
-
   V operator [](K key) => _source[key];
-
   bool containsKey(K key) => _source.containsKey(key);
-
   bool containsValue(V value) => _source.containsValue(value);
-
   void forEach(void f(K key, V value)) => _source.forEach(f);
-
   Iterable<K> get keys => _source.keys;
-
   Iterable<V> get values => _source.values;
-
   void operator []=(K key, V value) => _throw();
-
   V putIfAbsent(K key, V ifAbsent()) { _throw(); }
-
   void addAll(Map<K, V> other) => _throw();
-
   V remove(K key) { _throw(); }
-
   void clear() => _throw();
 }
 
 class _InternalMirrorError {
+  final String _msg;
   const _InternalMirrorError(String this._msg);
   String toString() => _msg;
-  final String _msg;
 }
 
 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 _UnmodifiableMapView(new_map);
@@ skipping 47 matching lines @@
   }
   if (found_optional_positional) {
     buf.write(']');
   }
   buf.write(') -> ');
   buf.write(_n(returnType.qualifiedName));
   return buf.toString();
 }
 
 List _metadata(reflectee)
-  native 'DeclarationMirror_metadata';
+    native 'DeclarationMirror_metadata';
 
 class _LocalMirrorSystem extends MirrorSystem {
-  // Change parameter back to "this.libraries" when native code is changed.
+  final Map<Uri, LibraryMirror> libraries;
+  final IsolateMirror isolate;
+
   _LocalMirrorSystem(List<LibraryMirror> libraries, this.isolate)
       : this.libraries = new Map<Uri, LibraryMirror>.fromIterable(
             libraries, key: (e) => e.uri);
 
-  final Map<Uri, LibraryMirror> libraries;
-  final IsolateMirror isolate;
-
   TypeMirror _dynamicType = null;
   TypeMirror get dynamicType {
     if (_dynamicType == null) {
       _dynamicType = new _SpecialTypeMirror('dynamic');
     }
     return _dynamicType;
   }
 
   TypeMirror _voidType = null;
   TypeMirror get voidType {
     if (_voidType == null) {
       _voidType = new _SpecialTypeMirror('void');
     }
     return _voidType;
   }
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
 
 abstract class _LocalMirror implements Mirror {}
 
 class _LocalIsolateMirror extends _LocalMirror implements IsolateMirror {
-  _LocalIsolateMirror (this.debugName, this.rootLibrary);
+  final String debugName;
+  final LibraryMirror rootLibrary;
 
-  final String debugName;
-  final bool isCurrent = true;
-  final LibraryMirror rootLibrary;
+  _LocalIsolateMirror(this.debugName, this.rootLibrary);
+
+  bool get isCurrent => true;
 
   String toString() => "IsolateMirror on '$debugName'";
 }
 
 class _InvocationTrampoline implements Function {
-  ObjectMirror _receiver;
-  Symbol _selector;
+  final ObjectMirror _receiver;
+  final Symbol _selector;
   _InvocationTrampoline(this._receiver, this._selector);
   noSuchMethod(Invocation msg) {
     if (msg.memberName != #call) return super.noSuchMethod(msg);
     return _receiver.invoke(_selector,
                             msg.positionalArguments,
                             msg.namedArguments);
   }
 }
 
 abstract class _LocalObjectMirror extends _LocalMirror implements ObjectMirror {
+  final _reflectee; // May be a MirrorReference or an ordinary object.
+
   _LocalObjectMirror(this._reflectee);
 
-  final _reflectee; // May be a MirrorReference or an ordinary object.
-
   InstanceMirror invoke(Symbol memberName,
                         List positionalArguments,
                         [Map<Symbol, dynamic> namedArguments]) {
-
     int numPositionalArguments = positionalArguments.length;
     int numNamedArguments = namedArguments != null ? namedArguments.length : 0;
     int numArguments = numPositionalArguments + numNamedArguments;
     List arguments = new List(numArguments);
     arguments.setRange(0, numPositionalArguments, positionalArguments);
     List names = new List(numNamedArguments);
     int argumentIndex = numPositionalArguments;
     int nameIndex = 0;
     if (numNamedArguments > 0) {
       namedArguments.forEach((name, value) {
         arguments[argumentIndex++] = value;
         names[nameIndex++] = _n(name);
       });
     }
 
-    return reflect(this._invoke(_reflectee,
-                                _n(memberName),
-                                arguments,
-                                names));
+    return reflect(this._invoke(_reflectee, _n(memberName), arguments, names));
   }
 
   InstanceMirror getField(Symbol memberName) {
-    return reflect(this._invokeGetter(_reflectee,
-                                      _n(memberName)));
+    return reflect(this._invokeGetter(_reflectee, _n(memberName)));
   }
 
   InstanceMirror setField(Symbol memberName, Object value) {
-    this._invokeSetter(_reflectee,
-                       _n(memberName),
-                       value);
+    this._invokeSetter(_reflectee, _n(memberName), value);
     return reflect(value);
   }
 }
 
 class _LocalInstanceMirror extends _LocalObjectMirror
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
   _LocalInstanceMirror(reflectee) : super(reflectee);
@@ skipping 70 matching lines @@
     List names = new List(numNamedArguments);
     int argumentIndex = numPositionalArguments;
     int nameIndex = 0;
     if (numNamedArguments > 0) {
       namedArguments.forEach((name, value) {
         arguments[argumentIndex++] = value;
         names[nameIndex++] = _n(name);
       });
     }
 
-    return reflect(this._invoke(_reflectee,
-                                _n(memberName),
-                                arguments,
-                                names));
+    return reflect(this._invoke(_reflectee, _n(memberName), arguments, names));
   }
 
   _invoke(reflectee, functionName, arguments, argumentNames)
       native 'InstanceMirror_invoke';
 
   _invokeGetter(reflectee, getterName)
       native 'InstanceMirror_invokeGetter';
 
   _invokeSetter(reflectee, setterName, value)
       native 'InstanceMirror_invokeSetter';
@@ skipping 72 matching lines @@
 
   static _computeFunction(reflectee)
       native 'ClosureMirror_function';
 
   static _computeFindInContext(reflectee, name)
       native 'ClosureMirror_find_in_context';
 }
 
 class _LocalClassMirror extends _LocalObjectMirror
     implements ClassMirror {
+  final Type _reflectedType;
+  Symbol _simpleName;
+  DeclarationMirror _owner;
+  final bool _isGeneric;
+  final bool _isMixinAlias;
+  final bool _isGenericDeclaration;
+  Type _instantiator;
+
   _LocalClassMirror(reflectee,
                     reflectedType,
                     String simpleName,
                     this._owner,
                     this._isGeneric,
                     this._isMixinAlias,
                     this._isGenericDeclaration)
       : this._simpleName = _s(simpleName),
         this._reflectedType = reflectedType,
         this._instantiator = reflectedType,
         super(reflectee);
 
-  final Type _reflectedType;
-  final bool _isGeneric;
-  final bool _isMixinAlias;
-  final bool _isGenericDeclaration;
-  Type _instantiator;
 
   bool get hasReflectedType => !_isGenericDeclaration;
   Type get reflectedType {
     if (!hasReflectedType) {
       throw new UnsupportedError(
           "Declarations of generics have no reflected type");
     }
     return _reflectedType;
   }
 
-  Symbol _simpleName;
   Symbol get simpleName {
     // All but anonymous mixin applications have their name set at construction.
     if(_simpleName == null) {
       _simpleName = this._mixinApplicationName;
     }
     return _simpleName;
   }
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
-  var _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _library(_reflectee);
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   final bool isTopLevel = true;
@@ skipping 352 matching lines @@
 
   static Type _FunctionTypeMirror_return_type(reflectee, instantiator)
       native "FunctionTypeMirror_return_type";
 
   List<ParameterMirror> _FunctionTypeMirror_parameters(reflectee)
       native "FunctionTypeMirror_parameters";
 }
 
 abstract class _LocalDeclarationMirror extends _LocalMirror
     implements DeclarationMirror {
+  final _reflectee;
+  Symbol _simpleName;
+
   _LocalDeclarationMirror(this._reflectee, this._simpleName);
 
-  final _reflectee;
-
-  Symbol _simpleName;
   Symbol get simpleName => _simpleName;
 
   Symbol _qualifiedName = null;
   Symbol get qualifiedName {
     if (_qualifiedName == null) {
       _qualifiedName = _computeQualifiedName(owner, simpleName);
     }
     return _qualifiedName;
   }
 
@@ skipping 21 matching lines @@
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _TypeVariableMirror_owner(_reflectee).originalDeclaration;
     }
     return _owner;
   }
 
   bool get isPrivate => false;
   bool get isStatic => false;
-
-  final bool isTopLevel = false;
+  bool get isTopLevel => false;
 
   SourceLocation get location {
     throw new UnimplementedError(
         'TypeVariableMirror.location is not implemented');
   }
 
   TypeMirror _upperBound = null;
   TypeMirror get upperBound {
     if (_upperBound == null) {
       _upperBound = reflectType(_TypeVariableMirror_upper_bound(_reflectee));
@@ skipping 22 matching lines @@
   static DeclarationMirror _TypeVariableMirror_owner(reflectee)
       native "TypeVariableMirror_owner";
 
   static Type _TypeVariableMirror_upper_bound(reflectee)
       native "TypeVariableMirror_upper_bound";
 }
 
 
 class _LocalTypedefMirror extends _LocalDeclarationMirror
     implements TypedefMirror {
+  final Type _reflectedType;
+  final bool _isGeneric;
+  final bool _isGenericDeclaration;
+
   _LocalTypedefMirror(reflectee,
                       this._reflectedType,
                       String simpleName,
                       this._isGeneric,
                       this._isGenericDeclaration,
                       this._owner)
       : super(reflectee, _s(simpleName));
 
-  final Type _reflectedType;
-  final bool _isGeneric;
-  final bool _isGenericDeclaration;
-
   bool get isTopLevel => true;
   bool get isPrivate => false;
 
   DeclarationMirror _owner;
   DeclarationMirror get owner {
     if (_owner == null) {
       _owner = _LocalClassMirror._library(_reflectee);
     }
     return _owner;
   }
@@ skipping 54 matching lines @@
 
   static _nativeReferent(reflectedType)
       native "TypedefMirror_referent";
 
   static _nativeDeclaration(reflectedType)
       native "TypedefMirror_declaration";
 }
 
 class _LocalLibraryMirror extends _LocalObjectMirror
     implements LibraryMirror {
+  final Symbol simpleName;
+  final Uri uri;
+
   _LocalLibraryMirror(reflectee,
                       String simpleName,
                       String url)
       : this.simpleName = _s(simpleName),
         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;
+  DeclarationMirror get owner => null;
 
-  // Always false for libraries.
-  final bool isPrivate = false;
-
-  // Always false for libraries.
-  final bool isTopLevel = false;
+  bool get isPrivate => false;
+  bool get isTopLevel => false;
 
   Type get _instantiator => null;
 
   SourceLocation get location {
     throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
-  final Uri uri;
-
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     return _declarations =
         new _UnmodifiableMapView<Symbol, DeclarationMirror>(members);
   }
 
   Map<Symbol, Mirror> _members;
   Map<Symbol, Mirror> get members {
     if (_members == null) {
@@ skipping 84 matching lines @@
 
   _invokeSetter(reflectee, setterName, value)
       native 'LibraryMirror_invokeSetter';
 
   _computeMembers(reflectee)
       native "LibraryMirror_members";
 }
 
 class _LocalMethodMirror extends _LocalDeclarationMirror
     implements MethodMirror {
+  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-", "~/"];
+
   _LocalMethodMirror(reflectee,
                      String simpleName,
                      this._owner,
                      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));
 
-  static const _operators = const ["%", "&", "*", "+", "-", "/", "<", "<<",
-      "<=", "==", ">", ">=", ">>", "[]", "[]=", "^", "|", "~", "unary-", "~/"];
-
-  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;
-
   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);
     }
     return _owner;
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_') ||
                         _n(constructorName).startsWith('_');
 
-  bool get isTopLevel =>  owner is LibraryMirror;
+  bool get isTopLevel => owner is LibraryMirror;
 
   SourceLocation get location {
     throw new UnimplementedError('MethodMirror.location is not implemented');
   }
 
   Type get _instantiator {
     var o = owner;
     while (o is MethodMirror) o = o.owner;
     return o._instantiator;
   }
@@ skipping 72 matching lines @@
 
   List<ParameterMirror> _MethodMirror_parameters(reflectee)
       native "MethodMirror_parameters";
 
   static String _MethodMirror_source(reflectee)
       native "MethodMirror_source";
 }
 
 class _LocalVariableMirror extends _LocalDeclarationMirror
     implements VariableMirror {
+  final DeclarationMirror owner;
+  final bool isStatic;
+  final bool isFinal;
+  final bool isConst;
+
   _LocalVariableMirror(reflectee,
                        String simpleName,
                        this.owner,
                        this._type,
                        this.isStatic,
                        this.isFinal,
                        this.isConst)
       : super(reflectee, _s(simpleName));
 
-  final DeclarationMirror owner;
-  final bool isStatic;
-  final bool isFinal;
-  final bool isConst;
-
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   bool get isTopLevel => owner is LibraryMirror;
 
   SourceLocation get location {
     throw new UnimplementedError('VariableMirror.location is not implemented');
   }
 
   Type get _instantiator {
     return owner._instantiator;
   }
 
   TypeMirror _type;
   TypeMirror get type {
     if (_type == null) {
        _type = reflectType(_VariableMirror_type(_reflectee, _instantiator));
     }
     return _type;
   }
 
   String toString() => "VariableMirror on '${MirrorSystem.getName(simpleName)}'";
 
   static _VariableMirror_type(reflectee, instantiator)
       native "VariableMirror_type";
 }
 
 class _LocalParameterMirror extends _LocalVariableMirror
     implements ParameterMirror {
+  final int _position;
+  final bool isOptional;
+  final bool isNamed;
+  final List _unmirroredMetadata;
+
   _LocalParameterMirror(reflectee,
                         String simpleName,
                         DeclarationMirror owner,
                         this._position,
                         this.isOptional,
                         this.isNamed,
                         bool isFinal,
                         this._defaultValueReflectee,
                         this._unmirroredMetadata)
       : super(reflectee,
               simpleName,
               owner,
               null,  // We override the type.
               false, // isStatic does not apply.
               isFinal,
               false  // Not const.
               );
 
-  final int _position;
-  final bool isOptional;
-  final bool isNamed;
-  final List _unmirroredMetadata;
-
   Object _defaultValueReflectee;
   InstanceMirror _defaultValue;
   InstanceMirror get defaultValue {
     if (!isOptional) {
       return null;
     }
     if (_defaultValue == null) {
       _defaultValue = reflect(_defaultValueReflectee);
     }
     return _defaultValue;
@@ skipping 22 matching lines @@
   }
 
   String toString() => "ParameterMirror on '${_n(simpleName)}'";
 
   static Type _ParameterMirror_type(_reflectee, _position, instantiator)
       native "ParameterMirror_type";
 }
 
 class _SpecialTypeMirror extends _LocalMirror
     implements TypeMirror, DeclarationMirror {
+  final Symbol simpleName;
+
   _SpecialTypeMirror(String name) : simpleName = _s(name);
 
-  final bool isPrivate = false;
-  final DeclarationMirror owner = null;
-  final Symbol simpleName;
-  final bool isTopLevel = true;
-  final List<InstanceMirror> metadata = emptyList;
+  bool get isPrivate => false;
+  bool get isTopLevel => true;
+
+  DeclarationMirror get owner => null;
+
+  List<InstanceMirror> get metadata => emptyList;
 
   List<TypeVariableMirror> get typeVariables => emptyList;
   List<TypeMirror> get typeArguments => emptyList;
 
   bool get isOriginalDeclaration => true;
   TypeMirror get originalDeclaration => this;
 
   SourceLocation get location {
     throw new UnimplementedError('TypeMirror.location is not implemented');
   }
@@ skipping 64 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }