fix #29108, improve inference error messages

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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.test.generated.strong_mode_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 1080 matching lines @@
     DartType cType = AstFinder
         .getTopLevelFunction(unit, "test")
         .element
         .localVariables[0]
         .type;
     Element elementC = AstFinder.getClass(unit, "C").element;
 
     _isInstantiationOf(_hasElement(elementC))([_isDynamic])(cType);
   }
 
+  test_inference_error_arguments() async {
+    Source source = addSource(r'''
+typedef R F<T, R>(T t);
+
+F<T, T> g<T>(F<T, T> f) => (x) => f(f(x));
+
+test() {
+  var h = g((int x) => 42.0);
+}
+ ''');
+    await computeAnalysisResult(source);
+    _expectInferenceError(
+        source,
+        [
+          StrongModeCode.COULD_NOT_INFER,
+          StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
+        ],
+        r'''
+Couldn't infer type parameter 'T'.
+
+Tried to infer 'double' for 'T' but it did not work:

[Leaf, 2017/03/20 22:46:55]

<bikeshed>
"it did not work" feels a bit clunky to me.  What do you think of "which doesn't
work" instead?
</bikeshed>

[Jennifer Messerly, 2017/03/21 01:08:08]

Done.

+  Argument 'f' inferred as '(int) → double'

[Leaf, 2017/03/20 22:46:55]

The key to this section is making it absolutely 100% crystal clear that the
first type is the type of the actual argument, and the second type is the
declared type of the parameter.  What do you think of 

Parameter 'f' declared as `(T) -> T`
Argument has type '(int) -> double'

?

This is also consistent with the order and phrasing that you use for other kinds
of constraints below (`Return type declared as...`, `Function type declared
as...`).

[Jennifer Messerly, 2017/03/21 01:08:36]

oops! also I did this one too. Forgot to save comment :)

+               must be a   '(T) → T'.

[Jennifer Messerly, 2017/03/20 22:03:27]

should we show this as (double) → double?

... it's interesting we'd do this with argument types but not return type.
Maybe it's the wording? Or does it make sense because the direction is
different?

+
+Consider passing explicit type argument(s) to the generic.
+
+''');
+  }
+
+  test_inference_error_arguments2() async {
+    Source source = addSource(r'''
+typedef R F<T, R>(T t);
+
+F<T, T> g<T>(F<T, T> a, F<T, T> b) => (x) => a(b(x));
+
+test() {
+  var h = g((int x) => 42.0, (double x) => 42);
+}
+ ''');
+    await computeAnalysisResult(source);
+    _expectInferenceError(
+        source,
+        [
+          StrongModeCode.COULD_NOT_INFER,
+          StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE,
+          StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
+        ],
+        r'''
+Couldn't infer type parameter 'T'.
+
+Tried to infer 'num' for 'T' but it did not work:
+  Argument 'a' inferred as '(int) → double'
+               must be a   '(T) → T'.
+  Argument 'b' inferred as '(double) → int'
+               must be a   '(T) → T'.
+
+Consider passing explicit type argument(s) to the generic.
+
+''');
+  }
+
+  test_inference_error_extendsFromReturn() async {
+    // This is not an inference error because we successfully infer Null.
+    Source source = addSource(r'''
+T max<T extends num>(T x, T y) => x;
+
+test() {
+  String hello = max(1, 2);
+}
+ ''');
+    var analysisResult = await computeAnalysisResult(source);
+    assertErrors(source, [
+      StrongModeCode.INVALID_CAST_LITERAL,
+      StrongModeCode.INVALID_CAST_LITERAL
+    ]);
+    var unit = analysisResult.unit;
+    var h = (AstFinder.getStatementsInTopLevelFunction(unit, "test")[0]
+            as VariableDeclarationStatement)
+        .variables
+        .variables[0];
+    var call = h.initializer as MethodInvocation;
+    expect(call.staticInvokeType.toString(), '(Null, Null) → Null');
+  }
+
+  test_inference_error_extendsFromReturn2() async {
+    Source source = addSource(r'''
+typedef R F<T, R>(T t);
+F<T, T> g<T extends num>() => (y) => y;
+
+test() {
+  F<String, String> hello = g();
+}
+ ''');
+    await computeAnalysisResult(source);
+    _expectInferenceError(
+        source,
+        [
+          StrongModeCode.COULD_NOT_INFER,
+        ],
+        r'''
+Couldn't infer type parameter 'T'.
+
+Tried to infer 'String' for 'T' but it did not work:
+  Type parameter 'T' declared to extend 'num'.

[Jennifer Messerly, 2017/03/20 22:03:27]

like I feel this one is pretty good, but YMMV

[Leaf, 2017/03/20 22:46:55]

Agreed.

+The type 'String' was inferred from:
+  Return type declared as '(T) → T'
+              used where  '(String) → String' is required.
+
+Consider passing explicit type argument(s) to the generic.
+
+''');
+  }
+
+
+  test_inference_error_genericFunction() async {
+    Source source = addSource(r'''
+T max<T extends num>(T x, T y) => x < y ? y : x;
+abstract class Iterable<T> {
+  T get first;
+  S fold<S>(S s, S f(S s, T t));
+}
+test(Iterable values) {
+  num n = values.fold(values.first as num, max);
+}
+ ''');
+    await computeAnalysisResult(source);
+    _expectInferenceError(
+        source,
+        [
+          StrongModeCode.COULD_NOT_INFER,
+          StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
+        ],
+        r'''
+Couldn't infer type parameter 'T'.
+
+Tried to infer 'dynamic' for 'T' but it did not work:
+  Function type declared as '<T extends num>(T, T) → T'
+                used where  '(num, dynamic) → num' is required.
+
+Consider passing explicit type argument(s) to the generic.
+
+''');
+  }
+
+  test_inference_error_returnContext() async {
+    Source source = addSource(r'''
+typedef R F<T, R>(T t);
+
+F<T, T> g<T>(T t) => (x) => t;
+
+test() {
+  F<num, int> h = g(42);
+}
+ ''');
+    await computeAnalysisResult(source);
+    _expectInferenceError(
+        source,
+        [StrongModeCode.COULD_NOT_INFER],
+        r'''
+Couldn't infer type parameter 'T'.
+
+Tried to infer 'num' for 'T' but it did not work:
+  Return type declared as '(T) → T'
+              used where  '(num) → int' is required.
+
+Consider passing explicit type argument(s) to the generic.
+
+''');
+  }
+
   test_inference_hints() async {
     Source source = addSource(r'''
       void main () {
         var x = 3;
         List<int> l0 = [];
      }
    ''');
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 1019 matching lines @@
       typeTest(exp.staticType);
     }
 
     check("f0", _isListOf(_isDynamic));
     check("f1", _isListOf(_isDynamic));
 
     check("f2", _isListOf(_isInt));
     check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 
+  /// Verifies the source has the expected [errorCodes] as well as the
+  /// expected [errorMessage].
+  void _expectInferenceError(
+      Source source, List<ErrorCode> errorCodes, String errorMessage) {
+    assertErrors(source, errorCodes);
+    var errors = analysisResults[source]
+        .errors
+        .where((e) => e.errorCode == StrongModeCode.COULD_NOT_INFER)
+        .map((e) => e.message)
+        .toList();
+    expect(errors.length, 1);
+    var actual = errors[0];
+    expect(actual,
+        errorMessage, // Print the literal error message for easy copy+paste:
+        reason: 'Actual error did not match expected error:\n$actual');
+  }
+
   /// Helper method for testing `FutureOr<T>`.
   ///
   /// Validates that [code] produces [errors]. It should define a function
   /// "test", whose body is an expression that invokes a method. Returns that
   /// invocation.
   Future<MethodInvocation> _testFutureOr(String code,
       {List<ErrorCode> errors}) async {
     Source source = addSource("""
     import "dart:async";
     $code""");
@@ skipping 1520 matching lines @@
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     CompilationUnit unit = await resolveSource(code);
     assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 }