Populate TypeInferrerImpl.closureContext more frequently.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 328 matching lines @@
 /// form.
 class KernelFunctionDeclaration extends FunctionDeclaration
     implements KernelStatement {
   KernelFunctionDeclaration(VariableDeclaration variable, FunctionNode function)
       : super(variable, function);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.functionDeclarationEnter(this);
     var oldClosureContext = inferrer.closureContext;
-    inferrer.closureContext = null;
+    inferrer.closureContext =
+        new ClosureContext(inferrer, function.asyncMarker, function.returnType);
     inferrer.inferStatement(function.body);
     inferrer.closureContext = oldClosureContext;
     inferrer.listener.functionDeclarationExit(this);
   }
 }
 
 /// Concrete shadow object representing a function expression in kernel form.
 class KernelFunctionExpression extends FunctionExpression
     implements KernelExpression {
   KernelFunctionExpression(FunctionNode function) : super(function);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
-    var asyncMarker = function.asyncMarker;
-    bool isAsync = asyncMarker == AsyncMarker.Async ||
-        asyncMarker == AsyncMarker.AsyncStar;
-    bool isGenerator = asyncMarker == AsyncMarker.SyncStar ||
-        asyncMarker == AsyncMarker.AsyncStar;
     typeNeeded = inferrer.listener.functionExpressionEnter(this, typeContext) ||
         typeNeeded;
     // TODO(paulberry): do we also need to visit default parameter values?
 
     // Let `<T0, ..., Tn>` be the set of type parameters of the closure (with
     // `n`=0 if there are no type parameters).
     List<TypeParameter> typeParameters = function.typeParameters;
 
     // Let `(P0 x0, ..., Pm xm)` be the set of formal parameters of the closure
     // (including required, positional optional, and named optional parameters).
@@ skipping 58 matching lines @@
           inferrer.instrumentation?.record(
               Uri.parse(inferrer.uri),
               formal.fileOffset,
               'type',
               new InstrumentationValueForType(inferredType));
           formal.type = inferredType;
         }
       }
     }
 
-    // Let `N’` be `N[T/S]`, adjusted accordingly if the closure is declared
-    // with `async`, `async*`, or `sync*`.
+    // Let `N'` be `N[T/S]`.  The [ClosureContext] constructor will adjust
+    // accordingly if the closure is declared with `async`, `async*`, or
+    // `sync*`.
     if (returnContext != null) {
       returnContext = substitution.substituteType(returnContext);
     }
-    if (isGenerator) {
-      if (isAsync) {
-        returnContext = inferrer.getTypeArgumentOf(
-            returnContext, inferrer.coreTypes.streamClass);
-      } else {
-        returnContext = inferrer.getTypeArgumentOf(
-            returnContext, inferrer.coreTypes.iterableClass);
-      }
-    } else if (isAsync) {
-      // TODO(paulberry): do we have to handle FutureOr<> here?
-      returnContext = inferrer.getTypeArgumentOf(
-          returnContext, inferrer.coreTypes.futureClass);
-    }
 
     // Apply type inference to `B` in return context `N’`, with any references
     // to `xi` in `B` having type `Pi`.  This produces `B’`.
     bool isExpressionFunction = function.body is ReturnStatement;
     bool needToSetReturnType = isExpressionFunction || inferrer.strongMode;
     ClosureContext oldClosureContext = inferrer.closureContext;
-    inferrer.closureContext =
-        new ClosureContext(isAsync, isGenerator, returnContext);
+    ClosureContext closureContext =
+        new ClosureContext(inferrer, function.asyncMarker, returnContext);
+    inferrer.closureContext = closureContext;
     inferrer.inferStatement(function.body);
 
     // If the closure is declared with `async*` or `sync*`, let `M` be the least
     // upper bound of the types of the `yield` expressions in `B’`, or `void` if
     // `B’` contains no `yield` expressions.  Otherwise, let `M` be the least
     // upper bound of the types of the `return` expressions in `B’`, or `void`
     // if `B’` contains no `return` expressions.
     DartType inferredReturnType;
     if (needToSetReturnType || typeNeeded) {
-      inferredReturnType = inferrer.inferReturnType(
-          inferrer.closureContext.inferredReturnType, isExpressionFunction);
-      if (!isExpressionFunction &&
-          returnContext != null &&
-          (!inferrer.typeSchemaEnvironment
-                  .isSubtypeOf(inferredReturnType, returnContext) ||
-              returnContext is VoidType)) {
-        // For block-bodied functions, if the inferred return type isn't a
-        // subtype of the context (or the context is void), we use the context.
-        // TODO(paulberry): this is inherited from analyzer; it's not part of
-        // the spec.  See also dartbug.com/29606.
-        inferredReturnType = greatestClosure(inferrer.coreTypes, returnContext);
-      }
-
-      // Let `M’` be `M`, adjusted accordingly if the closure is declared with
-      // `async`, `async*`, or `sync*`.
-      if (isGenerator) {
-        if (isAsync) {
-          inferredReturnType = inferrer.wrapType(
-              inferredReturnType, inferrer.coreTypes.streamClass);
-        } else {
-          inferredReturnType = inferrer.wrapType(
-              inferredReturnType, inferrer.coreTypes.iterableClass);
-        }
-      } else if (isAsync) {
-        inferredReturnType = inferrer.wrapFutureType(inferredReturnType);
-      }
+      inferredReturnType =
+          closureContext.inferReturnType(inferrer, isExpressionFunction);
     }
 
     // Then the result of inference is `<T0, ..., Tn>(R0 x0, ..., Rn xn) B` with
     // type `<T0, ..., Tn>(R0, ..., Rn) -> M’` (with some of the `Ri` and `xi`
     // denoted as optional or named parameters, if appropriate).
     if (needToSetReturnType) {
       inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
           'returnType', new InstrumentationValueForType(inferredReturnType));
       function.returnType = inferredReturnType;
     }
@@ skipping 281 matching lines @@
 }
 
 /// Concrete shadow object representing a return statement in kernel form.
 class KernelReturnStatement extends ReturnStatement implements KernelStatement {
   KernelReturnStatement([Expression expression]) : super(expression);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.returnStatementEnter(this);
     var closureContext = inferrer.closureContext;
-    var typeContext = closureContext != null && !closureContext.isGenerator
-        ? closureContext.returnContext
-        : null;
+    var typeContext =
+        !closureContext.isGenerator ? closureContext.returnContext : null;
     var inferredType = expression != null
-        ? inferrer.inferExpression(
-            expression, typeContext, closureContext != null)
+        ? inferrer.inferExpression(expression, typeContext, true)
         : const VoidType();
     // Analyzer treats bare `return` statements as having no effect on the
     // inferred type of the closure.  TODO(paulberry): is this what we want
     // for Fasta?
     if (expression != null) {
-      closureContext?.handleReturn(inferrer, inferredType);
+      closureContext.handleReturn(inferrer, inferredType);
     }
     inferrer.listener.returnStatementExit(this);
   }
 }
 
 /// Common base class for shadow objects representing statements in kernel
 /// form.
 abstract class KernelStatement extends Statement {
   /// Calls back to [inferrer] to perform type inference for whatever concrete
   /// type of [KernelStatement] this is.
@@ skipping 515 matching lines @@
 
 /// Concrete shadow object representing a yield statement in kernel form.
 class KernelYieldStatement extends YieldStatement implements KernelStatement {
   KernelYieldStatement(Expression expression, {bool isYieldStar: false})
       : super(expression, isYieldStar: isYieldStar);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     inferrer.listener.yieldStatementEnter(this);
     var closureContext = inferrer.closureContext;
-    var typeContext = closureContext != null && closureContext.isGenerator
-        ? closureContext.returnContext
-        : null;
+    var typeContext =
+        closureContext.isGenerator ? closureContext.returnContext : null;
     if (isYieldStar && typeContext != null) {
-      if (closureContext == null) {
-        typeContext = null;
-      } else {
-        typeContext = inferrer.wrapType(
-            typeContext,
-            closureContext.isAsync
-                ? inferrer.coreTypes.streamClass
-                : inferrer.coreTypes.iterableClass);
-      }
+      typeContext = inferrer.wrapType(
+          typeContext,
+          closureContext.isAsync
+              ? inferrer.coreTypes.streamClass
+              : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(
         expression, typeContext, closureContext != null);
     closureContext?.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }