Implements support for reflection on parameters.

test_reflectable/test/basic_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.
 
 // Tests some basic functionality of instance mirrors and class mirrors.
 
 library test_reflectable.test.basic_test;
 
 import 'package:unittest/unittest.dart';
 import 'package:reflectable/reflectable.dart' as r;
 import 'package:reflectable/capability.dart';
 
 class MyReflectable extends r.Reflectable {
   const MyReflectable()
-      : super(instanceInvokeCapability, newInstanceCapability);
+      : super(instanceInvokeCapability, newInstanceCapability,
+            declarationsCapability);
 }
 
 @MyReflectable()
 class A {
   var foo;
   instanceMethod(x) => 'A:instanceMethod($x)';
   get accessor => 'A:get accessor';
   set accessor(x) {
     accessorBackingStorageA = x;
   }
+
   aMethod() => 'aMethod';
 }
 
 @MyReflectable()
 class B extends A {
   get foo => 'B:get field';
   instanceMethod(x) => 'B:instanceMethod($x)';
   get accessor => 'B:get accessor';
   set accessor(x) {
     accessorBackingStorageB = x;
   }
+
   bMethod() => 'bMethod';
 }
 
 @MyReflectable()
 class C extends B {
   set foo(x) {
     fooBackingStorageC = x;
   }
+
   instanceMethod(x) => 'C:instanceMethod($x)';
   get accessor => 'C:get accessor';
   set accessor(x) {
     accessorBackingStorageC = x;
   }
+
   cMethod() => 'cMethod';
 }
 
 List<r.DeclarationMirror> filteredDeclarationsOf(r.ClassMirror cm, predicate) {
   var result = new List();
   cm.declarations.forEach((k, v) {
     if (predicate(v)) {
       result.add(v);
     }
   });
@@ skipping 14 matching lines @@
 
 List<r.MethodMirror> gettersOf(r.ClassMirror cm) {
   return filteredDeclarationsOf(cm, (v) => v is r.MethodMirror && v.isGetter);
 }
 
 List<r.MethodMirror> settersOf(r.ClassMirror cm) {
   return filteredDeclarationsOf(cm, (v) => v is r.MethodMirror && v.isSetter);
 }
 
 List<r.MethodMirror> methodsOf(r.ClassMirror cm) {
-  return filteredDeclarationsOf(cm,
-      (v) => v is r.MethodMirror && v.isRegularMethod);
+  return filteredDeclarationsOf(
+      cm, (v) => v is r.MethodMirror && v.isRegularMethod);
 }
 
 Matcher throwsNoSuchCapabilityError = throwsA(isNoSuchCapabilityError);
 Matcher throwsNoSuchMethodError = throwsA(isNoSuchMethodError);
 Matcher isNoSuchCapabilityError = new isInstanceOf<NoSuchCapabilityError>();
 Matcher isNoSuchMethodError = new isInstanceOf<NoSuchMethodError>();
 
 main() {
   var unnamed = '';
   var foo = 'foo';
@@ skipping 75 matching lines @@
     expect(() => aM.invoke(cMethod, []), throwsNoSuchMethodError);
     expect(() => bM.invoke(cMethod, []), throwsNoSuchMethodError);
     expect(cM.invoke(cMethod, []), "cMethod");
   });
 
   test('getters and setters', () {
     expect(gettersOf(aClass).map((x) => x.simpleName), ["accessor"]);
     expect(gettersOf(bClass).map((x) => x.simpleName),
         ["accessor", "foo"].toSet());
     expect(gettersOf(cClass).map((x) => x.simpleName), ["accessor"]);
-    expect(settersOf(aClass).map((x) => x.simpleName),
-        ["accessor="]);
-    expect(settersOf(bClass).map((x) => x.simpleName),
-        ["accessor="].toSet());
+    expect(settersOf(aClass).map((x) => x.simpleName), ["accessor="]);
+    expect(settersOf(bClass).map((x) => x.simpleName), ["accessor="].toSet());
     expect(settersOf(cClass).map((x) => x.simpleName),
         ["accessor=", "foo="].toSet());
     expect(methodsOf(aClass).map((x) => x.simpleName),
         ["instanceMethod", "aMethod"].toSet());
     expect(methodsOf(bClass).map((x) => x.simpleName),
         ["instanceMethod", "bMethod"].toSet());
     expect(methodsOf(cClass).map((x) => x.simpleName),
         ["instanceMethod", "cMethod"].toSet());
   });
 }