Infer fields/getters/setters types according to the new top-level inference rules.

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 11 matching lines @@
  * Return `true` if the given [expression] is an immediately-evident expression,
  * so can be used to infer the type for a top-level variable or a class field.
  */
 bool isValidForTypeInference(Expression expression) {
   var visitor = new _IsValidForTypeInferenceVisitor();
   expression.accept(visitor);
   return visitor.isValid;
 }
 
 /**
- * Sets the type of the field. This is stored in the field itself, and the
- * synthetic getter/setter types.
+ * 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;
-  if (field.initializer != null) {
-    (field.initializer as ExecutableElementImpl).returnType = newType;
-  }
 }
 
 /**
- * Return the element for the single parameter of the given [setter], or `null`
- * if the executable element is not a setter or does not have a single
- * parameter.
- */
-ParameterElement _getParameter(ExecutableElement setter) {
-  if (setter is PropertyAccessorElement && setter.isSetter) {
-    List<ParameterElement> parameters = setter.parameters;
-    if (parameters.length == 1) {
-      return parameters[0];
-    }
-  }
-  return null;
-}
-
-/**
  * 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 {
   /**
@@ skipping 53 matching lines @@
 
   /**
    * 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 inferred type for the given property accessor [element]. The
+   * returned value is never `null`, but might be an error, and/or have the
+   * `null` type.
+   */
+  _FieldOverrideInferenceResult _computeFieldOverrideType(
+      ExecutableElement element) {
+    String name = element.displayName;
+
+    var overriddenElements = <ExecutableElement>[];
+    overriddenElements.addAll(
+        inheritanceManager.lookupOverrides(element.enclosingElement, name));
+    overriddenElements.addAll(
+        inheritanceManager.lookupOverrides(element.enclosingElement, '$name='));
+
+    bool isCovariant = false;
+    DartType impliedType;
+    for (ExecutableElement overriddenElement in overriddenElements) {
+      FunctionType overriddenType =
+          _toOverriddenFunctionType(element, overriddenElement);
+      if (overriddenType == null) {
+        return new _FieldOverrideInferenceResult(false, null, true);
+      }
+
+      DartType type;
+      if (overriddenElement.kind == ElementKind.GETTER) {
+        type = overriddenType.returnType;
+      } else if (overriddenElement.kind == ElementKind.SETTER) {
+        if (overriddenType.parameters.length == 1) {
+          ParameterElement parameter = overriddenType.parameters[0];
+          type = parameter.type;
+          isCovariant = isCovariant || parameter.isCovariant;
+        }
+      } else {
+        return new _FieldOverrideInferenceResult(false, null, true);
+      }
+
+      if (impliedType == null) {
+        impliedType = type;
+      } else if (type != impliedType) {
+        return new _FieldOverrideInferenceResult(false, null, true);
+      }
+    }
+
+    return new _FieldOverrideInferenceResult(isCovariant, impliedType, false);
+  }
+
+  /**
    * 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
-   * [overriddenMethods].
+   * [overriddenTypes].
    *
    * At the moment, this method will only return a type other than 'dynamic' if
    * the types of all of the parameters are the same. In the future we might
    * want to be smarter about it, such as by returning the least upper bound of
    * the parameter types.
    */
   DartType _computeParameterType(ParameterElement parameter, int index,
       List<FunctionType> overriddenTypes) {
     DartType parameterType = null;
     int length = overriddenTypes.length;
     for (int i = 0; i < length; i++) {
-      ParameterElement matchingParam = _getCorrespondingParameter(
+      ParameterElement matchingParameter = _getCorrespondingParameter(
           parameter, index, overriddenTypes[i].parameters);
-      var type = matchingParam?.type ?? typeProvider.dynamicType;
+      DartType type = matchingParameter?.type ?? typeProvider.dynamicType;
       if (parameterType == null) {
         parameterType = type;
       } else if (parameterType != type) {
         return typeProvider.dynamicType;
       }
     }
     return parameterType ?? typeProvider.dynamicType;
   }
 
   /**
@@ skipping 48 matching lines @@
     if (index < methodParameters.length) {
       var matchingParameter = methodParameters[index];
       if (matchingParameter.parameterKind != ParameterKind.NAMED) {
         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) {
+    if (element.isSynthetic || element.isStatic) {
+      return;
+    }
+
+    if (element.kind == ElementKind.GETTER && !element.hasImplicitReturnType) {
+      return;
+    }
+
+    _FieldOverrideInferenceResult typeResult =
+        _computeFieldOverrideType(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) {
+      var parameter = element.parameters[0] as ParameterElementImpl;
+      if (parameter.hasImplicitType) {
+        parameter.type = typeResult.type;
+      }
+      parameter.inheritsCovariant = typeResult.isCovariant;
+    }
+    setFieldType(element.variable, typeResult.type);
+  }
+
+  /**
    * 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(_inferExecutable);
+        classElement.accessors.forEach(_inferAccessor);
         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);
       }
     }
   }
 
-  void _inferConstructorFieldFormals(ConstructorElement element) {
-    for (ParameterElement p in element.parameters) {
-      if (p is FieldFormalParameterElementImpl) {
-        _inferFieldFormalParameter(p);
+  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) {
     if (element.isSynthetic || element.isStatic) {
       return;
     }
-    List<ExecutableElement> overriddenMethods = inheritanceManager
-        .lookupOverrides(element.enclosingElement, element.name);
-    if (overriddenMethods.isEmpty ||
-        !_allSameElementKind(element, overriddenMethods)) {
+    List<ExecutableElement> overriddenElements = inheritanceManager
+        .lookupOverrides(element.enclosingElement, element.displayName);
+    if (overriddenElements.isEmpty ||
+        !_allSameElementKind(element, overriddenElements)) {
+      return;
+    }
+
+    List<FunctionType> overriddenTypes =
+        _toOverriddenFunctionTypes(element, overriddenElements);
+    if (overriddenTypes.isEmpty) {
       return;
     }
 
     //
-    // Overridden methods must have the same number of generic type parameters
-    // as this method, or none.
-    //
-    // If we do have generic type parameters on the element we're inferring,
-    // we must express its parameter and return types in terms of its own
-    // parameters. For example, given `m<T>(t)` overriding `m<S>(S s)` we
-    // should infer this as `m<T>(T t)`.
-    //
-    List<DartType> typeFormals =
-        TypeParameterTypeImpl.getTypes(element.type.typeFormals);
-
-    List<FunctionType> overriddenTypes = new List<FunctionType>();
-    for (ExecutableElement overriddenMethod in overriddenMethods) {
-      FunctionType overriddenType = overriddenMethod.type;
-      if (overriddenType == null) {
-        // TODO(brianwilkerson) I think the overridden method should always have
-        // a type, but there appears to be a bug that causes it to sometimes be
-        // null, we guard against that case by not performing inference.
-        return;
-      }
-      if (overriddenType.typeFormals.isNotEmpty) {
-        if (overriddenType.typeFormals.length != typeFormals.length) {
-          return;
-        }
-        overriddenType = overriddenType.instantiate(typeFormals);
-      }
-      overriddenTypes.add(overriddenType);
-    }
-
-    //
     // Infer the return type.
     //
     if (element.hasImplicitReturnType) {
       (element as ExecutableElementImpl).returnType =
           _computeReturnType(overriddenTypes.map((t) => t.returnType));
       if (element is PropertyAccessorElement) {
         _updateSyntheticVariableType(element);
       }
     }
     //
@@ skipping 10 matching lines @@
           parameter.type = _computeParameterType(parameter, i, overriddenTypes);
           if (element is PropertyAccessorElement) {
             _updateSyntheticVariableType(element);
           }
         }
       }
     }
   }
 
   /**
-   * If the given [fieldElement] represents a non-synthetic instance field for
+   * 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 fieldElement) {
-    if (fieldElement.isSynthetic || fieldElement.isStatic) {
+  void _inferField(FieldElement field) {
+    if (field.isSynthetic || field.isStatic) {
       return;
     }
-    List<ExecutableElement> overriddenSetters =
-        inheritanceManager.lookupOverrides(
-            fieldElement.enclosingElement, fieldElement.name + '=');
-    var setter = fieldElement.setter;
-    if (setter != null && overriddenSetters.isNotEmpty) {
-      _inferParameterCovariance(
-          setter.parameters[0], 0, overriddenSetters.map((s) => s.type));
+
+    _FieldOverrideInferenceResult typeResult =
+        _computeFieldOverrideType(field.getter);
+    if (typeResult.isError) {
+      return;
     }
 
-    if (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.map((e) => e.returnType));
+    if (field.hasImplicitType) {
+      DartType newType = typeResult.type;
+      if (newType == null &&
+          field.initializer != null &&
+          !fieldsWithDisabledInitializerInference.contains(field)) {
+        newType = field.initializer.returnType;
+      }
 
-        if (!_isCompatible(newType, overriddenSetters)) {
-          newType = null;
-        }
-      }
-      //
-      // If there is no overridden getter or if the overridden getter's type is
-      // dynamic, then we can infer the type from the initialization expression
-      // without breaking subtype rules. We could potentially infer a consistent
-      // return type even if the overridden getter's type was not dynamic, but
-      // choose not to for simplicity. The field is required to be final to
-      // prevent choosing a type that is inconsistent with assignments we cannot
-      // analyze.
-      //
-      if (newType == null || newType.isDynamic) {
-        FunctionElement initializer = fieldElement.initializer;
-        if (initializer != null &&
-            (fieldElement.isFinal || overriddenGetters.isEmpty)) {
-          if (!fieldsWithDisabledInitializerInference.contains(fieldElement)) {
-            newType = initializer.returnType;
-          }
-        }
-      }
       if (newType == null || newType.isBottom || newType.isDartCoreNull) {
         newType = typeProvider.dynamicType;
       }
-      setFieldType(fieldElement, newType);
+
+      setFieldType(field, newType);
+    }
+
+    if (field.setter != null) {
+      var parameter = field.setter.parameters[0] as ParameterElementImpl;
+      parameter.inheritsCovariant = typeResult.isCovariant;
     }
   }
 
-  void _inferFieldFormalParameter(FieldFormalParameterElementImpl element) {
-    FieldElement field = element.field;
-    if (field != null && element.hasImplicitType) {
-      element.type = field.type;
-    }
-  }
-
   /**
    * If a parameter is covariant, any parameters that override it are too.
    */
   void _inferParameterCovariance(ParameterElementImpl parameter, int index,
       Iterable<FunctionType> overriddenTypes) {
     parameter.inheritsCovariant = overriddenTypes.any((f) {
       var param = _getCorrespondingParameter(parameter, index, f.parameters);
       return param != null && param.isCovariant;
     });
   }
 
   /**
    * 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);
       }
     }
   }
 
   /**
-   * Return `true` if the given [type] is compatible with the argument types of
-   * all of the given [setters].
+   * TODO
+   *
+   * Return [FunctionType]s of the [overriddenElement] that [element] overrides.
+   * Return `null`, in case of type parameters inconsistency.
+   *
+   * Overridden elements must have the same number of generic type parameters
+   * as the target element, or none.
+   *
+   * If we do have generic type parameters on the element we're inferring,
+   * we must express its parameter and return types in terms of its own
+   * parameters. For example, given `m<T>(t)` overriding `m<S>(S s)` we
+   * should infer this as `m<T>(T t)`.
    */
-  bool _isCompatible(DartType type, List<ExecutableElement> setters) {
-    for (ExecutableElement setter in setters) {
-      ParameterElement parameter = _getParameter(setter);
-      if (parameter != null && !typeSystem.isSubtypeOf(parameter.type, type)) {
-        return false;
+  FunctionType _toOverriddenFunctionType(
+      ExecutableElement element, ExecutableElement overriddenElement) {
+    List<DartType> typeFormals =
+        TypeParameterTypeImpl.getTypes(element.type.typeFormals);
+
+    FunctionType overriddenType = overriddenElement.type;
+    if (overriddenType == null) {
+      // TODO(brianwilkerson) I think the overridden method should always have
+      // a type, but there appears to be a bug that causes it to sometimes be
+      // null, we guard against that case by not performing inference.
+      return null;
+    }
+    if (overriddenType.typeFormals.isNotEmpty) {
+      if (overriddenType.typeFormals.length != typeFormals.length) {
+        return null;
       }
+      overriddenType = overriddenType.instantiate(typeFormals);
     }
-    return true;
+    return overriddenType;
   }
 
   /**
-   * Return `true` if the list of [elements] contains only getters.
+   * Return [FunctionType]s of [overriddenElements] that override [element].
+   * Return the empty list, in case of type parameters inconsistency.
    */
-  bool _onlyGetters(List<ExecutableElement> elements) {
-    for (ExecutableElement element in elements) {
-      if (!(element is PropertyAccessorElement && element.isGetter)) {
-        return false;
+  List<FunctionType> _toOverriddenFunctionTypes(
+      ExecutableElement element, List<ExecutableElement> overriddenElements) {
+    var overriddenTypes = <FunctionType>[];
+    for (ExecutableElement overriddenElement in overriddenElements) {
+      FunctionType overriddenType =
+          _toOverriddenFunctionType(element, overriddenElement);
+      if (overriddenType == null) {
+        return const <FunctionType>[];
       }
+      overriddenTypes.add(overriddenType);
     }
-    return true;
+    return overriddenTypes;
   }
 
   /**
    * 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.
@@ skipping 44 matching lines @@
   void visitSimpleIdentifier(SimpleIdentifier node) {
     if (!node.inDeclarationContext()) {
       Element nonAccessor(Element element) {
         if (element is PropertyAccessorElement && element.isSynthetic) {
           return element.variable;
         }
         return element;
       }
 
       Element element = nonAccessor(node.staticElement);
-      if (element is VariableElement) {
-        if (filter == null || filter(element)) {
-          results.add(element);
-        }
+      if (element is VariableElement && (filter == null || filter(element))) {
+        results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}
 
 /**
+ * The result of field type inference.
+ */
+class _FieldOverrideInferenceResult {
+  final bool isCovariant;
+  final DartType type;
+  final bool isError;
+
+  _FieldOverrideInferenceResult(this.isCovariant, this.type, this.isError);
+}
+
+/**
  * The visitor for [isValidForTypeInference].
  */
 class _IsValidForTypeInferenceVisitor extends RecursiveAstVisitor {
   bool isValid = true;
 
   @override
   void visitAssignmentExpression(AssignmentExpression node) {
     isValid = false;
   }
 
   @override
   void visitCascadeExpression(CascadeExpression node) {
     node.target.accept(this);
   }
 
   @override
   void visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element == null) {
       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;
     }
   }
 }