Fix downwards inference for async and generator functions.

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/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 5397 matching lines @@
 
   /**
    * The type system in use.
    */
   final TypeSystem _typeSystem;
 
   /**
    * A stack of return types for all of the enclosing
    * functions and methods.
    */
+  // TODO(leafp) Handle the implicit union type for Futures
+  // https://github.com/dart-lang/sdk/issues/25322
   List<DartType> _returnStack = <DartType>[];
 
   InferenceContext._(this._errorListener, TypeProvider typeProvider,
       this._typeSystem, this._inferenceHints)
       : _typeProvider = typeProvider;
 
   /**
    * Get the return type of the current enclosing function, if any.
+   *
+   * The type returned for a function is the type that is expected
+   * to be used in a return or yield context.  For ordinary functions
+   * this is the same as the return type of the function.  For async
+   * functions returning Future<T> and for generator functions
+   * returning Stream<T> or Iterable<T>, this is T.
    */
   DartType get returnContext =>
-      (_returnStack.isNotEmpty) ? _returnStack.last : null;
+      _returnStack.isNotEmpty ? _returnStack.last : null;
 
   /**
    * Match type [t1] against type [t2] as follows.
    * If `t1 = I<dynamic, ..., dynamic>`, then look for a supertype
    * of t1 of the form `K<S0, ..., Sm>` where `t2 = K<S0', ..., Sm'>`
    * If the supertype exists, use the constraints `S0 <: S0', ... Sm <: Sm'`
    * to derive a concrete instantation for I of the form `<T0, ..., Tn>`,
    * such that `I<T0, .., Tn> <: t2`
    */
   List<DartType> matchTypes(DartType t1, DartType t2) =>
@@ skipping 2913 matching lines @@
           node.rightHandSide, node.leftHandSide.staticType);
     }
     safelyVisit(node.rightHandSide);
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitAwaitExpression(AwaitExpression node) {
-    //TODO(leafp): Handle the implicit union type here
-    DartType contextType = InferenceContext.getType(node);
+    // TODO(leafp): Handle the implicit union type here
+    // https://github.com/dart-lang/sdk/issues/25322
+    DartType contextType = StaticTypeAnalyzer.flattenFutures(
+        typeProvider, InferenceContext.getType(node));
     if (contextType != null) {
       InterfaceType futureT =
           typeProvider.futureType.substitute4([contextType]);
       InferenceContext.setType(node.expression, futureT);
     }
     return super.visitAwaitExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
@@ skipping 513 matching lines @@
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       _overrideManager.enterScope();
       try {
         DartType functionType = InferenceContext.getType(node);
         if (functionType is FunctionType) {
           _inferFormalParameterList(node.parameters, functionType);
-          InferenceContext.setType(node.body, functionType.returnType);
+          DartType returnType = _computeReturnOrYieldType(
+              functionType.returnType,
+              _enclosingFunction.isGenerator,
+              _enclosingFunction.isAsynchronous);
+          InferenceContext.setType(node.body, returnType);
         }
         super.visitFunctionExpression(node);
       } finally {
         _overrideManager.exitScope();
       }
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
@@ skipping 184 matching lines @@
     }
     super.visitMapLiteral(node);
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
-      InferenceContext.setType(node.body, node.element.type?.returnType);
+      DartType returnType = _computeReturnOrYieldType(
+          _enclosingFunction.type?.returnType,
+          _enclosingFunction.isGenerator,
+          _enclosingFunction.isAsynchronous);
+      InferenceContext.setType(node.body, returnType);
       super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   @override
   void visitMethodDeclarationInScope(MethodDeclaration node) {
     super.visitMethodDeclarationInScope(node);
@@ skipping 208 matching lines @@
     return null;
   }
 
   @override
   Object visitYieldStatement(YieldStatement node) {
     DartType returnType = inferenceContext.returnContext;
     if (returnType != null && _enclosingFunction != null) {
       // If we're not in a generator ([a]sync*, then we shouldn't have a yield.
       // so don't infer
       if (_enclosingFunction.isGenerator) {
-        // If this is a yield*, then we just propagate the return type downwards
+        // If this just a yield, then we just pass on the element type
         DartType type = returnType;
-        // If this just a yield, then we need to get the element type
-        if (node.star == null) {
+        if (node.star != null) {
+          // If this is a yield*, then we wrap the element return type
           // If it's synchronous, we expect Iterable<T>, otherwise Stream<T>
-          InterfaceType wrapperD = _enclosingFunction.isSynchronous
-              ? typeProvider.iterableDynamicType
-              : typeProvider.streamDynamicType;
-          // Match the types to instantiate the type arguments if possible
-          List<DartType> targs =
-              inferenceContext.matchTypes(wrapperD, returnType);
-          type = (targs?.length == 1) ? targs[0] : null;
+          InterfaceType wrapperType = _enclosingFunction.isSynchronous
+              ? typeProvider.iterableType
+              : typeProvider.streamType;
+          type = wrapperType.substitute4(<DartType>[type]);
         }
         InferenceContext.setType(node.expression, type);
       }
     }
     return super.visitYieldStatement(node);
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
@@ skipping 20 matching lines @@
    */
   void _clearTypePromotionsIfPotentiallyMutatedIn(AstNode target) {
     for (Element element in _promoteManager.promotedElements) {
       if (_isVariablePotentiallyMutatedIn(element, target)) {
         _promoteManager.setType(element, null);
       }
     }
   }
 
   /**
+   * Given the declared return type of a function, compute the type of the
+   * values which should be returned or yielded as appropriate.  If a type
+   * cannot be computed from the declared return type, return null.
+   */
+  DartType _computeReturnOrYieldType(
+      DartType declaredType, bool isGenerator, bool isAsynchronous) {
+    // Ordinary functions just return their declared types.
+    if (!isGenerator && !isAsynchronous) {
+      return declaredType;
+    }
+    if (isGenerator) {
+      if (declaredType is! InterfaceType) {
+        return null;
+      }
+      // If it's synchronous, we expect Iterable<T>, otherwise Stream<T>
+      InterfaceType rawType = isAsynchronous
+          ? typeProvider.streamDynamicType
+          : typeProvider.iterableDynamicType;
+      // Match the types to instantiate the type arguments if possible
+      List<DartType> typeArgs =
+          inferenceContext.matchTypes(rawType, declaredType);
+      return (typeArgs?.length == 1) ? typeArgs[0] : null;
+    }
+    // Must be asynchronous to reach here, so strip off any layers of Future
+    return StaticTypeAnalyzer.flattenFutures(typeProvider, declaredType);
+  }
+
+  /**
    * The given expression is the expression used to compute the iterator for a
    * for-each statement. Attempt to compute the type of objects that will be
    * assigned to the loop variable and return that type. Return `null` if the
    * type could not be determined. The [iteratorExpression] is the expression
    * that will return the Iterable being iterated over.
    */
   DartType _getIteratorElementType(Expression iteratorExpression) {
     DartType expressionType = iteratorExpression.bestType;
     if (expressionType is InterfaceType) {
       InterfaceType interfaceType = expressionType;
@@ skipping 3987 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }