Remove false positive from override hint (issue 27046)

pkg/analyzer/lib/src/dart/resolver/inheritance_manager.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.
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 10 matching lines @@
  * Instances of the class `InheritanceManager` manage the knowledge of where class members
  * (methods, getters & setters) are inherited from.
  */
 class InheritanceManager {
   /**
    * The [LibraryElement] that is managed by this manager.
    */
   LibraryElement _library;
 
   /**
+   * A flag indicating whether abstract methods should be included when looking
+   * up the superclass chain.
+   */
+  bool _includeAbstractFromSuperclasses;
+
+  /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the mixin and superclass chain.
    */
   Map<ClassElement, Map<String, ExecutableElement>> _classLookup;
 
   /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the interface set.
    */
   Map<ClassElement, Map<String, ExecutableElement>> _interfaceLookup;
 
   /**
    * A map between each visited [ClassElement] and the set of [AnalysisError]s found on
    * the class element.
    */
   Map<ClassElement, Set<AnalysisError>> _errorsInClassElement =
       new HashMap<ClassElement, Set<AnalysisError>>();
 
   /**
    * Initialize a newly created inheritance manager.
    *
    * @param library the library element context that the inheritance mappings are being generated
    */
-  InheritanceManager(LibraryElement library) {
+  InheritanceManager(LibraryElement library,
+      {bool includeAbstractFromSuperclasses: false}) {

[scheglov, 2016/08/10 01:23:38]

At some point we discussed a possible optimization when we reuse a single
InheritanceManager instance between several tasks.
Unfortunately this flag will probably makes it harder.

     this._library = library;
+    _includeAbstractFromSuperclasses = includeAbstractFromSuperclasses;
     _classLookup = new HashMap<ClassElement, Map<String, ExecutableElement>>();
     _interfaceLookup =
         new HashMap<ClassElement, Map<String, ExecutableElement>>();
   }
 
   /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
@@ skipping 209 matching lines @@
         try {
           resultMap = new Map<String, ExecutableElement>.from(
               _computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, resultMap);
           //
           // Include the members from the superclass in the resultMap.
           //
-          _recordMapWithClassMembers(resultMap, supertype, false);
+          _recordMapWithClassMembers(
+              resultMap, supertype, _includeAbstractFromSuperclasses);
         } finally {
           visitedClasses.remove(superclassElt);
         }
       } else {
         // This case happens only when the superclass was previously visited and
         // not in the lookup, meaning this is meant to shorten the compute for
         // recursive cases.
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
     }
     //
     // Include the members from the mixins in the resultMap.  If there are
     // multiple mixins, visit them in the order listed so that methods in later
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
             Map<String, ExecutableElement> map =
                 new Map<String, ExecutableElement>();
             //
             // Include the members from the mixin in the resultMap.
             //
-            _recordMapWithClassMembers(map, mixin, false);
+            _recordMapWithClassMembers(
+                map, mixin, _includeAbstractFromSuperclasses);
             //
             // Add the members from map into result map.
             //
             for (String memberName in map.keys) {
               ExecutableElement value = map[memberName];
               ClassElement definingClass = value
                   .getAncestor((Element element) => element is ClassElement);
               if (!definingClass.type.isObject) {
                 ExecutableElement existingValue = resultMap[memberName];
                 if (existingValue == null ||
@@ skipping 905 matching lines @@
   }
 
   /**
    * Initializes [keys] and [values].
    */
   void _initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }