Implement `.instanceMembers`.

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 reflectable_test.declarations_test;
 
 import "package:reflectable/reflectable.dart";
 import "package:unittest/unittest.dart";
 
 class Reflector extends Reflectable {
   // TODO(sigurdm): Include capability to reflect on constructors when
   // available.
   const Reflector() : super(instanceInvokeCapability);
 }
 
+// TODO(sigurdm): Adapt this test when we support fields.
+
 @Reflector()
 abstract class A {
   A();
   A.redirecting() : this();
   factory A.factory() {
     return new B();
   }
   const factory A.redirectingFactory() = A.c;
   const A.c();
   foo() {}
@@ skipping 10 matching lines @@
   bar() {}
   set setter2(x) => null;
   @override
   int get getter1 => 11;
   @override
   int get getter2 => 12;
 }
 
 main() {
   const reflector = const Reflector();
-  test("Test declarations", () {
-    // TODO(sigurdm): Adapt this test when we support constructors, fields,
-    // in declarations.
-    Map<String, DeclarationMirror> declarationsA =
-        reflector.reflectType(A).declarations;
-    expect(declarationsA.values
-        .where((DeclarationMirror x) => x is MethodMirror)
-        .map((x) => x.simpleName), new Set.from([
+  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(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);
     expect(foo.isSetter, isFalse);
     expect(foo.isPrivate, isFalse);
     expect(foo.isAbstract, isFalse);
     expect(foo.isConstructor, isFalse);
     expect(foo.isGenerativeConstructor, isFalse);
     expect(foo.isFactoryConstructor, isFalse);
@@ skipping 70 matching lines @@
     expect(constConstructorA.isFactoryConstructor, isFalse);
     expect(constConstructorA.isConstConstructor, isTrue);
     expect(constConstructorA.isRedirectingConstructor, isFalse);
     MethodMirror redirectingFactoryConstructorA =
         declarationsA["A.redirectingFactory"] as MethodMirror;
     expect(redirectingFactoryConstructorA.isConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isGenerativeConstructor, isFalse);
     expect(redirectingFactoryConstructorA.isFactoryConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isConstConstructor, isTrue);
     expect(redirectingFactoryConstructorA.isRedirectingConstructor, isTrue);
-    var declarationsB = reflector.reflectType(B).declarations;
-    expect(declarationsB.values
-            .where((DeclarationMirror x) => x is MethodMirror)
-            .map((x) => x.simpleName),
-        new Set.from(["bar", "getter1", "getter2", "setter2=", "B"]));
+  });
+
+  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=",
+      "+"
+    ]));
+    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=",
+      "+"
+    ]));
   });
 }