Expose getInterfaceMembers method through ClassHierarchy.

pkg/kernel/test/class_hierarchy_test.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/src/incremental_class_hierarchy.dart';
 import 'package:kernel/testing/mock_sdk_program.dart';
 import 'package:kernel/text/ast_to_text.dart';
@@ skipping 112 matching lines @@
   Class addImplementsClass(String name, List<Class> implements_) {
     return addClass(new Class(
         name: name,
         supertype: objectSuper,
         implementedTypes: implements_.map((c) => c.asThisSupertype).toList()));
   }
 
   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));
   }
 
   Procedure newEmptyMethod(String name, {bool isAbstract: false}) {
     var body = isAbstract ? null : new Block([]);
     return new Procedure(new Name(name), ProcedureKind.Method,
         new FunctionNode(body, returnType: const VoidType()),
         isAbstract: isAbstract);
   }
 
   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,
         new FunctionNode(body,
             returnType: const VoidType(),
             positionalParameters: [new VariableDeclaration('_', type: type)]));
   }
 
   void setUp() {
     // Start with mock SDK libraries.
@@ skipping 756 matching lines @@
     expect(hierarchy.getInterfaceMember(b, aMethodName), aMethod);
     expect(hierarchy.getInterfaceMember(b, bMethodName), bMethod);
     expect(hierarchy.getInterfaceMember(b, aSetterName, setter: true), aSetter);
     expect(hierarchy.getInterfaceMember(b, bSetterName, setter: true), bSetter);
     expect(hierarchy.getInterfaceMember(c, aMethodName), aMethod);
     expect(hierarchy.getInterfaceMember(c, bMethodName), bMethod);
     expect(hierarchy.getInterfaceMember(c, aSetterName, setter: true), aSetter);
     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));
     var c = addClass(new Class(name: 'C', supertype: b.asThisSupertype));
 
     void assertOrderOfClasses(List<Class> unordered, List<Class> expected) {
       var ordered = hierarchy.getOrderedClasses(unordered);
       expect(ordered, expected);
     }
 
@@ skipping 107 matching lines @@
     actualText = actualText.replaceAll(' extends core::Object', '');
 
     if (actualText != expectedText) {
       print('-------- Actual --------');
       print(actualText + '------------------------');
     }
 
     expect(actualText, expectedText);
   }
 }