Propagate types of final/const top-level variables and fields.

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 9707 matching lines @@
   bool _isOverride(Element element) => element != null && element.isOverride;
 }
 
 /**
  * An AST visitor that is used to resolve the some of the nodes within a single
  * compilation unit. The nodes that are skipped are those that are within
  * function bodies.
  */
 class PartialResolverVisitor extends ResolverVisitor {
   /**
-   * A flag indicating whether the resolver is being run in strong mode.
-   */
-  final bool strongMode;
-
-  /**
    * 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. The list will be empty unless the resolver is being run in
-   * strong mode.
+   * be inferred.
    */
-  final List<VariableElement> variablesAndFields = <VariableElement>[];
+  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
    * [typeProvider]. The [inheritanceManager] is used to perform inheritance
    * lookups.  If `null` or unspecified, a new [InheritanceManager] will be
    * created based on [definingLibrary]. The [typeAnalyzerFactory] is used to
    * create the type analyzer.  If `null` or unspecified, a type analyzer of
    * type [StaticTypeAnalyzer] will be created.
    */
   PartialResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope,
       InheritanceManager inheritanceManager,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
-      : strongMode = definingLibrary.context.analysisOptions.strongMode,
-        super(definingLibrary, source, typeProvider, errorListener);
+      : super(definingLibrary, source, typeProvider, errorListener);
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     if (_shouldBeSkipped(node)) {
       return null;
     }
     return super.visitBlockFunctionBody(node);
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (_shouldBeSkipped(node)) {
       return null;
     }
     return super.visitExpressionFunctionBody(node);
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
-    if (strongMode && node.isStatic) {
-      _addVariables(node.fields.variables);
+    _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) {
-    if (strongMode) {
-      _addVariables(node.variables.variables);
+    _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) {
+    for (VariableDeclaration variable in variables) {
+      if (variable.initializer != null) {
+        VariableElement element = variable.element;
+        if (element.isConst || element.isFinal) {
+          propagableVariables.add(element);
+        }
+      }
     }
-    return super.visitTopLevelVariableDeclaration(node);
   }
 
   /**
    * 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 _addVariables(NodeList<VariableDeclaration> variables) {
+  void _addStaticVariables(List<VariableDeclaration> variables) {
     for (VariableDeclaration variable in variables) {
       if (variable.initializer != null) {
-        variablesAndFields.add(variable.element);
+        staticVariables.add(variable.element);
       }
     }
   }
 
   /**
    * Return `true` if the given function body should be skipped because it is
    * the body of a top-level function, method or constructor.
    */
   bool _shouldBeSkipped(FunctionBody body) {
     AstNode parent = body.parent;
@@ skipping 5725 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }