Fix type inference of getters that "override" setters and vice versa.

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 97 matching lines @@
   /// 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.
   ///
   /// By default getters and setters are overridden separately.  The [isSetter]
   /// callback parameter determines which type of access is being overridden.
+  void forEachOverridePair(Class class_,
+      callback(Member declaredMember, Member interfaceMember, bool isSetter));
+
+  /// Invokes [callback] for every function, field, or getter declared in
+  /// [class_] that has a corresponding setter in a supertype of [class_], and
+  /// for every setter or non-final field declared in [class_] that has a
+  /// corresponding function, field, or getter in a supertype of [class_].
   ///
-  /// 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),
-      {bool crossGettersSetters: false});
+  /// We use the term "inheritable" for members that are candidates for
+  /// inheritance but may have been overridden.  The "declared" members of a
+  /// mixin application are those declared in the mixed-in type. The callback is
+  /// invoked in the following case:
+  ///
+  /// A member declared in the class overrides a member inheritable through
+  /// one of the supertypes of the 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.
+  ///
+  /// By default getters and setters are overridden separately.  The [isSetter]

[scheglov, 2017/06/26 20:29:12]

"By default getters and setters are overridden separately." does not seem useful
here.
This method is exactly for crossing getters and setters.

[Paul Berry, 2017/06/27 20:53:30]

Thanks!  https://codereview.chromium.org/2960033002/ should address this.

+  /// callback parameter corresponds to whether [declaredMember] is a setter.
+  void forEachCrossOverridePair(Class class_,
+      callback(Member declaredMember, Member interfaceMember, bool isSetter));
 
   /// 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 254 matching lines @@
       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.
       _reportOverrides(info.implementedGettersAndCalls,
           info.declaredGettersAndCalls, callback);
       _reportOverrides(info.implementedSetters, info.declaredSetters, callback,
           isSetter: true);
     }
   }
 
+  @override
+  void forEachCrossOverridePair(Class class_,
+      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.declaredGettersAndCalls, superSetters, callback);
+      _reportOverrides(info.declaredSetters, superGetters, callback,
+          isSetter: true);
+    }
+  }
+
   static void _reportOverrides(
       List<Member> declaredList,
       List<Member> inheritedList,
       callback(Member declaredMember, Member interfaceMember, bool isSetter),
       {bool isSetter: false,
       bool onlyAbstract: false}) {
     int i = 0, j = 0;
     while (i < declaredList.length && j < inheritedList.length) {
       Member declared = declaredList[i];
       if (onlyAbstract && !declared.isAbstract) {
@@ skipping 710 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;
   }
 }