support `@virtual` fields, fix #27384

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 288 matching lines @@
       }
     }
     //
     // Infer the parameter types.
     //
     List<ParameterElement> parameters = element.parameters;
     int length = parameters.length;
     for (int i = 0; i < length; ++i) {
       ParameterElement parameter = parameters[i];
       if (parameter is ParameterElementImpl) {
-        // If a parameter is covariant, any parameters that override it are too.
-        parameter.inheritsCovariant = overriddenTypes.any((f) {
-          var param = _getCorrespondingParameter(parameter, i, f.parameters);
-          return param != null && param.isCovariant;
-        });
+        _inferParameterCovariance(parameter, i, overriddenTypes);
 
         if (parameter.hasImplicitType) {
           parameter.type = _computeParameterType(parameter, i, overriddenTypes);
           if (element is PropertyAccessorElement) {
             _updateSyntheticVariableType(element);
           }
         }
       }
     }
   }
 
   /**
    * 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) {
+    if (fieldElement.isSynthetic || fieldElement.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));
+    }
+
+    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));
-        List<ExecutableElement> overriddenSetters =
-            inheritanceManager.lookupOverrides(
-                fieldElement.enclosingElement, fieldElement.name + '=');
+
         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
@@ skipping 14 matching lines @@
   }
 
   void _inferFieldFormalParameter(FieldFormalParameterElement element) {
     FieldElement field = element.field;
     if (field != null && element.hasImplicitType) {
       (element as FieldFormalParameterElementImpl).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);
       }
     }
@@ skipping 91 matching lines @@
         results.add(element);
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}