Implements support for reflection on parameters.

test_reflectable/test/declarations_test.dart

 // Copyright (c) 2015, 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.
 
 library test_reflectable.test.declarations_test;
 
 import "package:reflectable/reflectable.dart";
 import "package:unittest/unittest.dart";
 
 class Reflector extends Reflectable {
-  const Reflector() : super(instanceInvokeCapability, newInstanceCapability);
+  const Reflector()
+      : super(instanceInvokeCapability, newInstanceCapability,
+            declarationsCapability);
 }
 
 // TODO(sigurdm) implement: Adapt this test when we support fields.
 
 @Reflector()
 abstract class A {
   A();
   A.redirecting() : this();
   factory A.factory() {
     return new B();
@@ skipping 20 matching lines @@
 }
 
 main() {
   const reflector = const Reflector();
   Map<String, DeclarationMirror> declarationsA =
       reflector.reflectType(A).declarations;
   Map<String, DeclarationMirror> declarationsB =
       reflector.reflectType(B).declarations;
 
   test("declarations", () {
-    expect(declarationsA.values.map((x) => x.simpleName), new Set.from([
-      "foo",
-      "getter1",
-      "getter2",
-      "setter1=",
-      "+",
-      "A",
-      "A.redirecting",
-      "A.factory",
-      "A.redirectingFactory",
-      "A.c"
-    ]));
+    expect(
+        declarationsA.values.map((x) => x.simpleName),
+        new Set.from([
+          "foo",
+          "getter1",
+          "getter2",
+          "setter1=",
+          "+",
+          "A",
+          "A.redirecting",
+          "A.factory",
+          "A.redirectingFactory",
+          "A.c"
+        ]));
 
     expect(declarationsB.values.map((x) => x.simpleName),
         new Set.from(["bar", "getter1", "getter2", "setter2=", "B"]));
   });
 
   test("MethodMirror properties", () {
     MethodMirror foo = declarationsA["foo"] as MethodMirror;
     expect(foo.isRegularMethod, isTrue);
     expect(foo.isStatic, isFalse);
     expect(foo.isGetter, isFalse);
@@ skipping 81 matching lines @@
     expect(redirectingFactoryConstructorA.isConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isGenerativeConstructor, isFalse);
     expect(redirectingFactoryConstructorA.isFactoryConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isConstConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isRedirectingConstructor, isTrue);
   });
 
   test("instanceMethods", () {
     Map<String, DeclarationMirror> instanceMembersA =
         reflector.reflectType(A).instanceMembers;
-    expect(instanceMembersA.values.map((x) => x.simpleName), new Set.from([
-      "toString",
-      "hashCode",
-      "==",
-      "noSuchMethod",
-    "runtimeType",
-      "foo",
-      "getter1",
-      "setter1=",
-      "+"
-    ]));
+    expect(
+        instanceMembersA.values.map((x) => x.simpleName),
+        new Set.from([
+          "toString",
+          "hashCode",
+          "==",
+          "noSuchMethod",
+          "runtimeType",
+          "foo",
+          "getter1",
+          "setter1=",
+          "+"
+        ]));
     Map<String, DeclarationMirror> instanceMembersB =
         reflector.reflectType(B).instanceMembers;
-    expect(instanceMembersB.values.map((x) => x.simpleName), new Set.from([
-      "toString",
-      "hashCode",
-      "==",
-      "noSuchMethod",
-      "runtimeType",
-      "foo",
-      "bar",
-      "getter1",
-      "getter2",
-      "setter1=",
-      "setter2=",
-      "+"
-    ]));
+    expect(
+        instanceMembersB.values.map((x) => x.simpleName),
+        new Set.from([
+          "toString",
+          "hashCode",
+          "==",
+          "noSuchMethod",
+          "runtimeType",
+          "foo",
+          "bar",
+          "getter1",
+          "getter2",
+          "setter1=",
+          "setter2=",
+          "+"
+        ]));
   });
 }