Infer setter parameter types in strong mode

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 213 matching lines @@
     }
     //
     // Then return the type of the parameter.
     //
     return matchingParameter == null
         ? typeProvider.dynamicType
         : matchingParameter.type;
   }
 
   /**
-   * 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) {
-      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)) {
-          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) {
       if (classElement.hasBeenInferred) {
         return;
       }
       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 {
         //
         // 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(_inferMethod);
+        classElement.accessors.forEach(_inferExecutable);
+        classElement.methods.forEach(_inferExecutable);
         classElement.hasBeenInferred = true;
       } finally {
         elementsBeingInferred.remove(classElement);
       }
     }
   }
 
   /**
    * If the given [fieldElement] represents a non-synthetic instance field for
    * which no type was provided, infer the type of the field.
@@ skipping 32 matching lines @@
       }
       (fieldElement as FieldElementImpl).type = newType;
       setReturnType(fieldElement.getter, newType);
       if (!fieldElement.isFinal && !fieldElement.isConst) {
         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.
+   * 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 _inferMethod(MethodElement methodElement) {
-    if (methodElement.isSynthetic || methodElement.isStatic) {
+  void _inferExecutable(ExecutableElement element) {
+    if (element.isSynthetic || element.isStatic) {
       return;
     }
     List<ExecutableElement> overriddenMethods = null;
     //
     // Infer the return type.
     //
-    if (methodElement.hasImplicitReturnType) {
+    if (element.hasImplicitReturnType) {
       overriddenMethods = inheritanceManager.lookupOverrides(
-          methodElement.enclosingElement, methodElement.name);
-      if (overriddenMethods.isEmpty || !_onlyMethods(overriddenMethods)) {
+          element.enclosingElement, element.name);
+      if (overriddenMethods.isEmpty ||
+          !_allSameElementKind(element, overriddenMethods)) {
         return;
       }
-      MethodElementImpl element = methodElement as MethodElementImpl;
       setReturnType(element, _computeReturnType(overriddenMethods));
+      if (element is PropertyAccessorElement) {
+        _updateSyntheticVariableType(element);
+      }
     }
     //
     // Infer the parameter types.
     //
-    List<ParameterElement> parameters = methodElement.parameters;
+    List<ParameterElement> parameters = element.parameters;
     int length = parameters.length;
     for (int i = 0; i < length; ++i) {
       ParameterElement parameter = parameters[i];
       if (parameter is ParameterElementImpl && parameter.hasImplicitType) {
         if (overriddenMethods == null) {
           overriddenMethods = inheritanceManager.lookupOverrides(
-              methodElement.enclosingElement, methodElement.name);
+              element.enclosingElement, element.name);
         }
-        if (overriddenMethods.isEmpty || !_onlyMethods(overriddenMethods)) {
+        if (overriddenMethods.isEmpty ||
+            !_allSameElementKind(element, overriddenMethods)) {
           return;
         }
         parameter.type = _computeParameterType(parameter, i, overriddenMethods);
+        if (element is PropertyAccessorElement) {
+          _updateSyntheticVariableType(element);
+        }
       }
     }
   }
 
   /**
+   * If the given [element] is a non-synthetic getter or setter, update its
+   * synthetic variable's type to match the getter's return type, or if no
+   * corresponding getter exists, use the setter's parameter type.
+   *
+   * In general, the type of the synthetic variable should not be used, because
+   * getters and setters are independent methods. But this logic matches what
+   * `TypeResolverVisitor.visitMethodDeclaration` would fill in there.
+   */
+  void _updateSyntheticVariableType(PropertyAccessorElement element) {
+    assert(!element.isSynthetic);
+    PropertyAccessorElement getter = element;
+    if (element.isSetter) {
+      // See if we can find any getter.
+      getter = element.correspondingGetter;
+    }
+    DartType newType;
+    if (getter != null) {
+      newType = getter.returnType;
+    } else if (element.isSetter && element.parameters.isNotEmpty) {
+      newType = element.parameters[0].type;
+    }
+    if (newType != null) {
+      (element.variable as VariableElementImpl).type = newType;
+    }
+  }
+
+  /**
    * Infer type information for all of the instance members in the given
    * interface [type].
    */
   void _inferType(InterfaceType type) {
     if (type != null) {
       ClassElement element = type.element;
       if (element != null) {
         _inferClass(element);
       }
     }
@@ skipping 21 matching lines @@
       if (!(element is PropertyAccessorElement && element.isGetter)) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Return `true` if the list of [elements] contains only methods.
    */
-  bool _onlyMethods(List<ExecutableElement> elements) {
-    for (ExecutableElement element in elements) {
-      if (element is! MethodElement) {
-        return false;
-      }
-    }
-    return true;
+  bool _allSameElementKind(
+      ExecutableElement element, List<ExecutableElement> elements) {
+    return elements.every((e) => e.kind == element.kind);
   }
 }
 
 /**
  * A visitor that will gather all of the variables referenced within a given
  * AST structure. The collection can be restricted to contain only those
  * variables that pass a specified filter.
  */
 class VariableGatherer extends RecursiveAstVisitor {
   /**
@@ skipping 24 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}