fix #25944, improve Future.then inference

pkg/analyzer/lib/src/generated/type_system.dart

Index: pkg/analyzer/lib/src/generated/type_system.dart
diff --git a/pkg/analyzer/lib/src/generated/type_system.dart b/pkg/analyzer/lib/src/generated/type_system.dart
index efe8e16908058e96ff4e52722307a6c4231b19b2..d9e66c67457982a585a9b41e4991ca3111d3c74c 100644
--- a/pkg/analyzer/lib/src/generated/type_system.dart
+++ b/pkg/analyzer/lib/src/generated/type_system.dart
@@ -207,6 +207,7 @@ class StrongTypeSystemImpl extends TypeSystem {
       List<DartType> correspondingParameterTypes,
       List<DartType> argumentTypes,
       DartType returnContextType) {
+
     if (fnType.typeFormals.isEmpty) {
       return fnType;
     }
@@ -218,23 +219,6 @@ class StrongTypeSystemImpl extends TypeSystem {
     var inferringTypeSystem =
         new _StrongInferenceTypeSystem(typeProvider, this, fnType.typeFormals);
 
-    // Special case inference for Future.then.
-    //
-    // We don't have union types, so Future<T>.then<S> is typed to take a
-    // callback `T -> S`. However, the lambda might actually return a
-    // Future<S>. So we handle that special case here.
-    if (argumentTypes.isNotEmpty && argumentTypes[0] is FunctionType) {
-      Element element = fnType?.element;
-      bool isFutureThen = element is MethodElement &&
-          element.name == 'then' &&
-          element.enclosingElement.type.isDartAsyncFuture;
-      if (isFutureThen) {
-        // Ignore return context. We'll let the onValue function's return type
-        // drive inference.
-        returnContextType = null;
-      }
-    }
-
     if (returnContextType != null) {
       inferringTypeSystem.isSubtypeOf(fnType.returnType, returnContextType);
     }
@@ -690,9 +674,13 @@ class StrongTypeSystemImpl extends TypeSystem {
       return true;
     }
 
-    // The types are void, dynamic, bottom, interface types, function types
-    // and type parameters.  We proceed by eliminating these different classes
-    // from consideration.
+    // The types are void, dynamic, bottom, interface types, function types,
+    // and type parameters.
+    //
+    // Union types can also arise in some cases relating to the Future type

[Leaf, 2016/08/05 22:32:35]

Is this vestigial?  I don't see any new code to handle Future unions, and I
would kind of expect them not to show up here.

[Jennifer Messerly, 2016/08/08 21:59:26]

Eeeek, good catch, done!

(yes for a while I had them not as well contained, they were indeed spreading to
LUB and subtype and stuff like that, at which point I backed off and started
over)

+    // (T | Future<T> for some T).
+    //
+    // We proceed by eliminating these different classes from consideration.
 
     // Trivially true.
     if (_isTop(t2, dynamicIsBottom: dynamicIsBottom) ||
@@ -1269,6 +1257,28 @@ class TypeSystemImpl extends TypeSystem {
 }
 
 /// Tracks upper and lower type bounds for a set of type parameters.
+///
+/// This class is used by calling [isSubtypeOf]. When it encounters one of
+/// the type parameters it is inferring, it will record the constraint, and
+/// optimistically assume the constraint will be satisfied.
+///
+/// For example if we are inferring type parameter A, and we ask if
+/// `A <: num`, this will record that A must be a subytpe of `num`. It also
+/// handles cases when A appears as part of the structure of another type, for
+/// example `Iterable<A> <: Iterable<num>` would infer the same constraint
+/// (due to covariant generic types) as would `() -> A <: () -> int`. In
+/// contrast `(A) -> void <: (num) -> void`.
+///
+/// Once the lower/upper bounds are determined, [_infer] should be called to
+/// finish the inference. It will instantiate a generic function type with the
+/// inferred types for each type parameter.
+///
+/// It can also optionally compute a partial solution, in case some of the type
+/// parameters could not be inferred (because the constraints cannot be
+/// satisfied), or bail on the inference when this happens.
+///
+/// As currently designed, an instance of this class should only be used to
+/// infer a single call and discarded immediately afterwards.
 class _StrongInferenceTypeSystem extends StrongTypeSystemImpl {
   final TypeProvider _typeProvider;
 
@@ -1506,3 +1516,72 @@ class _TypeParameterVariance {
     }
   }
 }
+
+/**
+ * This is a marker interface for [DartType] and [FutureUnionTypeContext].
+ *
+ * Both of those types are valid context types in strong mode's type inference.
+ */
+abstract class TypeContext {}
+
+/**
+ * A special union type of `Future<T> | T` used for Strong Mode inference.
+ */
+class FutureUnionTypeContext implements TypeContext {
+
+  // TODO(jmesserly): a Set would be better.
+  //
+  // For now we know `Future<T> | T` is the only valid use, so we can rely on
+  // the order, which simplifies some things.
+  //
+  // This will need clean up before this can function as a real union type.
+  final List<DartType> types;
+
+  @override
+  String toString() {
+    var buffer = new StringBuffer();
+    buffer.write('(');
+    for (int i = 0; i < types.length; i++) {
+      if (i != 0) {
+        buffer.write(' | ');
+      }
+      (types[i] as TypeImpl).appendTo(buffer);
+    }
+    buffer.write(')');
+    return buffer.toString();
+  }
+
+
+  /**
+   * Creates a union of `Future< flatten(T) > | flatten(T)`.
+   */
+  factory FutureUnionTypeContext(
+      DartType type, TypeProvider provider, TypeSystem system) {
+    type = type.flattenFutures(system);
+
+    // The order of these types is important: T could be a type variable, so
+    // we want to try and match `Future<T>` before we try and match `T`.
+    return new FutureUnionTypeContext._([
+      provider.futureType.instantiate([type]),
+      type
+    ]);
+  }
+
+  FutureUnionTypeContext._(this.types);
+
+  DartType get futureOfType => types[0];
+
+  DartType get type => types[1];
+
+  /**
+   * Creates a union of `T | Future<T>`, unless `T` is already a future-union,
+   * in which case it simply returns `T`
+   */
+  static FutureUnionTypeContext from(
+      TypeContext type, TypeProvider provider, TypeSystem system) {
+    if (type is FutureUnionTypeContext) {
+      return type;
+    }
+    return new FutureUnionTypeContext(type as DartType, provider, system);
+  }
+}