Improve the handling of inference for instance fields in the task model

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 9595 matching lines @@
  * 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 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.
+   * 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.
    */
-  final List<VariableElement> staticVariables = <VariableElement>[];
+  final List<VariableElement> variablesAndFields = <VariableElement>[];
 
   /**
    * A flag indicating whether we should discard errors while resolving the
    * initializer for variable declarations. We do this for top-level variables
    * and fields because their initializer will be re-resolved at a later time.
    */
   bool discardErrorsInInitializer = false;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
@@ skipping 32 matching lines @@
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (_shouldBeSkipped(node)) {
       return null;
     }
     return super.visitExpressionFunctionBody(node);
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
-    if (strongMode && node.isStatic) {
-      _addStaticVariables(node.fields.variables);
+    if (strongMode) {
+      _addVariables(node.fields.variables);
       bool wasDiscarding = discardErrorsInInitializer;
       discardErrorsInInitializer = true;
       try {
         return super.visitFieldDeclaration(node);
       } finally {
         discardErrorsInInitializer = wasDiscarding;
       }
     }
     return super.visitFieldDeclaration(node);
   }
 
   @override
   Object visitNode(AstNode node) {
     if (discardErrorsInInitializer) {
       AstNode parent = node.parent;
       if (parent is VariableDeclaration && parent.initializer == node) {
         DisablableErrorListener listener = errorListener;
         return listener.disableWhile(() => super.visitNode(node));
       }
     }
     return super.visitNode(node);
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     if (strongMode) {
-      _addStaticVariables(node.variables.variables);
+      _addVariables(node.variables.variables);
       bool wasDiscarding = discardErrorsInInitializer;
       discardErrorsInInitializer = true;
       try {
         return super.visitTopLevelVariableDeclaration(node);
       } finally {
         discardErrorsInInitializer = wasDiscarding;
       }
     }
     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 _addStaticVariables(NodeList<VariableDeclaration> variables) {
+  void _addVariables(NodeList<VariableDeclaration> variables) {
     for (VariableDeclaration variable in variables) {
       if (variable.initializer != null) {
-        staticVariables.add(variable.element);
+        variablesAndFields.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 6212 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }