Don't disable downward inference inside initializers used for top-level inference.

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/standard_resolution_map.dart';
@@ skipping 5004 matching lines @@
    * A comment before a function should be resolved in the context of the
    * function. But when we incrementally resolve a comment, we don't want to
    * resolve the whole function.
    *
    * So, this flag is set to `true`, when just context of the function should
    * be built and the comment resolved.
    */
   bool resolveOnlyCommentInFunctionBody = false;
 
   /**
-   * This flag is set to `true` while the type of a top-level variable or a
-   * class field is being inferred using its initializer.
-   */
-  bool isTopLevelInference;
-
-  /**
    * Body of the function currently being analyzed, if any.
    */
   FunctionBody _currentFunctionBody;
 
   /**
    * Are we running in strong mode or not.
    */
   bool strongMode;
 
   /**
    * 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.
    */
   ResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
-      {Scope nameScope, this.isTopLevelInference: false})
+      {Scope nameScope})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     AnalysisOptions options = definingLibrary.context.analysisOptions;
     this.strongMode = options.strongMode;
     this.elementResolver = new ElementResolver(this);
     this.typeSystem = definingLibrary.context.typeSystem;
     bool strongModeHints = false;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
@@ skipping 479 matching lines @@
       }
       rightOperand?.accept(this);
     }
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
-    bool wasTopLevelInference = isTopLevelInference;
-    isTopLevelInference = false;
     _overrideManager.enterScope();
     try {
       inferenceContext.pushReturnContext(node);
       super.visitBlockFunctionBody(node);
     } finally {
-      isTopLevelInference = wasTopLevelInference;
       _overrideManager.exitScope();
       inferenceContext.popReturnContext(node);
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     //
     // We do not visit the label because it needs to be visited in the context
@@ skipping 298 matching lines @@
       InferenceContext.setTypeFromNode(node.expression, node);
       super.visitExpressionFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
-    bool wasTopLevelInference = isTopLevelInference;
-    isTopLevelInference = node.fields.type == null;
     _overrideManager.enterScope();
     try {
       super.visitFieldDeclaration(node);
     } finally {
-      isTopLevelInference = wasTopLevelInference;
       Map<VariableElement, DartType> overrides =
           _overrideManager.captureOverrides(node.fields);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
@@ skipping 482 matching lines @@
     try {
       super.visitSwitchDefault(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    bool wasTopLevelInference = isTopLevelInference;
-    isTopLevelInference = node.variables.type == null;
     _overrideManager.enterScope();
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
-      isTopLevelInference = wasTopLevelInference;
       Map<VariableElement, DartType> overrides =
           _overrideManager.captureOverrides(node.variables);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
@@ skipping 258 matching lines @@
 
   FunctionType _inferArgumentTypesForGeneric(AstNode inferenceNode,
       DartType uninstantiatedType, TypeArgumentList typeArguments,
       {AstNode errorNode}) {
     errorNode ??= inferenceNode;
     TypeSystem ts = typeSystem;
     if (typeArguments == null &&
         uninstantiatedType is FunctionType &&
         uninstantiatedType.typeFormals.isNotEmpty &&
         ts is StrongTypeSystemImpl) {
-      if (isTopLevelInference) {
-        if (uninstantiatedType.typeFormals.isNotEmpty) {
-          return null;
-        }
-      }
       return ts.inferGenericFunctionOrType/*<FunctionType>*/(
           uninstantiatedType,
           ParameterElement.EMPTY_LIST,
           DartType.EMPTY_LIST,
           InferenceContext.getContext(inferenceNode),
           downwards: true,
           errorReporter: errorReporter,
           errorNode: errorNode);
     }
     return null;
@@ skipping 4222 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }