support `@virtual` fields, fix #27384

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart' show StrongModeCode;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart';
 
 import 'ast_properties.dart';
 
 /// Given an [expression] and a corresponding [typeSystem] and [typeProvider],
 /// gets the known static type of the expression.
@@ skipping 41 matching lines @@
   } else if (expression is PropertyAccess) {
     return expression.propertyName.staticElement;
   } else if (expression is Identifier) {
     return expression.staticElement;
   }
   return null;
 }
 
 /// Return the field on type corresponding to member, or null if none
 /// exists or the "field" is actually a getter/setter.
-PropertyInducingElement _getMemberField(
+FieldElement _getMemberField(
     InterfaceType type, PropertyAccessorElement member) {
   String memberName = member.name;
-  PropertyInducingElement field;
+  FieldElement field;
   if (member.isGetter) {
     // The subclass member is an explicit getter or a field
     // - lookup the getter on the superclass.
     var getter = type.getGetter(memberName);
     if (getter == null || getter.isStatic) return null;
     field = getter.variable;
   } else if (!member.isSynthetic) {
     // The subclass member is an explicit setter
     // - lookup the setter on the superclass.
     // Note: an implicit (synthetic) setter would have already been flagged on
@@ skipping 1290 matching lines @@
       AstNode node, AstNode errorLocation, bool isSubclass) {
     assert(!element.isStatic);
 
     FunctionType subType = _elementType(element);
     // TODO(vsm): Test for generic
     FunctionType baseType = _getMemberType(type, element);
     if (baseType == null) return false;
 
     if (isSubclass && element is PropertyAccessorElement) {
       // Disallow any overriding if the base class defines this member
-      // as a field.  We effectively treat fields as final / non-virtual.
-      PropertyInducingElement field = _getMemberField(type, element);
-      if (field != null) {
+      // as a field.  We effectively treat fields as final / non-virtual,
+      // unless they are explicitly marked as @virtual
+      var field = _getMemberField(type, element);
+      if (field != null && !field.isVirtual) {
         _checker._recordMessage(
             errorLocation, StrongModeCode.INVALID_FIELD_OVERRIDE, [
           element.enclosingElement.name,
           element.name,
           subType,
           type,
           baseType
         ]);
       }
     }
@@ skipping 59 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }