Fix #28120, strong mode allows field overrides

pkg/dev_compiler/lib/src/compiler/nullable_type_inference.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.
 
 import 'dart:collection';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/ast/visitor.dart' show RecursiveAstVisitor;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'element_helpers.dart' show getStaticType, isInlineJS;
+import 'property_model.dart';
 
 /// An inference engine for nullable types.
 ///
 /// This can answer questions about whether expressions are nullable
 /// (see [isNullable]). Given a set of compilation units in a library, it will
 /// determine if locals can be null using flow-insensitive analysis.
 ///
 /// The analysis for null expressions is conservative and incomplete, but it can
 /// optimize some patterns.
 // TODO(vsm): Revisit whether we really need this when we get
 // better non-nullability in the type system.
 abstract class NullableTypeInference {
   LibraryElement get dartCoreLibrary;
+  VirtualFieldModel get virtualFields;
+
   bool isPrimitiveType(DartType type);
   bool isObjectMember(String name);
 
   /// Known non-null local variables.
   HashSet<LocalVariableElement> _notNullLocals;
 
   void inferNullableTypes(AstNode node) {
     var visitor = new _NullableLocalInference(this);
     node.accept(visitor);
     _notNullLocals = visitor.computeNotNullLocals();
@@ skipping 38 matching lines @@
         return !_notNullLocals.contains(element);
       }
 
       if (element is FunctionElement || element is MethodElement) {
         // A function or method. This can't be null.
         return false;
       }
 
       if (element is PropertyAccessorElement && element.isGetter) {
         PropertyInducingElement variable = element.variable;
-        var isVirtual = variable is FieldElement && variable.isVirtual;
+        var isVirtual =
+            variable is FieldElement && virtualFields.isVirtual(variable);
         return isVirtual || (variable.computeConstantValue()?.isNull ?? true);
       }
 
       // Other types of identifiers are nullable (parameters, fields).
       return true;
     }
 
     if (expr is Literal) return expr is NullLiteral;
     if (expr is IsExpression) return false;
     if (expr is FunctionExpression) return false;
@@ skipping 226 matching lines @@
           return false;
         }
 
         if (_nullInference._isNullable(right, visitLocal)) {
           _nullableLocals.add(element);
         }
       }
     }
   }
 }