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_extends() {
+    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 {}
+}
+''');
+
+    // No overrides of getters with getters, or setters with setters.
+    _assertOverridePairs(b, []);
+
+    // Has cross-overrides between getters and setters.
+    _assertOverridePairs(
+        b,
+        [
+          'test::B::foo overrides test::A::foo=',
+          'test::B::bar= overrides test::A::bar'
+        ],
+        crossGettersSetters: true);
+  }
+
+  void test_forEachOverridePair_crossGetterSetter_implements() {
+    var int = coreTypes.intClass.rawType;
+    var double = coreTypes.doubleClass.rawType;
+    var a = addClass(new Class(name: 'A', supertype: objectSuper, procedures: [
+      newEmptySetter('foo', type: int),
+    ]));
+    var b = addClass(new Class(name: 'B', supertype: objectSuper, procedures: [
+      newEmptySetter('foo', type: double),
+    ]));
+    var c = addClass(new Class(
+        name: 'C',
+        supertype: objectSuper,
+        implementedTypes: [a.asThisSupertype, b.asThisSupertype],
+        procedures: [newEmptyGetter('foo')]));
+
+    _assertTestLibraryText('''
+class A {
+  set foo(core::int _) → void {}
+}
+class B {
+  set foo(core::double _) → void {}
+}
+class C implements self::A, self::B {
+  get foo() → dynamic {
+    return null;
+  }
+}
+''');
+
+    // No overrides of getters with getters, or setters with setters.
+    _assertOverridePairs(c, []);
+
+    // Has cross-overrides between getters and setters.
+    // Even if these overrides are incompatible with each other.
+    _assertOverridePairs(
+        c,
+        [
+          'test::C::foo overrides test::A::foo=',
+          'test::C::foo overrides test::B::foo=',
+        ],
+        crossGettersSetters: true);
+  }
+
   /// 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 725 matching lines @@
 class B<T> extends self::A<self::B::T, core::bool> {}
 ''');
 
     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) {
+  void _assertOverridePairs(Class class_, List<String> expected,
+      {bool crossGettersSetters: false}) {
     List<String> overrideDescriptions = [];
     hierarchy.forEachOverridePair(class_,
         (Member declaredMember, Member interfaceMember, bool isSetter) {
-      String declaredName = '$declaredMember${isSetter ? '=': ''}';
-      String interfaceName = '$interfaceMember${isSetter ? '=': ''}';
+      String declaredSuffix;
+      String interfaceSuffix;
+      if (crossGettersSetters) {
+        declaredSuffix = _isSetter(declaredMember) ? '=' : '';
+        interfaceSuffix = _isSetter(interfaceMember) ? '=' : '';
+      } else {
+        declaredSuffix = isSetter ? '=' : '';
+        interfaceSuffix = isSetter ? '=' : '';
+      }
+      String declaredName = '$declaredMember$declaredSuffix';
+      String interfaceName = '$interfaceMember$interfaceSuffix';
       var desc = '$declaredName overrides $interfaceName';
       overrideDescriptions.add(desc);
-    });
+    }, crossGettersSetters: crossGettersSetters);
     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);
 
     String actualText = sb.toString();
 
     // Clean up the text a bit.
     const oftenUsedPrefix = '''
 library test;
 import self as self;
 import "dart:core" as core;
 
 ''';
     if (actualText.startsWith(oftenUsedPrefix)) {
       actualText = actualText.substring(oftenUsedPrefix.length);
     }
     actualText = actualText.replaceAll('{\n}', '{}');
     actualText = actualText.replaceAll(' extends core::Object', '');
 
-//    if (actualText != expectedText) {
-//      print('-------- Actual --------');
-//      print(actualText + '------------------------');
-//    }
+    if (actualText != expectedText) {
+      print('-------- Actual --------');
+      print(actualText + '------------------------');
+    }
 
     expect(actualText, expectedText);
   }
+
+  static bool _isSetter(Member member) {
+    return member is Procedure && member.kind == ProcedureKind.Setter;
+  }
 }