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

reflectable/lib/src/reflectable_mirror_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.
 
 // TODO(sigurdm) doc: Make NoSuchCapability messages streamlined (the same in
 // both `reflectable_mirror_based.dart` and
 // `reflectable_transformer_based.dart`, and explaining as well as possible
 // which capability is missing.)
 
 /// Implementation of the reflectable interface using dart mirrors.
 library reflectable.src.reflectable_implementation;
 
 import 'dart:mirrors' as dm;
 import 'reflectable_base.dart';
 import 'fixed_point.dart';
 import '../capability.dart';
 import '../mirrors.dart' as rm;
 import '../reflectable.dart';
 
 bool get isTransformed => false;
 
+/// Returns the set of reflectors in the current program.
+Set<Reflectable> get reflectors {
+  Set<Reflectable> result = new Set<Reflectable>();
+  for (dm.LibraryMirror library in dm.currentMirrorSystem().libraries.values) {
+    for (dm.LibraryDependencyMirror dependency in library.libraryDependencies) {
+      if (dependency.isImport &&
+          dependency.targetLibrary.qualifiedName == reflectableLibrarySymbol) {
+        for (dm.InstanceMirror metadatumMirror in dependency.metadata) {
+          Object metadatum = metadatumMirror.reflectee;
+          if (metadatum is GlobalQuantifyCapability) {
+            result.add(metadatum.reflector);
+          }
+          if (metadatum is GlobalQuantifyMetaCapability) {
+            result.add(metadatum.reflector);
+          }
+        }
+      }
+    }
+  }
+  for (dm.LibraryMirror library in dm.currentMirrorSystem().libraries.values) {
+    for (dm.DeclarationMirror declaration in library.declarations.values) {
+      for (dm.InstanceMirror metadatum in declaration.metadata) {
+        if (metadatum.reflectee is Reflectable) {
+          result.add(metadatum.reflectee);
+        }
+      }
+    }
+  }
+  return result;
+}
+
 /// The name of the reflectable library.
 const Symbol reflectableLibrarySymbol = #reflectable.reflectable;
 
 rm.ClassMirror wrapClassMirrorIfSupported(
     dm.ClassMirror classMirror, ReflectableImpl reflectable) {
   if (classMirror is dm.FunctionTypeMirror) {
     // TODO(sigurdm) clarify: Exactly what capabilities will allow reflecting on
     // a function is still not clear.
     return new _FunctionTypeMirrorImpl(classMirror, reflectable);
   } else {
@@ skipping 330 matching lines @@
   @override
   Map<String, rm.DeclarationMirror> get declarations {
     if (!reflectableSupportsDeclarations(_reflectable)) {
       throw new NoSuchCapabilityError(
           "Attempt to get declarations without capability");
     }
     Map<Symbol, dm.DeclarationMirror> decls = _libraryMirror.declarations;
     Iterable<Symbol> relevantKeys = decls.keys.where((k) {
       List<dm.InstanceMirror> metadata = decls[k].metadata;
       for (var item in metadata) {
-        if (item.hasReflectee && item.reflectee is ReflectableImpl) return true;
+        if (item.hasReflectee && item.reflectee == _reflectable) return true;
       }
       return false;
     });
     return new Map<String, rm.DeclarationMirror>.fromIterable(relevantKeys,
         key: (k) => dm.MirrorSystem.getName(k),
         value: (v) => wrapDeclarationMirror(decls[v], _reflectable));
   }
 
   @override
   Object invoke(String memberName, List positionalArguments,
@@ skipping 1311 matching lines @@
         for (dm.ParameterMirror parameter in declaration.parameters) {
           dm.TypeMirror typeMirror = parameter.type.originalDeclaration;
           if (typeMirror is dm.ClassMirror) yield typeMirror;
         }
         dm.TypeMirror typeMirror = declaration.returnType;
         if (typeMirror is dm.ClassMirror) yield typeMirror;
       }
     }
   }
 }