fix #26992, inference failures are now an error

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;
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptionsImpl;
+import 'package:analyzer/src/generated/error.dart'
+    show ErrorCode, ErrorReporter, StrongModeCode;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/utilities_dart.dart' show ParameterKind;
 import 'package:analyzer/src/generated/utilities_general.dart'
     show JenkinsSmiHash;
 
 typedef bool _GuardedSubtypeChecker<T>(T t1, T t2, Set<Element> visited);
 
 /**
  * Implementation of [TypeSystem] using the strong mode rules.
  * https://github.com/dart-lang/dev_compiler/blob/master/STRONG_MODE.md
@@ skipping 214 matching lines @@
 
     // Try to infer and instantiate the resulting type.
     var resultType = inferringTypeSystem._infer(fnType);
 
     // 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(
       TypeProvider typeProvider,
       FunctionType fnType,
       List<DartType> correspondingParameterTypes,
       List<DartType> argumentTypes,
-      DartType returnContextType) {
+      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)
@@ skipping 12 matching lines @@
       inferringTypeSystem.isSubtypeOf(fnType.returnType, 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]);
     }
 
-    return inferringTypeSystem._infer(fnType);
+    return inferringTypeSystem._infer(fnType, 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 1045 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) {
+  FunctionType _infer(FunctionType fnType,
+      [ErrorReporter errorReporter, AstNode errorNode]) {
     List<TypeParameterType> fnTypeParams =
         TypeParameterTypeImpl.getTypes(fnType.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);
@@ skipping 31 matching lines @@
       // 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);
 
       _TypeParameterBound bound = _bounds[typeParam];
-      inferredTypes[i] =
-          variance.passedIn || bound.lower.isBottom ? bound.upper : bound.lower;
+      DartType lowerBound = bound.lower;
+      DartType upperBound = bound.upper;
 
       // See if the bounds can be satisfied.
-      if (bound.upper.isBottom ||
-          !_typeSystem.isSubtypeOf(bound.lower, bound.upper)) {
-        // Inference failed. Bail.
-        return null;
+      // 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) {
+          return null;
+        }
+        errorReporter.reportErrorForNode(StrongModeCode.COULD_NOT_INFER,
+            errorNode, [typeParam, lowerBound, upperBound]);
+
+        // To make the errors more useful, we swap the normal heuristic.
+        //
+        // The normal heuristic prefers using the argument types (upwards
+        // inference, lower bound) to choose a tighter type.
+        //
+        // Here we want to prefer the return context type, so we can put the
+        // blame on the arguments to the function. That will result in narrow
+        // error spans. But ultimately it's just a heuristic, as the code is
+        // already erroneous.
+        //
+        // (we may adjust the normal heuristic too, once upwards+downwards
+        // 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);
   }
 
   @override
   bool _inferTypeParameterSubtypeOf(
       DartType t1, DartType t2, Set<Element> visited) {
     if (t1 is TypeParameterType) {
@@ skipping 253 matching lines @@
 }
 
 bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
   return (t.isDynamic && dynamicIsBottom) || t.isBottom;
 }
 
 bool _isTop(DartType t, {bool dynamicIsBottom: false}) {
   // TODO(leafp): Document the rules in play here
   return (t.isDynamic && !dynamicIsBottom) || t.isObject;
 }