Issue 24503. Disable type overrides for properties.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 engine.resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'constant.dart';
@@ skipping 10511 matching lines @@
    * @param element the element whose type might be overridden
    * @param potentialType the potential type of the element
    * @param allowPrecisionLoss true if `potentialType` is allowed to be less precise than the
    *          current best type
    *
    * Return a new better [DartType], or `null` if [potentialType] is not better
    * than the current [element] type.
    */
   DartType overrideVariable(VariableElement element, DartType potentialType,
       bool allowPrecisionLoss) {
+    // TODO(scheglov) type propagation for instance/top-level fields
+    // was disabled because it depends on the order or visiting.
+    // If both field and its client are in the same unit, and we visit
+    // the client before the field, then propagated type is not set yet.
+    if (element is PropertyInducingElement) {
+      return null;
+    }
+
     if (potentialType == null || potentialType.isBottom) {
       return null;
     }
     DartType currentType = _overrideManager.getBestType(element);
 
     if (potentialType == currentType) {
       return null;
     }
 
     // If we aren't allowing precision loss then the third and fourth conditions
@@ skipping 12 matching lines @@
     // It also covers an important case that is not applicable in the spec:
     // for union types, we want an is-check to promote from an union type to
     // (a subtype of) any of its members.
     //
     // The first check, that [! (C << P)], covers the case where [P] and [C] are
     // unrelated types; This case is not addressed in the spec for static types.
     if (currentType == null ||
         allowPrecisionLoss ||
         !currentType.isMoreSpecificThan(potentialType) ||
         potentialType.isMoreSpecificThan(currentType)) {
-      // TODO(scheglov) type propagation for instance/top-level fields
-      // was disabled because it depends on the order or visiting.
-      // If both field and its client are in the same unit, and we visit
-      // the client before the field, then propagated type is not set yet.
-//      if (element is PropertyInducingElement) {
-//        PropertyInducingElement variable = element;
-//        if (!variable.isConst && !variable.isFinal) {
-//          return;
-//        }
-//        (variable as PropertyInducingElementImpl).propagatedType =
-//            potentialType;
-//      }
       _overrideManager.setType(element, potentialType);
       return potentialType;
     }
     return null;
   }
 
   /**
    * A client is about to resolve a member in the given class declaration.
    */
   void prepareToResolveMembersInClass(ClassDeclaration node) {
@@ skipping 5345 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }