Fixed the last unit test that was failing with the new 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 9548 matching lines @@
 
   /**
    * 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.
    */
   final List<VariableElement> staticVariables = <VariableElement>[];
 
   /**
+   * A flag indicating whether we are currently visiting a child of either a
+   * field or a top-level variable.
+   */
+  bool inFieldOrTopLevelVariable = false;
+
+  /**
    * 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.
    *
    * The [definingLibrary] is the element for the library containing the node
@@ skipping 14 matching lines @@
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope,
       InheritanceManager inheritanceManager,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : strongMode = definingLibrary.context.analysisOptions.strongMode,
         super(definingLibrary, source, typeProvider,
             new DisablableErrorListener(errorListener));
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
+    if (inFieldOrTopLevelVariable) {
+      return super.visitBlockFunctionBody(node);
+    }
     return null;
   }
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    if (inFieldOrTopLevelVariable) {
+      return super.visitExpressionFunctionBody(node);
+    }
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
-    if (strongMode && node.isStatic) {
-      _addStaticVariables(node.fields.variables);
-      bool wasDiscarding = discardErrorsInInitializer;
-      discardErrorsInInitializer = true;
-      try {
-        return super.visitFieldDeclaration(node);
-      } finally {
-        discardErrorsInInitializer = wasDiscarding;
+    bool wasInFieldOrTopLevelVariable = inFieldOrTopLevelVariable;
+    try {
+      inFieldOrTopLevelVariable = true;
+      if (strongMode && node.isStatic) {
+        _addStaticVariables(node.fields.variables);
+        bool wasDiscarding = discardErrorsInInitializer;
+        discardErrorsInInitializer = true;
+        try {
+          return super.visitFieldDeclaration(node);
+        } finally {
+          discardErrorsInInitializer = wasDiscarding;
+        }
       }
+      return super.visitFieldDeclaration(node);
+    } finally {
+      inFieldOrTopLevelVariable = wasInFieldOrTopLevelVariable;
     }
-    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);
-      bool wasDiscarding = discardErrorsInInitializer;
-      discardErrorsInInitializer = true;
-      try {
-        return super.visitTopLevelVariableDeclaration(node);
-      } finally {
-        discardErrorsInInitializer = wasDiscarding;
+    bool wasInFieldOrTopLevelVariable = inFieldOrTopLevelVariable;
+    try {
+      inFieldOrTopLevelVariable = true;
+      if (strongMode) {
+        _addStaticVariables(node.variables.variables);
+        bool wasDiscarding = discardErrorsInInitializer;
+        discardErrorsInInitializer = true;
+        try {
+          return super.visitTopLevelVariableDeclaration(node);
+        } finally {
+          discardErrorsInInitializer = wasDiscarding;
+        }
       }
+      return super.visitTopLevelVariableDeclaration(node);
+    } finally {
+      inFieldOrTopLevelVariable = wasInFieldOrTopLevelVariable;
     }
-    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) {
@@ skipping 5877 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }