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

test_reflectable/test/meta_reflector_test.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 test_reflectable.test.mixin_test;
+/// File being transformed by the reflectable transformer.
+/// Creates a `MetaReflector` which may be used to reflect on the set of
+/// reflectors themselves.
+library test_reflectable.test.meta_reflector_test;
 
+@GlobalQuantifyCapability(
+    r"^reflectable.reflectable.Reflectable$", const MetaReflector())
 import "package:reflectable/reflectable.dart";
 import "package:unittest/unittest.dart";
 
-class Reflector extends Reflectable {
+abstract class AllReflectorsCapable implements Reflectable {
+  Reflectable get self;
+  Set<String> get scopes;
+}
+
+class MetaReflector extends Reflectable {
+  const MetaReflector()
+      : super(subtypeQuantifyCapability, newInstanceCapability);
+  Set<Reflectable> get allReflectors {
+    Set<Reflectable> result = new Set<Reflectable>();
+    annotatedClasses.forEach((ClassMirror classMirror) {
+      if (classMirror.isAbstract) return;
+      Reflectable reflector = classMirror.newInstance("", []);
+      if (reflector is AllReflectorsCapable) {
+        result.add(reflector.self);
+      }
+    });
+    return result;
+  }
+}
+
+Set<String> setOf(String s) => new Set<String>.from(<String>[s]);
+
+class Reflector extends Reflectable implements AllReflectorsCapable {
   const Reflector()
       : super(invokingCapability, declarationsCapability, libraryCapability);
+  Reflectable get self => const Reflector();
+  Set<String> get scopes => setOf("polymer");
 }
 
-// Note the class `A` is not annotated by this.
-class Reflector2 extends Reflectable {
+class Reflector2 extends Reflectable implements AllReflectorsCapable {
   const Reflector2()
       : super(invokingCapability, metadataCapability, libraryCapability);
+  Reflectable get self => const Reflector2();
+  Set<String> get scopes => setOf("observe");
 }
 
-class ReflectorUpwardsClosed extends Reflectable {
+class ReflectorUpwardsClosed extends Reflectable
+    implements AllReflectorsCapable {
   const ReflectorUpwardsClosed()
       : super(superclassQuantifyCapability, invokingCapability,
             declarationsCapability, typeRelationsCapability);
+  Reflectable get self => const ReflectorUpwardsClosed();
+  Set<String> get scopes => setOf("polymer")..add("observe");
 }
 
-class ReflectorUpwardsClosedToA extends Reflectable {
+class ReflectorUpwardsClosedToA extends Reflectable
+    implements AllReflectorsCapable {
   const ReflectorUpwardsClosedToA()
       : super(const SuperclassQuantifyCapability(A), invokingCapability,
             declarationsCapability);
+  Reflectable get self => const ReflectorUpwardsClosedToA();
+  Set<String> get scopes => new Set<String>();
 }
 
-class ReflectorUpwardsClosedUntilA extends Reflectable {
+class ReflectorUpwardsClosedUntilA extends Reflectable
+    implements AllReflectorsCapable {
   const ReflectorUpwardsClosedUntilA()
       : super(const SuperclassQuantifyCapability(A, excludeUpperBound: true),
             invokingCapability, declarationsCapability);
+  Reflectable get self => const ReflectorUpwardsClosedUntilA();
+  Set<String> get scopes => new Set<String>();
 }
 
 @Reflector()
 @Reflector2()
 @P()
 class M1 {
   foo() {}
   var field;
   static staticFoo(x) {}
 }
@@ skipping 64 matching lines @@
     expect(bMirror.superclass.reflectedType, const isInstanceOf<Type>());
     expect(bMirror.superclass.superclass.reflectedType,
         const isInstanceOf<Type>());
   });
 }
 
 Matcher throwsANoSuchCapabilityException =
     throwsA(const isInstanceOf<NoSuchCapabilityError>());
 
 main() {
-  testReflector(const Reflector(), "each is annotated");
-  testReflector(const ReflectorUpwardsClosed(), "upwards closed");
-  test("Mixin, superclasses not included", () {
-    var reflector2 = const Reflector2();
+  Set<Reflectable> allReflectors = const MetaReflector().allReflectors;
+
+  test("MetaReflector, set of reflectors", () {
+    expect(
+        allReflectors,
+        [
+          const Reflector(),
+          const Reflector2(),
+          const ReflectorUpwardsClosed(),
+          const ReflectorUpwardsClosedToA(),
+          const ReflectorUpwardsClosedUntilA()
+        ].toSet());
+    expect(
+        allReflectors.where((AllReflectorsCapable reflector) =>
+            reflector.scopes.contains("polymer")),
+        [const Reflector(), const ReflectorUpwardsClosed()].toSet());
+    expect(
+        allReflectors.where((AllReflectorsCapable reflector) =>
+            reflector.scopes.contains("observe")),
+        [const Reflector2(), const ReflectorUpwardsClosed()].toSet());
+  });
+
+  allReflectors
+      .where((AllReflectorsCapable reflector) =>
+          reflector.scopes.contains("polymer"))
+      .forEach(
+          (Reflectable reflector) => testReflector(reflector, "$reflector"));
+
+  test("MetaReflector, select by name", () {
+    var reflector2 = allReflectors
+        .firstWhere((Reflectable reflector) => "$reflector".contains("2"));
     ClassMirror bMirror = reflector2.reflectType(B);
     ClassMirror cMirror = reflector2.reflectType(C);
     ClassMirror dMirror = reflector2.reflectType(D);
     ClassMirror m1Mirror = reflector2.reflectType(M1);
     ClassMirror m2Mirror = reflector2.reflectType(M2);
     ClassMirror m3Mirror = reflector2.reflectType(M3);
     expect(bMirror.mixin, bMirror);
     expect(cMirror.mixin, cMirror);
     expect(dMirror.mixin, m1Mirror);
     expect(m1Mirror.mixin, m1Mirror);
     // Test that metadata is preserved.
     expect(m1Mirror.metadata, contains(const P()));
     expect(m2Mirror.mixin, m2Mirror);
     expect(m3Mirror.mixin, m3Mirror);
     expect(bMirror.superclass.mixin, m1Mirror);
     // Test that the mixin-application does not inherit the metadata from its
     // mixin.
     expect(bMirror.superclass.metadata, isEmpty);
     expect(
         () => bMirror.superclass.superclass, throwsANoSuchCapabilityException);
     expect(cMirror.superclass.superclass.mixin, m2Mirror);
     expect(cMirror.superclass.mixin, m3Mirror);
     expect(cMirror.superclass.superclass.superclass, bMirror);
     expect(() => dMirror.superclass, throwsANoSuchCapabilityException);
   });
-  test("Mixin, superclasses included up to bound", () {
-    var reflector = const ReflectorUpwardsClosedToA();
+
+  test("MetaReflector, select by capability", () {
+    var reflector = allReflectors.firstWhere((AllReflectorsCapable reflector) {
+      return (reflector.capabilities.any((ReflectCapability capability) =>
+          capability is SuperclassQuantifyCapability &&
+              capability.upperBound == A &&
+              !capability.excludeUpperBound));
+    });
     ClassMirror aMirror = reflector.reflectType(A);
     ClassMirror bMirror = reflector.reflectType(B);
     ClassMirror cMirror = reflector.reflectType(C);
     ClassMirror dMirror = reflector.reflectType(D);
     expect(() => reflector.reflectType(M1), throwsANoSuchCapabilityException);
     expect(() => reflector.reflectType(M2), throwsANoSuchCapabilityException);
     expect(() => reflector.reflectType(M3), throwsANoSuchCapabilityException);
     expect(() => bMirror.superclass.mixin, throwsANoSuchCapabilityException);
     expect(bMirror.superclass.superclass, aMirror);
     expect(() => cMirror.superclass.mixin, throwsANoSuchCapabilityException);
     expect(() => cMirror.superclass.superclass.mixin,
         throwsANoSuchCapabilityException);
     expect(cMirror.superclass.superclass.superclass, bMirror);
     expect(() => dMirror.mixin, throwsANoSuchCapabilityException);
     expect(dMirror.superclass, aMirror);
   });
-  test("Mixin, superclasses included up to but not including bound", () {
-    var reflector = const ReflectorUpwardsClosedUntilA();
-    ClassMirror bMirror = reflector.reflectType(B);
-    ClassMirror cMirror = reflector.reflectType(C);
-    ClassMirror dMirror = reflector.reflectType(D);
-    expect(() => reflector.reflectType(A), throwsANoSuchCapabilityException);
-    expect(() => reflector.reflectType(M1), throwsANoSuchCapabilityException);
-    expect(() => reflector.reflectType(M2), throwsANoSuchCapabilityException);
-    expect(() => reflector.reflectType(M3), throwsANoSuchCapabilityException);
-    expect(() => cMirror.superclass.mixin, throwsANoSuchCapabilityException);
-    expect(() => cMirror.superclass.superclass.mixin,
-        throwsANoSuchCapabilityException);
-    expect(cMirror.superclass.superclass.superclass, bMirror);
-    expect(cMirror.superclass.superclass.superclass.superclass != null, true);
-    expect(() => cMirror.superclass.superclass.superclass.superclass.superclass,
-        throwsANoSuchCapabilityException);
-    expect(() => dMirror.mixin, throwsANoSuchCapabilityException);
-    expect(() => dMirror.superclass, throwsANoSuchCapabilityException);
-  });
-  test("Mixin, naming", () {
-    var reflector2 = const Reflector2();
-    ClassMirror bMirror = reflector2.reflectType(B);
-    ClassMirror cMirror = reflector2.reflectType(C);
-    ClassMirror dMirror = reflector2.reflectType(D);
-    ClassMirror aWithM1Mirror = bMirror.superclass;
-    ClassMirror bWithM2Mirror = cMirror.superclass.superclass;
-    ClassMirror bWithM2WithM3Mirror = cMirror.superclass;
-    expect(bMirror.simpleName, "B");
-    expect(cMirror.simpleName, "C");
-    expect(dMirror.simpleName, "D");
-    expect(
-        aWithM1Mirror.simpleName,
-        "test_reflectable.test.mixin_test.A with "
-        "test_reflectable.test.mixin_test.M1");
-    expect(
-        bWithM2Mirror.simpleName,
-        "test_reflectable.test.mixin_test.B with "
-        "test_reflectable.test.mixin_test.M2");
-    expect(
-        bWithM2WithM3Mirror.simpleName,
-        "test_reflectable.test.mixin_test.B with "
-        "test_reflectable.test.mixin_test.M2, "
-        "test_reflectable.test.mixin_test.M3");
-    expect(cMirror.simpleName, "C");
-    expect(dMirror.simpleName, "D");
-
-    expect(bMirror.qualifiedName, "test_reflectable.test.mixin_test.B");
-    expect(cMirror.qualifiedName, "test_reflectable.test.mixin_test.C");
-    expect(dMirror.qualifiedName, "test_reflectable.test.mixin_test.D");
-    expect(
-        aWithM1Mirror.qualifiedName,
-        "test_reflectable.test.mixin_test."
-        "test_reflectable.test.mixin_test.A with "
-        "test_reflectable.test.mixin_test.M1");
-    expect(
-        bWithM2Mirror.qualifiedName,
-        "test_reflectable.test.mixin_test."
-        "test_reflectable.test.mixin_test.B with "
-        "test_reflectable.test.mixin_test.M2");
-    expect(
-        bWithM2WithM3Mirror.qualifiedName,
-        "test_reflectable.test.mixin_test."
-        "test_reflectable.test.mixin_test.B with "
-        "test_reflectable.test.mixin_test.M2, "
-        "test_reflectable.test.mixin_test.M3");
-    expect(cMirror.qualifiedName, "test_reflectable.test.mixin_test.C");
-    expect(dMirror.qualifiedName, "test_reflectable.test.mixin_test.D");
-  });
 }