Initializes _data in constructor

reflectable/lib/src/mirrors_unimpl.dart

 // Copyright (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.mirrors_unimpl;
 
 import 'dart:collection' show UnmodifiableMapView, UnmodifiableListView;
 
 import '../capability.dart';
 import '../mirrors.dart';
@@ skipping 86 matching lines @@
   }
 }
 
 /// This mapping contains the mirror-data for each reflector.
 /// It will be initialized in the generated code.
 Map<Reflectable, ReflectorData> data =
     throw new StateError("Reflectable has not been initialized. "
         "Did you forget to add the main file to the "
         "reflectable transformer's entry_points in pubspec.yaml?");
 
-abstract class _DataCaching {
-  // TODO(eernst) clarify: When we have some substantial pieces of code using
-  // reflectable, perform some experiments to detect how useful it is to have
-  // this kind of caching.
+abstract class _DataCachingMirror {
+  /// The reflector which represents the mirror system that this
+  /// mirror belongs to.
+  final ReflectableImpl _reflector;
 
-  ReflectorData _dataCache;
-  ReflectableImpl get _reflector;
+  /// Reflector data associated with this mirror.
+  final ReflectorData _data;
 
-  ReflectorData get _data {
-    if (_dataCache == null) {
-      _dataCache = data[_reflector];
-    }
-    return _dataCache;
-  }
+  _DataCachingMirror(ReflectableImpl reflector)
+      : _reflector = reflector,
+        _data = data[reflector];
 }
 
-class _InstanceMirrorImpl extends _DataCaching implements InstanceMirror {
-  final ReflectableImpl _reflector;
+class _InstanceMirrorImpl extends _DataCachingMirror implements InstanceMirror {
   final Object reflectee;
 
-  _InstanceMirrorImpl(this.reflectee, this._reflector) {
+  _InstanceMirrorImpl(this.reflectee, ReflectableImpl reflector)
+      : super(reflector) {
     _type = _data.classMirrorForType(reflectee.runtimeType);
     if (_type == null) {
       throw new NoSuchCapabilityError(
           "Reflecting on un-marked type ${reflectee.runtimeType}");
     }
   }
 
   ClassMirror _type;
 
   ClassMirror get type => _type;
@@ skipping 81 matching lines @@
             variableMirror._ownerIndex,
             variableMirror._reflector,
             variableMirror.metadata,
             null,
             -1)
       ],
       variableMirror._reflector,
       []);
 }
 
-class ClassMirrorImpl extends _DataCaching implements ClassMirror {
-  /// The reflector which represents the mirror system that this
-  /// mirror belongs to.
-  final ReflectableImpl _reflector;
-
+class ClassMirrorImpl extends _DataCachingMirror implements ClassMirror {
   /// The index of this mirror in the [ReflectorData.classMirrors] table.
   /// Also this is the index of the Type of the reflected class in
   /// [ReflectorData.types].
   final int _classIndex;
 
   /// A list of the indices in [ReflectorData.memberMirrors] of the
   /// declarations of the reflected class. This includes method mirrors
   /// and variable mirrors and it directly corresponds to `declarations`.
   final List<int> _declarationIndices;
 
@@ skipping 12 matching lines @@
   final String qualifiedName;
   final List<Object> _metadata;
   final Map<String, _StaticGetter> getters;
   final Map<String, _StaticSetter> setters;
   final Map<String, Function> constructors;
 
   ClassMirrorImpl(
       this.simpleName,
       this.qualifiedName,
       this._classIndex,
-      this._reflector,
+      ReflectableImpl reflector,
       this._declarationIndices,
       this._instanceMemberIndices,
       this._superclassIndex,
       this.getters,
       this.setters,
       this.constructors,
       metadata)
       : _metadata =
-            (metadata == null) ? null : new UnmodifiableListView(metadata);
+            (metadata == null) ? null : new UnmodifiableListView(metadata),
+        super(reflector);
 
   ClassMirror get superclass {
     if (_superclassIndex == null) return null;
     if (_superclassIndex == -1) {
       throw new NoSuchCapabilityError(
           "Requesting mirror on un-marked class, superclass of $simpleName");
     }
     return _data.classMirrors[_superclassIndex];
   }
 
@@ skipping 159 matching lines @@
     return getter;
   }
 
   String toString() => "ClassMirrorImpl($qualifiedName)";
 
   // Because we take care to only ever create one instance for each
   // type/reflector-combination we can rely on the default `hashCode` and `==`
   // operations.
 }
 
-class MethodMirrorImpl extends _DataCaching implements MethodMirror {
+class MethodMirrorImpl extends _DataCachingMirror implements MethodMirror {
   /// An encoding of the attributes and kind of this mirror.
   final int _descriptor;
 
   /// The name of this method. Setters names will end in '='.
   final String _name;
 
   /// The index of the [ClassMirror] of the owner of this method,
   final int _ownerIndex;
 
   /// The indices of the [ParameterMirror]s describing the formal parameters
   /// of this method.
   final List<int> _parameterIndices;
 
-  /// The [Reflectable] associated with this mirror.
-  final ReflectableImpl _reflector;
-
   /// A cache of the metadata of the mirrored method. The empty list means
   /// no metadata, null means that [_reflector] does not have
   /// [metadataCapability].
   final List<Object> _metadata;
 
   MethodMirrorImpl(this._name, this._descriptor, this._ownerIndex,
-      this._parameterIndices, this._reflector, List<Object> metadata)
+      this._parameterIndices, ReflectableImpl reflector, List<Object> metadata)
       : _metadata =
-            (metadata == null) ? null : new UnmodifiableListView(metadata);
+            (metadata == null) ? null : new UnmodifiableListView(metadata),
+        super(reflector);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
   ClassMirror get owner => _data.classMirrors[_ownerIndex];
 
   @override
   String get constructorName => _name;
 
   @override
   bool get isAbstract => (_descriptor & constants.abstractAttribute != 0);
@@ skipping 71 matching lines @@
       ? (_name == '' ? "${owner.simpleName}" : "${owner.simpleName}.$_name")
       : _name;
 
   @override
   String get source => null;
 
   @override
   String toString() => "MethodMirror($_name)";
 }
 
-abstract class VariableMirrorBase extends _DataCaching
+abstract class VariableMirrorBase extends _DataCachingMirror
     implements VariableMirror {
   final String _name;
   final int _descriptor;
   final int _ownerIndex;
-  final ReflectableImpl _reflector;
   final List<Object> _metadata;
 
   VariableMirrorBase(this._name, this._descriptor, this._ownerIndex,
-      this._reflector, List<Object> metadata)
+      ReflectableImpl reflector, List<Object> metadata)
       : _metadata =
-            (metadata == null) ? null : new UnmodifiableListView(metadata);
+            (metadata == null) ? null : new UnmodifiableListView(metadata),
+        super(reflector);
 
   int get kind => constants.kindFromEncoding(_descriptor);
 
   @override
   bool get isPrivate => (_descriptor & constants.privateAttribute != 0);
 
   @override
   bool get isTopLevel => owner is LibraryMirror;
 
   @override
@@ skipping 207 matching lines @@
   LibraryMirror findLibrary(String library) => _unsupported();
 
   @override
   Map<Uri, LibraryMirror> get libraries => _unsupported();
 
   @override
   Iterable<ClassMirror> get annotatedClasses {
     return new UnmodifiableListView<ClassMirror>(data[this].classMirrors);
   }
 }