Don't perform final fields and top-level variables type propagation.

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 5184 matching lines @@
 class PartialResolverVisitor extends ResolverVisitor {
   /**
    * The static variables and fields that have an initializer. These are the
    * variables that need to be re-resolved after static variables have their
    * types inferred. A subset of these variables are those whose types should
    * be inferred.
    */
   final List<VariableElement> staticVariables = <VariableElement>[];
 
   /**
-   * The static and instance variables and fields that have an initializer.
-   * These are the variables whose types might be propagated.
-   */
-  final List<VariableElement> propagableVariables = <VariableElement>[];
-
-  /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * The [definingLibrary] is the element for the library containing the node
    * being visited. The [source] is the source representing the compilation unit
    * containing the node being visited. The [typeProvider] is the object used to
    * access the types from the core library. The [errorListener] is the error
    * listener that will be informed of any errors that are found during
    * resolution. The [nameScope] is the scope used to resolve identifiers in the
    * node that will first be visited.  If `null` or unspecified, a new
    * [LibraryScope] will be created based on [definingLibrary] and
@@ skipping 20 matching lines @@
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (_shouldBeSkipped(node)) {
       return null;
     }
     return super.visitExpressionFunctionBody(node);
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
-    _addPropagableVariables(node.fields.variables);
     if (node.isStatic) {
       _addStaticVariables(node.fields.variables);
     }
     return super.visitFieldDeclaration(node);
   }
 
   @override
   Object visitNode(AstNode node) {
     return super.visitNode(node);
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    _addPropagableVariables(node.variables.variables);
     _addStaticVariables(node.variables.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
 
   /**
-   * Add all of the [variables] with initializers to [propagableVariables].
-   */
-  void _addPropagableVariables(List<VariableDeclaration> variables) {
-    int length = variables.length;
-    for (int i = 0; i < length; i++) {
-      VariableDeclaration variable = variables[i];
-      if (variable.name.name.isNotEmpty && variable.initializer != null) {
-        VariableElement element = variable.element;
-        if (element.isConst || element.isFinal) {
-          propagableVariables.add(element);
-        }
-      }
-    }
-  }
-
-  /**
    * Add all of the [variables] with initializers to the list of variables whose
    * type can be inferred. Technically, we only infer the types of variables
    * that do not have a static type, but all variables with initializers
    * potentially need to be re-resolved after inference because they might
    * refer to a field whose type was inferred.
    */
   void _addStaticVariables(List<VariableDeclaration> variables) {
     int length = variables.length;
     for (int i = 0; i < length; i++) {
       VariableDeclaration variable = variables[i];
@@ skipping 5874 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }