Add the 'crossGettersSetters' flag to ClassHierarchy.forEachOverridePair().

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 111 matching lines @@
   /// [implements_] the given classes.
   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())]);
+    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}) {
+  Procedure newEmptySetter(String name,
+      {bool abstract: false, DartType type: const DynamicType()}) {
     var body = abstract ? null : new Block([]);
     return new Procedure(
         new Name(name),
         ProcedureKind.Setter,
         new FunctionNode(body,
             returnType: const VoidType(),
-            positionalParameters: [new VariableDeclaration('_')]));
+            positionalParameters: [new VariableDeclaration('_', type: type)]));
   }
 
   void setUp() {
     // Start with mock SDK libraries.
     program = createMockSdkProgram();
     coreTypes = new CoreTypes(program);
 
     // Add the test library.
     library = new Library(Uri.parse('org-dartlang:///test.dart'), name: 'test');
     library.parent = program;
     program.libraries.add(library);
   }
 
+  void test_forEachOverridePair_crossGetterSetter_super() {
+    var int = coreTypes.intClass.rawType;
+    var a = addClass(new Class(name: 'A', supertype: objectSuper, procedures: [
+      newEmptySetter('foo', type: int),
+      newEmptyGetter('bar', returnType: int)
+    ]));
+    var b = addClass(new Class(
+        name: 'B',
+        supertype: a.asThisSupertype,
+        procedures: [newEmptyGetter('foo'), newEmptySetter('bar')]));
+
+    _assertTestLibraryText('''
+class A {
+  set foo(core::int _) → void {}
+  get bar() → core::int {
+    return null;
+  }
+}
+class B extends self::A {
+  get foo() → dynamic {
+    return null;
+  }
+  set bar(dynamic _) → void {}
+}
+''');
+
+    _assertOverridePairs(b, [
+      'test::B::foo overrides test::A::foo=',
+      'test::B::bar= overrides test::A::bar'
+    ]);

[Paul Berry, 2017/06/16 22:05:11]

We should also test that if `crossGettersSetters: false` ispassed to
forEachOverridePair, no overrides are reported.

+  }
+
   /// 2. A non-abstract member is inherited from a superclass, and in the
   /// context of this class, it overrides an abstract member inheritable through
   /// one of its superinterfaces.
   void test_forEachOverridePair_supertypeOverridesInterface() {
     var a = addClass(new Class(
         name: 'A',
         supertype: objectSuper,
         procedures: [newEmptyMethod('foo'), newEmptyMethod('bar')]));
     var b = addClass(new Class(
         name: 'B',
@@ skipping 728 matching lines @@
     var b_int = new InterfaceType(b, [int]);
     expect(hierarchy.getTypeAsInstanceOf(b_int, a),
         new InterfaceType(a, [int, bool]));
     expect(hierarchy.getTypeAsInstanceOf(b_int, objectClass),
         new InterfaceType(objectClass));
   }
 
   void _assertOverridePairs(Class class_, List<String> expected) {
     List<String> overrideDescriptions = [];
     hierarchy.forEachOverridePair(class_,
-        (Member declaredMember, Member interfaceMember, bool isSetter) {
-      String declaredName = '$declaredMember${isSetter ? '=': ''}';
-      String interfaceName = '$interfaceMember${isSetter ? '=': ''}';
+        (Member declaredMember, Member interfaceMember, bool isSetter_) {

[Paul Berry, 2017/06/16 22:05:11]

We are no longer checking that forEachOverridePair() passes in the correct value
for `isSetter`.  If there are clients that rely on `isSetter`, we should keep
testing it.  If there aren't, we should remove it.

[scheglov, 2017/06/16 23:49:41]

Done.

+      String declaredSuffix = _isSetter(declaredMember) ? '=' : '';
+      String interfaceSuffix = _isSetter(interfaceMember) ? '=' : '';
+      String declaredName = '$declaredMember$declaredSuffix';
+      String interfaceName = '$interfaceMember$interfaceSuffix';
       var desc = '$declaredName overrides $interfaceName';
       overrideDescriptions.add(desc);
-    });
+    }, crossGettersSetters: true);
     expect(overrideDescriptions, unorderedEquals(expected));
   }
 
   /// Assert that the test [library] has the [expectedText] presentation.
   /// The presentation is close, but not identical to the normal Kernel one.
   void _assertTestLibraryText(String expectedText) {
     StringBuffer sb = new StringBuffer();
     Printer printer = new Printer(sb);
     printer.writeLibraryFile(library);
 
@@ skipping 12 matching lines @@
     actualText = actualText.replaceAll('{\n}', '{}');
     actualText = actualText.replaceAll(' extends core::Object', '');
 
 //    if (actualText != expectedText) {
 //      print('-------- Actual --------');
 //      print(actualText + '------------------------');
 //    }
 
     expect(actualText, expectedText);
   }
+
+  static bool _isSetter(Member member) {
+    return member is Procedure && member.kind == ProcedureKind.Setter;
+  }
 }