Remove some order dependency in instance member 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/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 268 matching lines @@
   }
 
   /**
    * If the given [accessorElement] represents a non-synthetic instance getter
    * for which no return type was provided, infer the return type of the getter.
    */
   void _inferAccessor(PropertyAccessorElement accessorElement) {
     if (!accessorElement.isSynthetic &&
         accessorElement.isGetter &&
         !accessorElement.isStatic &&
-        accessorElement.hasImplicitReturnType &&
-        _getReturnType(accessorElement).isDynamic) {
+        accessorElement.hasImplicitReturnType) {
       List<ExecutableElement> overriddenGetters = inheritanceManager
           .lookupOverrides(
               accessorElement.enclosingElement, accessorElement.name);
       if (overriddenGetters.isNotEmpty && _onlyGetters(overriddenGetters)) {
         DartType newType = _computeReturnType(overriddenGetters);
         List<ExecutableElement> overriddenSetters = inheritanceManager
             .lookupOverrides(
                 accessorElement.enclosingElement, accessorElement.name + '=');
         PropertyAccessorElement setter = (accessorElement.enclosingElement
             as ClassElement).getSetter(accessorElement.name);
         if (setter != null) {
           overriddenSetters.add(setter);
         }
-        if (_isCompatible(newType, overriddenSetters)) {
-          _setReturnType(accessorElement, newType);
-          (accessorElement.variable as FieldElementImpl).type = newType;
+        if (!_isCompatible(newType, overriddenSetters)) {
+          newType = typeProvider.dynamicType;
         }
+        _setReturnType(accessorElement, newType);
+        (accessorElement.variable as FieldElementImpl).type = newType;
       }
     }
   }
 
   /**
    * Infer type information for all of the instance members in the given
    * [classElement].
    */
   void _inferClass(ClassElement classElement) {
     if (classElement is ClassElementImpl) {
@@ skipping 29 matching lines @@
     }
   }
 
   /**
    * If the given [fieldElement] represents a non-synthetic instance field for
    * which no type was provided, infer the type of the field.
    */
   void _inferField(FieldElement fieldElement) {
     if (!fieldElement.isSynthetic &&
         !fieldElement.isStatic &&
-        fieldElement.hasImplicitType &&
-        fieldElement.type.isDynamic) {
+        fieldElement.hasImplicitType) {
       //
       // First look for overridden getters with the same name as the field.
       //
       List<ExecutableElement> overriddenGetters = inheritanceManager
           .lookupOverrides(fieldElement.enclosingElement, fieldElement.name);
       DartType newType = null;
       if (overriddenGetters.isNotEmpty && _onlyGetters(overriddenGetters)) {
         newType = _computeReturnType(overriddenGetters);
         List<ExecutableElement> overriddenSetters = inheritanceManager
             .lookupOverrides(
                 fieldElement.enclosingElement, fieldElement.name + '=');
         if (!_isCompatible(newType, overriddenSetters)) {
           newType = null;
         }
       }
       //
       // Then, if none was found, infer the type from the initialization
       // expression.
       //
       if (newType == null) {
         if (fieldElement.initializer != null &&
             (fieldElement.isFinal || overriddenGetters.isEmpty)) {
           newType = fieldElement.initializer.returnType;
         }
       }
-      if (newType != null && !newType.isBottom) {
-        (fieldElement as FieldElementImpl).type = newType;
-        _setReturnType(fieldElement.getter, newType);
-        _setParameterType(fieldElement.setter, newType);
+      if (newType == null || newType.isBottom) {
+        newType = typeProvider.dynamicType;
       }
+      (fieldElement as FieldElementImpl).type = newType;
+      _setReturnType(fieldElement.getter, newType);
+      _setParameterType(fieldElement.setter, newType);
     }
   }
 
   /**
    * If the given [methodElement] represents a non-synthetic instance method
    * for which no return type was provided, infer the return type of the method.
    */
   void _inferMethod(MethodElement methodElement) {
     if (methodElement.isSynthetic || methodElement.isStatic) {
       return;
     }
     List<ExecutableElement> overriddenMethods = null;
     //
     // Infer the return type.
     //
-    if (methodElement.hasImplicitReturnType &&
-        _getReturnType(methodElement).isDynamic) {
+    if (methodElement.hasImplicitReturnType) {
       overriddenMethods = inheritanceManager.lookupOverrides(
           methodElement.enclosingElement, methodElement.name);
       if (overriddenMethods.isEmpty || !_onlyMethods(overriddenMethods)) {
         return;
       }
       MethodElementImpl element = methodElement as MethodElementImpl;
       _setReturnType(element, _computeReturnType(overriddenMethods));
     }
     //
     // Infer the parameter types.
     //
     List<ParameterElement> parameters = methodElement.parameters;
     var length = parameters.length;
     for (int i = 0; i < length; ++i) {
       ParameterElement parameter = parameters[i];
-      if (parameter.hasImplicitType && parameter.type.isDynamic) {
+      if (parameter is ParameterElementImpl && parameter.hasImplicitType) {
         overriddenMethods = overriddenMethods ??
             inheritanceManager.lookupOverrides(
                 methodElement.enclosingElement, methodElement.name);
         if (overriddenMethods.isEmpty || !_onlyMethods(overriddenMethods)) {
           return;
         }
-        DartType type = _computeParameterType(parameter, i, overriddenMethods);
-        if (!type.isDynamic) {
-          if (parameter is ParameterElementImpl) {
-            parameter.type = type;
-          }
-        }
+        parameter.type = _computeParameterType(parameter, i, overriddenMethods);
       }
     }
   }
 
   /**
    * Infer type information for all of the instance members in the given
    * interface [type].
    */
   void _inferType(InterfaceType type) {
     if (type != null) {
@@ skipping 81 matching lines @@
             new FunctionTypeImpl(element, functionType.prunedTypedefs);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}