Flatten futures when inferring the type of an async function expression.

pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.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.md file.
 
 import 'dart:math' as math;
 
 import 'package:front_end/src/fasta/type_inference/type_constraint_gatherer.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:kernel/ast.dart';
@@ skipping 31 matching lines @@
   /// Modify the given [constraint]'s lower bound to include [lower].
   void addLowerBound(TypeConstraint constraint, DartType lower) {
     constraint.lower = getLeastUpperBound(constraint.lower, lower);
   }
 
   /// Modify the given [constraint]'s upper bound to include [upper].
   void addUpperBound(TypeConstraint constraint, DartType upper) {
     constraint.upper = getGreatestLowerBound(constraint.upper, upper);
   }
 
+  /// Implements the function "flatten" defined in the spec, where T is [type]:
+  ///
+  ///     If T = Future<S> then flatten(T) = flatten(S).
+  ///
+  ///     Otherwise if T <: Future then let S be a type such that T << Future<S>
+  ///     and for all R, if T << Future<R> then S << R.  Then flatten(T) = S.
+  ///
+  ///     In any other circumstance, flatten(T) = T.
+  DartType flattenFutures(DartType type) {
+    if (type is InterfaceType) {
+      if (identical(type.classNode, coreTypes.futureClass)) {
+        return flattenFutures(type.typeArguments[0]);
+      }
+      InterfaceType futureBase =
+          hierarchy.getTypeAsInstanceOf(type, coreTypes.futureClass);
+      if (futureBase != null) {
+        return futureBase.typeArguments[0];
+      }
+    }
+    return type;
+  }
+
   /// Computes the greatest lower bound of [type1] and [type2].
   DartType getGreatestLowerBound(DartType type1, DartType type2) {
     // The greatest lower bound relation is reflexive.  Note that we don't test
     // for equality because we don't want to make the algorithm quadratic.  This
     // is ok because the check is not needed for correctness; it's just a speed
     // optimization.
     if (identical(type1, type2)) {
       return type1;
     }
 
@@ skipping 648 matching lines @@
           Substitution.fromMap({type2.parameter: objectType}).substituteType(
               type2.parameter.bound));
     } else {
       // We should only be called when at least one of the types is a
       // TypeParameterType
       assert(false);
       return const DynamicType();
     }
   }
 }