Infer types of instance methods before any other inference.

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 55 matching lines @@
 
   /**
    * The inheritance manager used to find overridden method.
    */
   final InheritanceManager inheritanceManager;
 
   /**
    * The classes that have been visited while attempting to infer the types of
    * instance members of some base class.
    */
-  HashSet<ClassElementImpl> elementsBeingInferred =
+  HashSet<ClassElementImpl> classesBeingInferred =
       new HashSet<ClassElementImpl>();
 
   /**
    * Initialize a newly create inferrer.
    */
   InstanceMemberInferrer(TypeProvider typeProvider, this.inheritanceManager,
       {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].
    */
   void inferCompilationUnit(CompilationUnitElement unit) {
     for (ClassElement classElement in unit.types) {
       try {
         _inferClass(classElement);
       } on _CycleException {
         // This is a short circuit return to prevent types that inherit from
         // types containing a circular reference from being inferred.
       }
     }
   }
 
   /**
+   * Infer types for all of the instance methods in [unit].
+   */
+  void inferInstanceMethods(CompilationUnitElement unit) {
+    for (ClassElement classElement in unit.types) {
+      try {
+        _inferClassInstanceMethods(classElement);
+      } on _CycleException {}
+    }
+  }
+
+  /**
    * Return `true` if the list of [elements] contains only methods.
    */
   bool _allSameElementKind(
       ExecutableElement element, List<ExecutableElement> elements) {
     return elements.every((e) => e.kind == element.kind);
   }
 
   /**
    * Compute the best type for the [parameter] at the given [index] that must be
    * compatible with the types of the corresponding parameters of the given
@@ skipping 81 matching lines @@
 
   /**
    * Infer type information for all of the instance members in the given
    * [classElement].
    */
   void _inferClass(ClassElement classElement) {
     if (classElement is ClassElementImpl) {
       if (classElement.hasBeenInferred) {
         return;
       }
-      if (!elementsBeingInferred.add(classElement)) {
+      if (!classesBeingInferred.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 {
         //
         // 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(_inferExecutable);
-        classElement.methods.forEach(_inferExecutable);
         //
         // Infer initializing formal parameter types. This must happen after
         // field types are inferred.
         //
         classElement.constructors.forEach(_inferConstructorFieldFormals);
         classElement.hasBeenInferred = true;
       } finally {
-        elementsBeingInferred.remove(classElement);
+        classesBeingInferred.remove(classElement);
       }
     }
   }
+
+  /**
+   * Infer types for all of the instance methods in the given [classElement].
+   */
+  void _inferClassInstanceMethods(ClassElement classElement) {
+    if (classElement is ClassElementImpl) {
+      if (classElement.hasInferredInstanceMethods) {
+        return;
+      }
+      if (!classesBeingInferred.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 {
+        //
+        // Process supertypes first.
+        //
+        void processSupertype(InterfaceType type) {
+          ClassElement element = type?.element;
+          if (element != null) {
+            _inferClassInstanceMethods(element);
+          }
+        }
+
+        processSupertype(classElement.supertype);
+        classElement.mixins.forEach(processSupertype);
+        classElement.interfaces.forEach(processSupertype);
+
+        //
+        // Then infer the types for the instance methods in this class.
+        //
+        classElement.methods.forEach(_inferExecutable);
+        classElement.hasInferredInstanceMethods = true;
+      } finally {
+        classesBeingInferred.remove(classElement);
+      }
+    }
+  }
 
   void _inferConstructorFieldFormals(ConstructorElement element) {
     for (ParameterElement p in element.parameters) {
       if (p is FieldFormalParameterElementImpl) {
         _inferFieldFormalParameter(p);
       }
     }
   }
 
   /**
@@ skipping 249 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}