Creates `reflectors`, as a meta-meta feature that enables dynamic selection of a "mirror system".

reflectable/lib/src/reflectable_transformer_based.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';
 import '../reflectable.dart';
 import 'encoding_constants.dart' as constants;
 import 'encoding_constants.dart' show NO_CAPABILITY_INDEX;
 import 'reflectable_base.dart';
 
 bool get isTransformed => true;
 
+/// Returns the set of reflectors in the current program.
+Set<Reflectable> get reflectors => data.keys.toSet();
+
 // Mirror classes with default implementations of all methods, to be used as
 // superclasses of transformer generated static mirror classes.  They serve to
 // ensure that the static mirror classes always implement all methods, such that
 // they throw an exception at runtime, rather than causing an error at compile
 // time, which is the required behavior for static mirrors when they are used
 // in ways that are not covered by the specified capabilities.
 //
 // Each of these classes implements the corresponding class in
 // `package:reflectable/mirrors.dart`, and they replicate the internal
 // implements `structure in package:reflectable/mirrors.dart` using `extends`
@@ skipping 173 matching lines @@
     }
     throw new NoSuchInvokeCapabilityError(reflectee, setterName, [value], {});
   }
 }
 
 class ClassMirrorImpl extends _DataCaching implements ClassMirror {
   /// The reflector which represents the mirror system that this
   /// mirror belongs to.
   final ReflectableImpl _reflector;
 
+  /// An encoding of the attributes and kind of this class mirror.
+  final int _descriptor;
+
   /// 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;
 
   /// The index of the owner library in the [ReflectorData.libraryMirrors]
   /// table.
   final int _ownerIndex;
 
   /// The index of the mirror of the superclass in the
@@ skipping 53 matching lines @@
   final String simpleName;
   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._descriptor,
       this._classIndex,
       this._reflector,
       this._declarationIndices,
       this._instanceMemberIndices,
       this._staticMemberIndices,
       this._superclassIndex,
       this._getters,
       this._setters,
       this._constructors,
       this._ownerIndex,
       this._mixinIndex,
       this._superinterfaceIndices,
       List<Object> metadata)
       : _metadata =
             (metadata == null) ? null : new UnmodifiableListView(metadata);
 
-  bool get isAbstract => _unsupported();
+  bool get isAbstract => (_descriptor & constants.abstractAttribute != 0);
 
   Map<String, DeclarationMirror> _declarations;
 
   Map<String, DeclarationMirror> get declarations {
     if (_declarations == null) {
       Map<String, DeclarationMirror> result =
           new Map<String, DeclarationMirror>();
       for (int declarationIndex in _declarationIndices) {
         // We encode a missing `declarations` capability as an index with
         // the value NO_CAPABILITY_INDEX. Note that `_declarations` will not be
@@ skipping 175 matching lines @@
     return _data.classMirrors[_superclassIndex];
   }
 
   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 LibraryMirrorImpl implements LibraryMirror {
-  LibraryMirrorImpl(this.simpleName, this.uri, this.getters, this.setters,
+class LibraryMirrorImpl extends _DataCaching implements LibraryMirror {
+  LibraryMirrorImpl(
+      this.simpleName,
+      this.uri,
+      this._reflector,
+      this._declarationIndices,
+      this.getters,
+      this.setters,
       List<Object> metadata)
       : _metadata =
             metadata == null ? null : new UnmodifiableListView(metadata);
 
+  final ReflectableImpl _reflector;
+
+  /// A list of the indices in [ReflectorData.memberMirrors] of the
+  /// declarations of the reflected class. This includes method mirrors for
+  /// top level functions of this library and it directly corresponds to
+  /// `declarations`. Exception: When the given `_reflector.capabilities` do
+  /// not support the operation `declarations`, this will be
+  /// `<int>[NO_CAPABILITY_INDEX]`. It is enough to check that the list is
+  /// non-empty and first element is NO_CAPABILITY_INDEX to detect this
+  /// situation, because NO_CAPABILITY_INDEX` will otherwise never occur.
+  final List<int> _declarationIndices;
+
+  @override
   final Uri uri;
 
-  // TODO(eernst) clarify: `_unsupported()` means not yet implemented here?
-  Map<String, DeclarationMirror> get declarations => _unsupported();
-
   @override
   final String simpleName;
 
   final Map<String, _StaticGetter> getters;
   final Map<String, _StaticSetter> setters;
 
+  Map<String, DeclarationMirror> _declarations;
+
+  @override
+  Map<String, DeclarationMirror> get declarations {
+    if (_declarations == null) {
+      Map<String, DeclarationMirror> result =
+          new Map<String, DeclarationMirror>();
+      for (int declarationIndex in _declarationIndices) {
+        // We encode a missing `declarations` capability as an index with
+        // the value NO_CAPABILITY_INDEX. Note that `_declarations` will not be
+        // initialized and hence we will come here repeatedly if that is the
+        // case; however, performing operations for which there is no capability
+        // need not have stellar performance, it is almost always a bug to do
+        // that.
+        if (declarationIndex == NO_CAPABILITY_INDEX) {
+          throw new NoSuchCapabilityError(
+              "Requesting declarations of '$qualifiedName' without capability");
+        }
+        DeclarationMirror declarationMirror =
+            _data.memberMirrors[declarationIndex];
+        result[declarationMirror.simpleName] = declarationMirror;
+      }
+      _declarations =
+          new UnmodifiableMapView<String, DeclarationMirror>(result);
+    }
+    return _declarations;
+  }
+
   @override
   Object invoke(String memberName, List positionalArguments,
       [Map<Symbol, dynamic> namedArguments]) {
     _StaticGetter getter = getters[memberName];
     if (getter == null) {
       throw new NoSuchInvokeCapabilityError(
           null, memberName, positionalArguments, namedArguments);
     }
     return Function.apply(
-        getters[memberName](), positionalArguments, namedArguments);
+        getter(), positionalArguments, namedArguments);
   }
 
   @override
   Object invokeGetter(String getterName) {
     _StaticGetter getter = getters[getterName];
     if (getter == null) {
       throw new NoSuchInvokeCapabilityError(null, getterName, [], {});
     }
     return getter();
   }
@@ skipping 659 matching lines @@
   LibraryMirror findLibrary(String libraryName) {
     if (data[this].libraryMirrors == null) {
       throw new NoSuchCapabilityError("Using 'findLibrary' without capability. "
           "Try adding 'libraryCapability'.");
     }
     return data[this].libraryMirrors.singleWhere(
         (LibraryMirror mirror) => mirror.qualifiedName == libraryName);
   }
 
   @override
-  Map<Uri, LibraryMirror> get libraries => _unsupported();
+  Map<Uri, LibraryMirror> get libraries {
+    Map<Uri, LibraryMirror> result = <Uri, LibraryMirror>{};
+    for (LibraryMirror library in data[this].libraryMirrors) {
+      result[library.uri] = library;
+    }
+    return new UnmodifiableMapView(result);
+  }
 
   @override
   Iterable<ClassMirror> get annotatedClasses {
     return new UnmodifiableListView<ClassMirror>(data[this].classMirrors);
   }
 }
 
 // For mixin-applications we need to construct objects that represents their
 // type.
 class FakeType implements Type {
   const FakeType(this.description);
 
   final String description;
 
   String toString() => "Type($description)";
 }