Expose getInterfaceMembers method through ClassHierarchy.

pkg/kernel/test/class_hierarchy_test.dart

Index: pkg/kernel/test/class_hierarchy_test.dart
diff --git a/pkg/kernel/test/class_hierarchy_test.dart b/pkg/kernel/test/class_hierarchy_test.dart
index 2c0fbd026b3d5f7cc2fd44542fb4fa273ed76a29..6bc0aafb9d3772e60bf647ae369bb27b5ddcd12a 100644
--- a/pkg/kernel/test/class_hierarchy_test.dart
+++ b/pkg/kernel/test/class_hierarchy_test.dart
@@ -130,8 +130,9 @@ abstract class _ClassHierarchyTest {
   ClassHierarchy createClassHierarchy(Program program);
 
   Procedure newEmptyGetter(String name,
-      {DartType returnType: const DynamicType()}) {
-    var body = new Block([new ReturnStatement(new NullLiteral())]);
+      {DartType returnType: const DynamicType(), bool isAbstract: false}) {
+    var body =
+        isAbstract ? null : new Block([new ReturnStatement(new NullLiteral())]);
     return new Procedure(new Name(name), ProcedureKind.Getter,
         new FunctionNode(body, returnType: returnType));
   }
@@ -144,8 +145,8 @@ abstract class _ClassHierarchyTest {
   }
 
   Procedure newEmptySetter(String name,
-      {bool abstract: false, DartType type: const DynamicType()}) {
-    var body = abstract ? null : new Block([]);
+      {bool isAbstract: false, DartType type: const DynamicType()}) {
+    var body = isAbstract ? null : new Block([]);
     return new Procedure(
         new Name(name),
         ProcedureKind.Setter,
@@ -922,6 +923,304 @@ class C implements self::B {}
     expect(hierarchy.getInterfaceMember(c, bSetterName, setter: true), bSetter);
   }
 
+  void test_getInterfaceMembers_in_class() {
+    var method = newEmptyMethod('method');
+    var getter = newEmptyGetter('getter');
+    var setter = newEmptySetter('setter');
+    var abstractMethod = newEmptyMethod('abstractMethod', isAbstract: true);
+    var abstractGetter = newEmptyGetter('abstractGetter', isAbstract: true);
+    var abstractSetter = newEmptySetter('abstractSetter', isAbstract: true);
+    var nonFinalField = new Field(new Name('nonFinalField'));
+    var finalField = new Field(new Name('finalField'), isFinal: true);
+    var a = addClass(new Class(
+        isAbstract: true,
+        name: 'A',
+        supertype: objectSuper,
+        fields: [
+          nonFinalField,
+          finalField
+        ],
+        procedures: [
+          method,
+          getter,
+          setter,
+          abstractMethod,
+          abstractGetter,
+          abstractSetter
+        ]));
+
+    _assertTestLibraryText('''
+abstract class A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+  abstract method abstractMethod() → void;
+  get abstractGetter() → dynamic;
+  set abstractSetter(dynamic _) → void;
+}
+''');
+
+    expect(
+        hierarchy.getInterfaceMembers(a),
+        unorderedEquals([
+          method,
+          getter,
+          abstractMethod,
+          abstractGetter,
+          nonFinalField,
+          finalField
+        ]));
+    expect(hierarchy.getInterfaceMembers(a, setters: true),
+        unorderedEquals([setter, abstractSetter, nonFinalField]));
+  }
+
+  void test_getInterfaceMembers_inherited() {
+    var method = newEmptyMethod('method');
+    var getter = newEmptyGetter('getter');
+    var setter = newEmptySetter('setter');
+    var abstractMethod = newEmptyMethod('abstractMethod', isAbstract: true);
+    var abstractGetter = newEmptyGetter('abstractGetter', isAbstract: true);
+    var abstractSetter = newEmptySetter('abstractSetter', isAbstract: true);
+    var nonFinalField = new Field(new Name('nonFinalField'));
+    var finalField = new Field(new Name('finalField'), isFinal: true);
+
+    var a = addClass(new Class(name: 'A', supertype: objectSuper, fields: [
+      nonFinalField,
+      finalField
+    ], procedures: [
+      method,
+      getter,
+      setter,
+      abstractMethod,
+      abstractGetter,
+      abstractSetter
+    ]));
+    var b = addClass(new Class(name: 'B', supertype: a.asThisSupertype));
+    var c = addClass(new Class(
+        isAbstract: true,
+        name: 'C',
+        supertype: objectSuper,
+        implementedTypes: [a.asThisSupertype]));
+
+    _assertTestLibraryText('''
+class A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+  abstract method abstractMethod() → void;
+  get abstractGetter() → dynamic;
+  set abstractSetter(dynamic _) → void;
+}
+class B extends self::A {}
+abstract class C implements self::A {}
+''');
+
+    expect(
+        hierarchy.getInterfaceMembers(b),
+        unorderedEquals([

[scheglov, 2017/08/25 20:15:20]

We could extract the lists of super getters/setters and reuse for both B and C.
So, we wouldn't need to search for (not existing) differences in them.

[Paul Berry, 2017/08/25 20:56:39]

Done.

+          method,
+          getter,
+          abstractMethod,
+          abstractGetter,
+          nonFinalField,
+          finalField
+        ]));
+    expect(hierarchy.getInterfaceMembers(b, setters: true),
+        unorderedEquals([setter, abstractSetter, nonFinalField]));
+    expect(
+        hierarchy.getInterfaceMembers(c),
+        unorderedEquals([
+          method,
+          getter,
+          abstractMethod,
+          abstractGetter,
+          nonFinalField,
+          finalField
+        ]));
+    expect(hierarchy.getInterfaceMembers(c, setters: true),
+        unorderedEquals([setter, abstractSetter, nonFinalField]));
+  }
+
+  void test_getInterfaceMembers_mixed_in() {

[scheglov, 2017/08/25 20:15:20]

Do you expect that mixing-in and extends/implements will diverge, so don't want
to put it into the previous test?

[Paul Berry, 2017/08/25 20:56:39]

Good point.  I've merged it into the previous test.

+    var method = newEmptyMethod('method');
+    var getter = newEmptyGetter('getter');
+    var setter = newEmptySetter('setter');
+    var abstractMethod = newEmptyMethod('abstractMethod', isAbstract: true);
+    var abstractGetter = newEmptyGetter('abstractGetter', isAbstract: true);
+    var abstractSetter = newEmptySetter('abstractSetter', isAbstract: true);
+    var nonFinalField = new Field(new Name('nonFinalField'));
+    var finalField = new Field(new Name('finalField'), isFinal: true);
+
+    var a = addClass(new Class(name: 'A', supertype: objectSuper, fields: [
+      nonFinalField,
+      finalField
+    ], procedures: [
+      method,
+      getter,
+      setter,
+      abstractMethod,
+      abstractGetter,
+      abstractSetter
+    ]));
+    var b = addClass(new Class(
+        name: 'B', supertype: objectSuper, mixedInType: a.asThisSupertype));
+
+    _assertTestLibraryText('''
+class A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+  abstract method abstractMethod() → void;
+  get abstractGetter() → dynamic;
+  set abstractSetter(dynamic _) → void;
+}
+class B = core::Object with self::A {}
+''');
+
+    expect(
+        hierarchy.getInterfaceMembers(b),
+        unorderedEquals([
+          method,
+          getter,
+          abstractMethod,
+          abstractGetter,
+          nonFinalField,
+          finalField
+        ]));
+    expect(hierarchy.getInterfaceMembers(b, setters: true),
+        unorderedEquals([setter, abstractSetter, nonFinalField]));
+  }
+
+  void test_getInterfaceMembers_multiple() {
+    var method_a = newEmptyMethod('method');
+    var getter_a = newEmptyGetter('getter');
+    var setter_a = newEmptySetter('setter');
+    var nonFinalField_a = new Field(new Name('nonFinalField'));
+    var finalField_a = new Field(new Name('finalField'), isFinal: true);
+    var method_b = newEmptyMethod('method');
+    var getter_b = newEmptyGetter('getter');
+    var setter_b = newEmptySetter('setter');
+    var nonFinalField_b = new Field(new Name('nonFinalField'));
+    var finalField_b = new Field(new Name('finalField'), isFinal: true);
+
+    var a = addClass(new Class(
+        name: 'A',
+        supertype: objectSuper,
+        fields: [nonFinalField_a, finalField_a],
+        procedures: [method_a, getter_a, setter_a]));
+    var b = addClass(new Class(
+        name: 'B',
+        supertype: objectSuper,
+        fields: [nonFinalField_b, finalField_b],
+        procedures: [method_b, getter_b, setter_b]));
+    var c = addClass(new Class(
+        isAbstract: true,
+        name: 'C',
+        supertype: objectSuper,
+        implementedTypes: [a.asThisSupertype, b.asThisSupertype]));
+
+    _assertTestLibraryText('''
+class A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+}
+class B {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+}
+abstract class C implements self::A, self::B {}
+''');
+
+    expect(
+        hierarchy.getInterfaceMembers(c),
+        unorderedEquals([
+          method_a,
+          getter_a,
+          nonFinalField_a,
+          finalField_a,
+          method_b,
+          getter_b,
+          nonFinalField_b,
+          finalField_b
+        ]));
+    expect(
+        hierarchy.getInterfaceMembers(c, setters: true),
+        unorderedEquals(
+            [setter_a, nonFinalField_a, setter_b, nonFinalField_b]));
+  }
+
+  void test_getInterfaceMembers_shadowed() {
+    var method_a = newEmptyMethod('method');
+    var getter_a = newEmptyGetter('getter');
+    var setter_a = newEmptySetter('setter');
+    var nonFinalField_a = new Field(new Name('nonFinalField'));
+    var finalField_a = new Field(new Name('finalField'), isFinal: true);
+    var method_b = newEmptyMethod('method');
+    var getter_b = newEmptyGetter('getter');
+    var setter_b = newEmptySetter('setter');
+    var nonFinalField_b = new Field(new Name('nonFinalField'));
+    var finalField_b = new Field(new Name('finalField'), isFinal: true);
+
+    var a = addClass(new Class(
+        name: 'A',
+        supertype: objectSuper,
+        fields: [nonFinalField_a, finalField_a],
+        procedures: [method_a, getter_a, setter_a]));
+    var b = addClass(new Class(
+        name: 'B',
+        supertype: a.asThisSupertype,
+        fields: [nonFinalField_b, finalField_b],
+        procedures: [method_b, getter_b, setter_b]));
+
+    _assertTestLibraryText('''
+class A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+}
+class B extends self::A {
+  field dynamic nonFinalField;
+  final field dynamic finalField;
+  method method() → void {}
+  get getter() → dynamic {
+    return null;
+  }
+  set setter(dynamic _) → void {}
+}
+''');
+
+    expect(hierarchy.getInterfaceMembers(b),
+        unorderedEquals([method_b, getter_b, nonFinalField_b, finalField_b]));
+    expect(hierarchy.getInterfaceMembers(b, setters: true),
+        unorderedEquals([setter_b, nonFinalField_b]));

[scheglov, 2017/08/25 20:15:20]

Maybe add one non-shadowed method from A?
There is a tiny chance that the implementation replaces the denoted interface
with the class members ignoring superinterfaces. Not that we are doing this ;-)

[Paul Berry, 2017/08/25 20:56:40]

Done.

+  }
+
   void test_getOrderedClasses() {
     var a = addClass(new Class(name: 'A', supertype: objectSuper));
     var b = addClass(new Class(name: 'B', supertype: a.asThisSupertype));