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

pkg/kernel/lib/class_hierarchy.dart

 // Copyright (c) 2016, 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.
 library kernel.class_hierarchy;
 
 import 'ast.dart';
 import 'dart:math';
 import 'dart:typed_data';
 import 'src/heap.dart';
 import 'type_algebra.dart';
@@ skipping 95 matching lines @@
   ///
   /// 3. A non-abstract member is inherited from a superclass, and it overrides
   /// an abstract member declared in this class.
   ///
   /// This method will not report that a member overrides itself. A given pair
   /// may be reported multiple times when there are multiple inheritance paths
   /// to the overridden member.
   ///
   /// It is possible for two methods to override one another in both directions.
   ///
-  /// Getters and setters are overridden separately.  The [isSetter] callback
-  /// parameter determines which type of access is being overridden.
+  /// By default getters and setters are overridden separately.  The [isSetter]
+  /// callback parameter determines which type of access is being overridden.
+  ///
+  /// However if [crossGettersSetters] is set to `true`, getters might be
+  /// reported as overriding setters, and vice versa - setter overriding
+  /// getters.  The callback should check the [Procedure.kind] property.
   void forEachOverridePair(Class class_,
-      callback(Member declaredMember, Member interfaceMember, bool isSetter));
+      callback(Member declaredMember, Member interfaceMember, bool isSetter),
+      {bool crossGettersSetters: false});
 
   /// This method is invoked by the client after it changed the [classes], and
   /// some of the information that this hierarchy might have cached, is not
   /// valid anymore. The hierarchy may perform required updates and return the
   /// same instance, or return a new instance.
   ClassHierarchy applyChanges(Iterable<Class> classes);
 }
 
 /// Implementation of [ClassHierarchy] for closed world.
 class ClosedWorldClassHierarchy implements ClassHierarchy {
@@ skipping 240 matching lines @@
   /// when members are inherited through different supertypes and not overridden
   /// in the class.
   ///
   /// Also see [getInterfaceMember].
   List<Member> getInterfaceMembers(Class class_, {bool setters: false}) {
     return _buildInterfaceMembers(class_, _infoFor[class_], setters: setters);
   }
 
   @override
   void forEachOverridePair(Class class_,
-      callback(Member declaredMember, Member interfaceMember, bool isSetter)) {
+      callback(Member declaredMember, Member interfaceMember, bool isSetter),
+      {bool crossGettersSetters: false}) {
     _ClassInfo info = _infoFor[class_];
     for (var supertype in class_.supers) {
       var superclass = supertype.classNode;
       var superGetters = getInterfaceMembers(superclass);
       var superSetters = getInterfaceMembers(superclass, setters: true);
       _reportOverrides(info.implementedGettersAndCalls, superGetters, callback);
       _reportOverrides(info.declaredGettersAndCalls, superGetters, callback,
           onlyAbstract: true);
       _reportOverrides(info.implementedSetters, superSetters, callback,
           isSetter: true);
       _reportOverrides(info.declaredSetters, superSetters, callback,
           isSetter: true, onlyAbstract: true);
+      if (crossGettersSetters) {
+        _reportOverrides(info.declaredGettersAndCalls, superSetters, callback);
+        _reportOverrides(info.declaredSetters, superGetters, callback);
+      }
     }
     if (!class_.isAbstract) {
       // If a non-abstract class declares an abstract method M whose
       // implementation M' is inherited from the superclass, then the inherited
       // method M' overrides the declared method M.
       // This flies in the face of conventional override logic, but is necessary
       // because an instance of the class will contain the method M' which can
       // be invoked through the interface of M.
       // Note that [_reportOverrides] does not report self-overrides, so in
       // most cases these calls will just scan both lists and report nothing.
@@ skipping 727 matching lines @@
 class _LubHeap extends Heap<_ClassInfo> {
   @override
   bool sortsBefore(_ClassInfo a, _ClassInfo b) => sortsBeforeStatic(a, b);
 
   static bool sortsBeforeStatic(_ClassInfo a, _ClassInfo b) {
     if (a.depth > b.depth) return true;
     if (a.depth < b.depth) return false;
     return a.topologicalIndex < b.topologicalIndex;
   }
 }