fix #28526 and fix #28527 FutureOr<T> in await and subtype

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

 // Copyright (c) 2015, 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.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 678 matching lines @@
         return false;
       }
       try {
         return check(t1, t2, visited);
       } finally {
         visited.remove(element);
       }
     };
   }
 
-  /// If [t1] or [t2] is a type parameter we are inferring, update its bound.
-  /// Returns `true` if we could possibly find a compatible type,
-  /// otherwise `false`.
-  bool _inferTypeParameterSubtypeOf(DartType t1, DartType t2) {
-    return false;
-  }
-
   /**
    * This currently does not implement a very complete least upper bound
    * algorithm, but handles a couple of the very common cases that are
    * causing pain in real code.  The current algorithm is:
    * 1. If either of the types is a supertype of the other, return it.
    *    This is in fact the best result in this case.
    * 2. If the two types have the same class element, then take the
    *    pointwise least upper bound of the type arguments.  This is again
    *    the best result, except that the recursive calls may not return
    *    the true least uppper bounds.  The result is guaranteed to be a
@@ skipping 117 matching lines @@
 
     // Trivially true.
     if (_isTop(t2, dynamicIsBottom: dynamicIsBottom) ||
         _isBottom(t1, dynamicIsBottom: dynamicIsBottom)) {
       return true;
     }
 
     // Trivially false.
     if (_isTop(t1, dynamicIsBottom: dynamicIsBottom) ||
         _isBottom(t2, dynamicIsBottom: dynamicIsBottom)) {
-      return _inferTypeParameterSubtypeOf(t1, t2);
-    }
-
-    // S <: T where S is a type variable
-    //  T is not dynamic or object (handled above)
-    //  True if T == S
-    //  Or true if bound of S is S' and S' <: T
-    if (t1 is TypeParameterType) {
-      if (t2 is TypeParameterType &&
-          t1.definition == t2.definition &&
-          guardedSubtype(t1.bound, t2.bound, visited)) {
-        return true;
-      }
-      if (_inferTypeParameterSubtypeOf(t1, t2)) {
-        return true;
-      }
-      DartType bound = t1.element.bound;
-      return bound == null ? false : guardedSubtype(bound, t2, visited);
-    }
-
-    if (t2 is TypeParameterType) {
-      return _inferTypeParameterSubtypeOf(t1, t2);
+      return false;
     }
 
     // Handle FutureOr<T> union type.
     if (t1 is InterfaceType && t1.isDartAsyncFutureOr) {
       var t1TypeArg = t1.typeArguments[0];
       if (t2 is InterfaceType && t2.isDartAsyncFutureOr) {
         var t2TypeArg = t2.typeArguments[0];
         // FutureOr<A> <: FutureOr<B> iff A <: B
         return isSubtypeOf(t1TypeArg, t2TypeArg);
       }
 
       // given t1 is Future<A> | A, then:
       // (Future<A> | A) <: t2 iff Future<A> <: t2 and A <: t2.
       var t1Future = typeProvider.futureType.instantiate([t1TypeArg]);
       return isSubtypeOf(t1Future, t2) && isSubtypeOf(t1TypeArg, t2);
     }
 
     if (t2 is InterfaceType && t2.isDartAsyncFutureOr) {
       // given t2 is Future<A> | A, then:
       // t1 <: (Future<A> | A) iff t1 <: Future<A> or t1 <: A
       var t2TypeArg = t2.typeArguments[0];
       var t2Future = typeProvider.futureType.instantiate([t2TypeArg]);
       return isSubtypeOf(t1, t2Future) || isSubtypeOf(t1, t2TypeArg);
     }
 
+    // S <: T where S is a type variable
+    //  T is not dynamic or object (handled above)
+    //  True if T == S
+    //  Or true if bound of S is S' and S' <: T
+    if (t1 is TypeParameterType) {
+      if (t2 is TypeParameterType &&
+          t1.definition == t2.definition &&
+          guardedSubtype(t1.bound, t2.bound, visited)) {
+        return true;
+      }
+      DartType bound = t1.element.bound;
+      return bound == null ? false : guardedSubtype(bound, t2, visited);
+    }
+    if (t2 is TypeParameterType) {
+      return false;
+    }
+
     // Void only appears as the return type of a function, and we handle it
     // directly in the function subtype rules. We should not get to a point
     // where we're doing a subtype test on a "bare" void, but just in case we
     // do, handle it safely.
     // TODO(rnystrom): Determine how this can ever be reached. If it can't,
     // remove it.
     if (t1.isVoid || t2.isVoid) {
       return t1.isVoid && t2.isVoid;
     }
 
@@ skipping 575 matching lines @@
     // Initialize the inferred type array.
     //
     // They all start as `dynamic` to offer reasonable degradation for f-bounded
     // type parameters.
     var inferredTypes = new List<DartType>.filled(
         fnTypeParams.length, DynamicTypeImpl.instance,
         growable: false);
 
     for (int i = 0; i < fnTypeParams.length; i++) {
       TypeParameterType typeParam = fnTypeParams[i];
+      _TypeParameterBound bound = _bounds[typeParam];
 
       // Apply the `extends` clause for the type parameter, if any.
       //
       // Assumption: if the current type parameter has an "extends" clause
       // that refers to another type variable we are inferring, it will appear
       // before us or in this list position. For example:
       //
       //     <TFrom, TTo extends TFrom>
       //
       // We may infer TTo is TFrom. In that case, we already know what TFrom
       // is inferred as, so we can substitute it now. This also handles more
       // complex cases such as:
       //
       //     <TFrom, TTo extends Iterable<TFrom>>
       //
       // Or if the type parameter's bound depends on itself such as:
       //
       //     <T extends Clonable<T>>
       DartType declaredUpperBound = typeParam.element.bound;
       if (declaredUpperBound != null) {
         // Assert that the type parameter is a subtype of its bound.
-        _inferTypeParameterSubtypeOf(typeParam,
+        // TODO(jmesserly): the order of calling GLB here matters, because of
+        // https://github.com/dart-lang/sdk/issues/28513
+        bound.upper = _typeSystem.getGreatestLowerBound(bound.upper,

[Jennifer Messerly, 2017/01/27 23:04:49]

this fix is new.

             declaredUpperBound.substitute2(inferredTypes, fnTypeParams));
       }
 
       // Now we've computed lower and upper bounds for each type parameter.
       //
       // To decide on which type to assign, we look at the return type and see
       // if the type parameter occurs in covariant or contravariant positions.
       //
       // If the type is "passed in" at all, or if our lower bound was bottom,
       // we choose the upper bound as being the most useful.
       //
       // Otherwise we choose the more precise lower bound.
       _TypeParameterVariance variance =
           new _TypeParameterVariance.from(typeParam, declaredReturnType);
 
-      _TypeParameterBound bound = _bounds[typeParam];
       DartType lowerBound = bound.lower;
       DartType upperBound = bound.upper;
 
       // See if the bounds can be satisfied.
       // TODO(jmesserly): also we should have an error for unconstrained type
       // parameters, rather than silently inferring dynamic.
       if (upperBound.isBottom ||
           !_typeSystem.isSubtypeOf(lowerBound, upperBound)) {
         // Inference failed.
         if (errorReporter == null) {
@@ skipping 22 matching lines @@
           variance.passedIn && !upperBound.isDynamic || lowerBound.isBottom
               ? upperBound
               : lowerBound;
     }
 
     // Return the instantiated type.
     return genericType.instantiate(inferredTypes) as dynamic/*=T*/;
   }
 
   @override
-  bool _inferTypeParameterSubtypeOf(DartType t1, DartType t2) {
+  bool _isSubtypeOf(DartType t1, DartType t2, Set<Element> visited,
+      {bool dynamicIsBottom: false}) {
+    // TODO(jmesserly): the trivial constraints are not treated as part of
+    // the constraint set here. This seems incorrect once we are able to pin the
+    // inferred type of a type parameter based on the downwards information.
+    if (identical(t1, t2) ||
+        _isTop(t2, dynamicIsBottom: dynamicIsBottom) ||
+        _isBottom(t1, dynamicIsBottom: dynamicIsBottom)) {
+      return true;
+    }
+
     if (t1 is TypeParameterType) {
+      // TODO(jmesserly): we ignore `dynamicIsBottom` here, is that correct?
       _TypeParameterBound bound = _bounds[t1];
       if (bound != null) {
         // Ensure T1 <: T2, where T1 is a type parameter we are inferring.
         // T2 is an upper bound, so merge it with our existing upper bound.
         //
         // We already know T1 <: U, for some U.
         // So update U to reflect the new constraint T1 <: GLB(U, T2)
         //
         bound.upper = _typeSystem.getGreatestLowerBound(bound.upper, t2);
         // Optimistically assume we will be able to satisfy the constraint.
         return true;
       }
     }
     if (t2 is TypeParameterType) {
       _TypeParameterBound bound = _bounds[t2];
       if (bound != null) {
         // Ensure T1 <: T2, where T2 is a type parameter we are inferring.
         // T1 is a lower bound, so merge it with our existing lower bound.
         //
         // We already know L <: T2, for some L.
         // So update L to reflect the new constraint LUB(L, T1) <: T2
         //
         bound.lower = _typeSystem.getLeastUpperBound(bound.lower, t1);
         // Optimistically assume we will be able to satisfy the constraint.
         return true;
       }
     }
-    return false;
+    return super
+        ._isSubtypeOf(t1, t2, visited, dynamicIsBottom: dynamicIsBottom);
   }
 }
 
 /// An [upper] and [lower] bound for a type variable.
 class _TypeParameterBound {
   /// The upper bound of the type parameter. In other words, T <: upperBound.
   ///
   /// In Dart this can be written as `<T extends UpperBoundType>`.
   ///
   /// In inference, this can happen as a result of parameters of function type.
@@ skipping 93 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }