Extend Future.then inference to subclasses

pkg/analyzer/lib/src/generated/static_type_analyzer.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.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1929 matching lines @@
         ParameterElement parameter = rawParameters[i];
         if (parameter != null) {
           paramTypes.add(parameter.type);
           argTypes.add(argumentList.arguments[i].staticType);
         }
       }
 
       DartType returnContext = InferenceContext.getContext(node);
       DartType returnType;
       if (returnContext is FutureUnionType) {
-        returnType = fnType.returnType.isDartAsyncFuture
+        returnType = _resolver.isSubtypeOfFuture(fnType.returnType)
             ? returnContext.futureOfType
             : returnContext.type;
       } else {
         returnType = returnContext;
       }
 
       // Special case Future<T>.then upwards inference. It has signature:
       //
       //     <S>(T -> (S | Future<S>)) -> Future<S>
       //
       // Based on the first argument type, we'll pick one of these signatures:
       //
       //     <S>(T -> S) -> Future<S>
       //     <S>(T -> Future<S>) -> Future<S>
       //
       // ... and finish the inference using that.
       if (argTypes.isNotEmpty && _resolver.isFutureThen(fnType.element)) {
         var firstArgType = argTypes[0];
         var firstParamType = paramTypes[0] as FunctionType;
         if (firstArgType is FunctionType) {
           var argReturnType = firstArgType.returnType;
           // Skip the inference if we have the top type. It can only lead to
           // worse inference. For example, this happens when the lambda returns
           // S or Future<S> in a conditional.
           if (!argReturnType.isObject && !argReturnType.isDynamic) {
             DartType paramReturnType = fnType.typeFormals[0].type;
-            if (argReturnType.isDartAsyncFuture) {
+            if (_resolver.isSubtypeOfFuture(argReturnType)) {
               // Given an argument of (T) -> Future<S>, instantiate with <S>
               paramReturnType =
                   _typeProvider.futureType.instantiate([paramReturnType]);
             }
 
             // Adjust the expected parameter type to have this return type.
             var function = new FunctionElementImpl(firstParamType.name, -1)
               ..synthetic = true
               ..shareParameters(firstParamType.parameters)
               ..returnType = paramReturnType;
             function.type = new FunctionTypeImpl(function);
-
             // Use this as the expected 1st parameter type.
             paramTypes[0] = function.type;
           }
         }
       }
-
       return ts.inferGenericFunctionCall(
           _typeProvider, fnType, paramTypes, argTypes, returnType);
     }
     return null;
   }
 
   /**
    * Given an instance creation of a possibly generic type, infer the type
    * arguments using the current context type as well as the argument types.
    */
   void _inferInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructor = node.constructorName;
     ConstructorElement originalElement = constructor.staticElement;
     // If the constructor is generic, we'll have a ConstructorMember that
     // substitutes in type arguments (possibly `dynamic`) from earlier in
     // resolution.
     //
     // Otherwise we'll have a ConstructorElement, and we can skip inference
     // because there's nothing to infer in a non-generic type.
     if (originalElement is! ConstructorMember) {
       return;
     }
 
+    // TODO(leafp): Currently, we may re-infer types here, since we
+    // sometimes resolve multiple times.  We should really check that we
+    // have not already inferred something.  However, the obvious ways to
+    // check this don't work, since we may have been instantiated
+    // to bounds in an earlier phase, and we *do* want to do inference
+    // in that case.
+
     // Get back to the uninstantiated generic constructor.
     // TODO(jmesserly): should we store this earlier in resolution?
     // Or look it up, instead of jumping backwards through the Member?
     var rawElement = (originalElement as ConstructorMember).baseElement;
 
     FunctionType constructorType =
         _constructorToGenericFunctionType(rawElement);
 
     ArgumentList arguments = node.argumentList;
     FunctionType inferred = _inferGenericInvoke(
@@ skipping 40 matching lines @@
       if (contextType is FutureUnionType) {
         // TODO(jmesserly): can we do something better here?
         computedType = body.isAsynchronous ? contextType.type : _dynamicType;
       } else {
         computedType = contextType ?? _dynamicType;
       }
       recordInference = !computedType.isDynamic;
     }
 
     computedType = _computeReturnTypeOfFunction(body, computedType);
-
     functionElement.returnType = computedType;
     _recordPropagatedTypeOfFunction(functionElement, node.body);
     _recordStaticType(node, functionElement.type);
     if (recordInference) {
       _resolver.inferenceContext.recordInference(node, functionElement.type);
     }
   }
 
   /**
    * Given a local variable declaration and its initializer, attempt to infer
@@ skipping 318 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }