Implement `.instanceMembers`.

test_reflectable/test/declarations_test.dart

Index: test_reflectable/test/declarations_test.dart
diff --git a/test_reflectable/test/declarations_test.dart b/test_reflectable/test/declarations_test.dart
index 3962dd00e632f3a1a9813f22339cd468592f9655..e76bd7562618dadb8feb71e6567cbd606c761101 100644
--- a/test_reflectable/test/declarations_test.dart
+++ b/test_reflectable/test/declarations_test.dart
@@ -8,29 +8,172 @@ 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(invokeMembersCapability);
 }
 
+// TODO(sigurdm): Adapt this test when we support fields.
+
 @Reflector()
-class A {
+abstract class A {
+  A();
+  A.redirecting() : this();
+  factory A.factory() {
+    return new B();
+  }
+  const factory A.redirectingFactory() = A.c;
+  const A.c();
   foo() {}
+  int get getter1 => 10;
+  int get getter2;
+  set setter1(x) => null;
+  operator +(Object other) {
+    return this;
+  }
 }
 
 @Reflector()
 class B extends A {
   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,
-    // getters and setters in declarations.
-    expect(reflector.reflectType(A).declarations.values
-        .where((DeclarationMirror x) => x is MethodMirror && x.isRegularMethod)
-        .map((x) => x.simpleName), ["foo"]);
-    expect(reflector.reflectType(B).declarations.values
-        .where((DeclarationMirror x) => x is MethodMirror && x.isRegularMethod)
-        .map((x) => x.simpleName), ["bar"]);
+  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",
+      "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);
+    expect(foo.isConstConstructor, isFalse);
+    expect(foo.isRedirectingConstructor, isFalse);
+    expect(foo.isOperator, isFalse);
+    expect(foo.isSynthetic, isFalse);
+    expect(foo.isTopLevel, isFalse);
+    MethodMirror setter1 = declarationsA["setter1="] as MethodMirror;
+    expect(setter1.isRegularMethod, isFalse);
+    expect(setter1.isStatic, isFalse);
+    expect(setter1.isGetter, isFalse);
+    expect(setter1.isSetter, isTrue);
+    expect(setter1.isPrivate, isFalse);
+    expect(setter1.isAbstract, isFalse);
+    expect(setter1.isOperator, isFalse);
+    expect(setter1.isSynthetic, isFalse);
+    MethodMirror operatorPlus = declarationsA["+"] as MethodMirror;
+    expect(operatorPlus.isRegularMethod, isTrue);
+    expect(operatorPlus.isStatic, isFalse);
+    expect(operatorPlus.isGetter, isFalse);
+    expect(operatorPlus.isSetter, isFalse);
+    expect(operatorPlus.isPrivate, isFalse);
+    expect(operatorPlus.isAbstract, isFalse);
+    expect(operatorPlus.isConstructor, isFalse);
+    expect(operatorPlus.isOperator, isTrue);
+    MethodMirror constructorA = declarationsA["A"] as MethodMirror;
+    expect(constructorA.isRegularMethod, isFalse);
+    expect(constructorA.isStatic, isFalse);
+    expect(constructorA.isGetter, isFalse);
+    expect(constructorA.isSetter, isFalse);
+    expect(constructorA.isPrivate, isFalse);
+    expect(constructorA.isAbstract, isFalse);
+    expect(constructorA.isConstructor, isTrue);
+    expect(constructorA.isGenerativeConstructor, isTrue);
+    expect(constructorA.isFactoryConstructor, isFalse);
+    expect(constructorA.isConstConstructor, isFalse);
+    expect(constructorA.isRedirectingConstructor, isFalse);
+    expect(constructorA.isOperator, isFalse);
+    expect(constructorA.isSynthetic, isFalse);
+    expect(constructorA.isTopLevel, isFalse);
+    MethodMirror redirectingConstructorA =
+        declarationsA["A.redirecting"] as MethodMirror;
+    expect(redirectingConstructorA.isConstructor, isTrue);
+    expect(redirectingConstructorA.isGenerativeConstructor, isTrue);
+    expect(redirectingConstructorA.isFactoryConstructor, isFalse);
+    expect(redirectingConstructorA.isConstConstructor, isFalse);
+    expect(redirectingConstructorA.isRedirectingConstructor, isTrue);
+    MethodMirror factoryConstructorA =
+        declarationsA["A.factory"] as MethodMirror;
+    expect(factoryConstructorA.isConstructor, isTrue);
+    expect(factoryConstructorA.isGenerativeConstructor, isFalse);
+    expect(factoryConstructorA.isFactoryConstructor, isTrue);
+    expect(factoryConstructorA.isConstConstructor, isFalse);
+    expect(factoryConstructorA.isRedirectingConstructor, isFalse);
+    MethodMirror constConstructorA = declarationsA["A.c"] as MethodMirror;
+    expect(constConstructorA.isConstructor, isTrue);
+    expect(constConstructorA.isGenerativeConstructor, isTrue);
+    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);
+  });
+
+  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=",
+      "+"
+    ]));
   });
 }