Implement new flatten specification.

pkg/compiler/lib/src/dart_types.dart

Index: pkg/compiler/lib/src/dart_types.dart
diff --git a/pkg/compiler/lib/src/dart_types.dart b/pkg/compiler/lib/src/dart_types.dart
index fd27d881abab676d98fabe45ad37567e05214ade..b9c90fe40bbab1bdb29fad25c9d181cac4972f4b 100644
--- a/pkg/compiler/lib/src/dart_types.dart
+++ b/pkg/compiler/lib/src/dart_types.dart
@@ -1222,6 +1222,37 @@ class Types implements DartTypes {
     return new Types(compiler);
   }
 
+  /// Flatten [type] by recursively removing enclosing `Future` annotations.
+  ///
+  /// Defined in the language specification as:
+  ///
+  ///   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.
+  ///
+  /// For instance:
+  ///     flatten(T) = T
+  ///     flatten(Future<T>) = T
+  ///     flatten(Future<Future<T>>) = T
+  ///
+  /// This method is used in the static typing of await and type checking of
+  /// return.
+  DartType flatten(DartType type) {

[Paul Berry, 2015/03/25 15:22:25]

There are two corner cases I ran into in the analyzer implementation that don't
seem to be addressed here.  If T != Future<S> but T <: Future, it's possible for
there to be multiple type arguments to Future appearing in the class hierarchy. 
When this happens, there will either be:

1. a single type S that is at least as specific as all the others (i.e. the
"most specific" type argument to future), in which case, that should be the
result of flatten().  Or:

2. no type S that is at least as specific as all the others, in which case I
believe flatten(T) should be T.

For example, assume the following classes exist:
class Base
class Derived1 extends Base
class Derived2 extends Base
class A extends Future<Derived1> implements Future<Base>
class B extends Future<Base> implements Future<Derived1>
class C extends Future<Derived1> implements Future<Derived2>
class D extends Future<Derived2> implements Future<Derived1>

Then:
- flatten(A) = flatten(B) = Derived1, since Derived1 is more specific than Base
(case 1).
- flatten(C) = C and flatten(D) = D, since neither Derived1 nor Derived2 is more
specific than the other.

The general algorithm for finding the "most specific" type out of a set (if it
exists) turned out to be unexpectedly tricky.  You can see my implementation
around line 1855 of
https://codereview.chromium.org/1023903002/diff/1/pkg/analyzer/lib/src/genera...
(the _findMostSpecificType function).

+    if (type is InterfaceType) {
+      if (type.element == coreTypes.futureClass) {
+        // T = Future<S>
+        return flatten(type.typeArguments.first);
+      }
+      InterfaceType futureType = type.asInstanceOf(coreTypes.futureClass);
+      if (futureType != null) {
+        // T << Future<S>
+        return futureType.typeArguments.single;
+      }
+    }
+    return type;
+  }
+
   /** Returns true if [t] is more specific than [s]. */
   bool isMoreSpecific(DartType t, DartType s) {
     return moreSpecificVisitor.isMoreSpecific(t, s);