fix #27151, list and map literals infer using up and down info

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 345 matching lines @@
 
     // Since we're trying to infer the instantiation, we want to ignore type
     // formals as we check the parameters and return type.
     var inferFnType =
         fnType.instantiate(TypeParameterTypeImpl.getTypes(fnType.typeFormals));
     if (!inferringTypeSystem.isSubtypeOf(inferFnType, contextType)) {
       return fnType;
     }
 
     // Try to infer and instantiate the resulting type.
-    var resultType = inferringTypeSystem._infer(fnType);
+    var resultType = inferringTypeSystem._infer(
+        fnType, fnType.typeFormals, fnType.returnType);
 
     // If the instantiation failed (because some type variable constraints
     // could not be solved, in other words, we could not find a valid subtype),
     // then return the original type, so the error is in terms of it.
     //
     // It would be safe to return a partial solution here, but the user
     // experience may be better if we simply do not infer in this case.
     //
     // TODO(jmesserly): this heuristic is old. Maybe we should we issue the
     // inference error?
     return resultType ?? fnType;
   }
 
   /// Given a function type with generic type parameters, infer the type
   /// parameters from the actual argument types, and return the instantiated
   /// function type. If we can't, returns the original function type.
   ///
   /// Concretely, given a function type with parameter types P0, P1, ... Pn,
   /// result type R, and generic type parameters T0, T1, ... Tm, use the
   /// argument types A0, A1, ... An to solve for the type parameters.
   ///
   /// For each parameter Pi, we want to ensure that Ai <: Pi. We can do this by
   /// running the subtype algorithm, and when we reach a type parameter Tj,
   /// recording the lower or upper bound it must satisfy. At the end, all
   /// constraints can be combined to determine the type.
   ///
   /// As a simplification, we do not actually store all constraints on each type
   /// parameter Tj. Instead we track Uj and Lj where U is the upper bound and
   /// L is the lower bound of that type parameter.
-  FunctionType inferGenericFunctionCall(
+  /*=T*/ inferGenericFunctionCall/*<T extends ParameterizedType>*/(
       TypeProvider typeProvider,
-      FunctionType fnType,
-      List<DartType> correspondingParameterTypes,
+      /*=T*/ genericType,
+      List<DartType> declaredParameterTypes,
       List<DartType> argumentTypes,
+      DartType declaredReturnType,
       DartType returnContextType,
       {ErrorReporter errorReporter,
       AstNode errorNode}) {
-    if (fnType.typeFormals.isEmpty) {
-      return fnType;
-    }
-
-    // If we're in a future union context, choose either the Future<T> or the T
-    // based on the function's return type.
-    if (returnContextType is FutureUnionType) {
-      var futureUnion = returnContextType as FutureUnionType;
-      returnContextType =
-          isSubtypeOf(fnType.returnType, typeProvider.futureDynamicType)
-              ? futureUnion.futureOfType
-              : futureUnion.type;
+    // TODO(jmesserly): expose typeFormals on ParameterizedType.
+    List<TypeParameterElement> typeFormals = genericType is FunctionType
+        ? genericType.typeFormals
+        : genericType.typeParameters;
+    if (typeFormals.isEmpty) {
+      return genericType;
     }
 
     // Create a TypeSystem that will allow certain type parameters to be
     // inferred. It will optimistically assume these type parameters can be
     // subtypes (or supertypes) as necessary, and track the constraints that
     // are implied by this.
     var inferringTypeSystem =
-        new _StrongInferenceTypeSystem(typeProvider, this, fnType.typeFormals);
+        new _StrongInferenceTypeSystem(typeProvider, this, typeFormals);
 
     if (returnContextType != null) {
-      inferringTypeSystem.isSubtypeOf(fnType.returnType, returnContextType);
+      // If we're in a future union context, choose either the Future<T>
+      // or the T based on the declared return type.
+      if (returnContextType is FutureUnionType) {
+        var futureUnion = returnContextType as FutureUnionType;
+        returnContextType =
+            isSubtypeOf(declaredReturnType, typeProvider.futureDynamicType)
+                ? futureUnion.futureOfType
+                : futureUnion.type;
+      }
+
+      inferringTypeSystem.isSubtypeOf(declaredReturnType, returnContextType);
     }
 
     for (int i = 0; i < argumentTypes.length; i++) {
       // Try to pass each argument to each parameter, recording any type
       // parameter bounds that were implied by this assignment.
       inferringTypeSystem.isSubtypeOf(
-          argumentTypes[i], correspondingParameterTypes[i]);
+          argumentTypes[i], declaredParameterTypes[i]);
     }
 
-    return inferringTypeSystem._infer(fnType, errorReporter, errorNode);
+    return inferringTypeSystem._infer(
+        genericType, typeFormals, declaredReturnType, errorReporter, errorNode);
   }
 
   /**
    * Given a [DartType] [type], if [type] is an uninstantiated
    * parameterized type then instantiate the parameters to their
    * bounds. Specifically, if [type] is of the form
    * `<T0 extends B0, ... Tn extends Bn>.F` or
    * `class C<T0 extends B0, ... Tn extends Bn> {...}`
    * (where Bi is implicitly dynamic if absent),
    * compute `{I0/T0, ..., In/Tn}F or C<I0, ..., In>` respectively
@@ skipping 1057 matching lines @@
   final StrongTypeSystemImpl _typeSystem;
   final Map<TypeParameterType, _TypeParameterBound> _bounds;
 
   _StrongInferenceTypeSystem(this._typeProvider, this._typeSystem,
       Iterable<TypeParameterElement> typeFormals)
       : _bounds = new Map.fromIterable(typeFormals,
             key: (t) => t.type, value: (t) => new _TypeParameterBound());
 
   /// Given the constraints that were given by calling [isSubtypeOf], find the
   /// instantiation of the generic function that satisfies these constraints.
-  FunctionType _infer(FunctionType fnType,
+  /*=T*/ _infer/*<T extends ParameterizedType>*/(/*=T*/ genericType,
+      List<TypeParameterElement> typeFormals, DartType declaredReturnType,
       [ErrorReporter errorReporter, AstNode errorNode]) {
     List<TypeParameterType> fnTypeParams =
-        TypeParameterTypeImpl.getTypes(fnType.typeFormals);
+        TypeParameterTypeImpl.getTypes(typeFormals);
 
     // 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++) {
@@ skipping 26 matching lines @@
       // 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, fnType.returnType);
+          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)) {
@@ skipping 18 matching lines @@
         // inference are fully integrated, to prefer downwards info).
         lowerBound = bound.upper;
         upperBound = bound.lower;
       }
 
       inferredTypes[i] =
           variance.passedIn || lowerBound.isBottom ? upperBound : lowerBound;
     }
 
     // Return the instantiated type.
-    return fnType.instantiate(inferredTypes);
+    return genericType.instantiate(inferredTypes) as dynamic/*=T*/;

[Leaf, 2016/09/14 23:11:35]

Does this mean that .instantiate should have a better type?  Just curious, not
suggesting that we fix it now.

[Jennifer Messerly, 2016/09/14 23:18:41]

Maybe something like:

abstract class ParameterizedType<T extends ParameterizedType<T>> {
  // ...
  T instantiate(List<DartType> typeArgs);
}
abstract class InterfaceType extends ParameterizedType<InterfaceType> {
  // ...
  InterfaceType instantiate(List<DartType> typeArgs);
}
abstract class FunctionType extends ParameterizedType<FunctionType> {
  // ...
  FunctionType instantiate(List<DartType> typeArgs);
}


that's a lot of mechanism for just two cases :) so we could also just match
them:

if (genericType is FunctionType) {
  return genericType.instantiate(inferredTypes);
}
return (genericType as InterfaceType).instantiate(inferredTypes);


Or yet another option, return the list of type arguments and leave the
"instantiate" to the caller. That's more in line with how matchTypes works.
Might be cleaner?

   }
 
   @override
   bool _inferTypeParameterSubtypeOf(
       DartType t1, DartType t2, Set<Element> visited) {
     if (t1 is TypeParameterType) {
       _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.
@@ skipping 129 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }