Issue 29398. Infer instance members using InheritanceManager of the ClassElement.

pkg/analyzer/lib/src/task/strong_mode.dart

 // Copyright (c) 2015, 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 analyzer.src.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 23 matching lines @@
 
 /**
  * Sets the type of the field. The types in implicit accessors are updated
  * implicitly, and the types of explicit accessors should be updated separately.
  */
 void setFieldType(VariableElement field, DartType newType) {
   (field as VariableElementImpl).type = newType;
 }
 
 /**
+ * A function that return the [InheritanceManager] for the class [element].
+ */
+typedef InheritanceManager InheritanceManagerProvider(ClassElement element);
+
+/**
  * A function that returns `true` if the given [element] passes the filter.
  */
 typedef bool VariableFilter(VariableElement element);
 
 /**
  * An object used to infer the type of instance fields and the return types of
  * instance methods within a single compilation unit.
  */
 class InstanceMemberInferrer {
   /**
    * The type provider used to look up types.
    */
   final TypeProvider typeProvider;
 
   /**
    * The type system used to compute the least upper bound of types.
    */
   TypeSystem typeSystem;
 
   /**
-   * The inheritance manager used to find overridden method.
+   * The provider for inheritance managers used to find overridden method.
    */
-  final InheritanceManager inheritanceManager;
+  final InheritanceManagerProvider inheritanceManagerProvider;
 
   /**
    * The set of fields for which type inference from initializer should be
    * disabled, because their initializers are not immediately-evident
    * expressions.
    */
   final Set<FieldElement> fieldsWithDisabledInitializerInference;
 
   /**
    * The classes that have been visited while attempting to infer the types of
    * instance members of some base class.
    */
   HashSet<ClassElementImpl> elementsBeingInferred =
       new HashSet<ClassElementImpl>();
 
   /**
    * Initialize a newly create inferrer.
    */
-  InstanceMemberInferrer(TypeProvider typeProvider, this.inheritanceManager,
+  InstanceMemberInferrer(
+      TypeProvider typeProvider,
+      this.inheritanceManagerProvider,
       this.fieldsWithDisabledInitializerInference,
       {TypeSystem typeSystem})
       : typeSystem = (typeSystem != null)
             ? typeSystem
             : new TypeSystemImpl(typeProvider),
         this.typeProvider = typeProvider;
 
   /**
    * Infer type information for all of the instance members in the given
    * compilation [unit].
@@ skipping 15 matching lines @@
   bool _allSameElementKind(
       ExecutableElement element, List<ExecutableElement> elements) {
     return elements.every((e) => e.kind == element.kind);
   }
 
   /**
    * Compute the inferred type for the given property [accessor]. The returned
    * value is never `null`, but might be an error, and/or have the `null` type.
    */
   _FieldOverrideInferenceResult _computeFieldOverrideType(
-      PropertyAccessorElement accessor) {
+      InheritanceManager inheritanceManager, PropertyAccessorElement accessor) {
     String name = accessor.displayName;
 
     var overriddenElements = <ExecutableElement>[];
     overriddenElements.addAll(
         inheritanceManager.lookupOverrides(accessor.enclosingElement, name));
     if (overriddenElements.isEmpty || !accessor.variable.isFinal) {
       List<ExecutableElement> overriddenSetters = inheritanceManager
           .lookupOverrides(accessor.enclosingElement, '$name=');
       overriddenElements.addAll(overriddenSetters);
     }
@@ skipping 116 matching lines @@
         return matchingParameter;
       }
     }
     return null;
   }
 
   /**
    * If the given [element] represents a non-synthetic instance property
    * accessor for which no type was provided, infer its types.
    */
-  void _inferAccessor(PropertyAccessorElement element) {
+  void _inferAccessor(
+      InheritanceManager inheritanceManager, PropertyAccessorElement element) {
     if (element.isSynthetic || element.isStatic) {
       return;
     }
 
     if (element.kind == ElementKind.GETTER && !element.hasImplicitReturnType) {
       return;
     }
 
     _FieldOverrideInferenceResult typeResult =
-        _computeFieldOverrideType(element);
+        _computeFieldOverrideType(inheritanceManager, element);
     if (typeResult.isError == null || typeResult.type == null) {
       return;
     }
 
     if (element.kind == ElementKind.GETTER) {
       (element as ExecutableElementImpl).returnType = typeResult.type;
     } else if (element.kind == ElementKind.SETTER) {
       List<ParameterElement> parameters = element.parameters;
       if (parameters.isNotEmpty) {
         var parameter = parameters[0] as ParameterElementImpl;
@@ skipping 17 matching lines @@
       }
       if (!elementsBeingInferred.add(classElement)) {
         // We have found a circularity in the class hierarchy. For now we just
         // stop trying to infer any type information for any classes that
         // inherit from any class in the cycle. We could potentially limit the
         // algorithm to only not inferring types in the classes in the cycle,
         // but it isn't clear that the results would be significantly better.
         throw new _CycleException();
       }
       try {
+        InheritanceManager inheritanceManager =
+            inheritanceManagerProvider(classElement);
         //
         // Ensure that all of instance members in the supertypes have had types
         // inferred for them.
         //
         _inferType(classElement.supertype);
         classElement.mixins.forEach(_inferType);
         classElement.interfaces.forEach(_inferType);
         //
         // Then infer the types for the members.
         //
-        classElement.fields.forEach(_inferField);
-        classElement.accessors.forEach(_inferAccessor);
-        classElement.methods.forEach(_inferExecutable);
+        classElement.fields.forEach((field) {
+          _inferField(inheritanceManager, field);
+        });
+        classElement.accessors.forEach((accessor) {
+          _inferAccessor(inheritanceManager, accessor);
+        });
+        classElement.methods.forEach((method) {
+          _inferExecutable(inheritanceManager, method);
+        });
         //
         // Infer initializing formal parameter types. This must happen after
         // field types are inferred.
         //
         classElement.constructors.forEach(_inferConstructorFieldFormals);
         classElement.hasBeenInferred = true;
       } finally {
         elementsBeingInferred.remove(classElement);
       }
     }
   }
 
   void _inferConstructorFieldFormals(ConstructorElement constructor) {
     for (ParameterElement parameter in constructor.parameters) {
       if (parameter.hasImplicitType &&
           parameter is FieldFormalParameterElementImpl) {
         FieldElement field = parameter.field;
         if (field != null) {
           parameter.type = field.type;
         }
       }
     }
   }
 
   /**
    * If the given [element] represents a non-synthetic instance method,
    * getter or setter, infer the return type and any parameter type(s) where
    * they were not provided.
    */
-  void _inferExecutable(ExecutableElement element) {
+  void _inferExecutable(
+      InheritanceManager inheritanceManager, ExecutableElement element) {
     if (element.isSynthetic || element.isStatic) {
       return;
     }
     List<ExecutableElement> overriddenElements = inheritanceManager
         .lookupOverrides(element.enclosingElement, element.displayName);
     if (overriddenElements.isEmpty ||
         !_allSameElementKind(element, overriddenElements)) {
       return;
     }
 
@@ skipping 30 matching lines @@
           }
         }
       }
     }
   }
 
   /**
    * If the given [field] represents a non-synthetic instance field for
    * which no type was provided, infer the type of the field.
    */
-  void _inferField(FieldElement field) {
+  void _inferField(InheritanceManager inheritanceManager, FieldElement field) {
     if (field.isSynthetic || field.isStatic) {
       return;
     }
 
     _FieldOverrideInferenceResult typeResult =
-        _computeFieldOverrideType(field.getter);
+        _computeFieldOverrideType(inheritanceManager, field.getter);
     if (typeResult.isError) {
       if (field is FieldElementForLink_ClassField) {
         field.setInferenceError(new TopLevelInferenceErrorBuilder(
             kind: TopLevelInferenceErrorKind.overrideConflictFieldType));
       }
       return;
     }
 
     if (field.hasImplicitType) {
       DartType newType = typeResult.type;
@@ skipping 258 matching lines @@
       AstNode parent = node.parent;
       if (parent is PropertyAccess && parent.propertyName == node ||
           parent is PrefixedIdentifier && parent.identifier == node) {
         isValid = false;
       }
     } else if (element is PropertyAccessorElement && !element.isStatic) {
       isValid = false;
     }
   }
 }