[Diagnostics] Implement IgnoreAssignmentDestinationType::diagnoseForAmbiguity

For cases like this:

```swift
struct X {}
struct Y {}

func overloaded<T>(_ value: T) -> T { value }
func overloaded<T>(_ value: T) -> Int { 0 }

func test(x: inout X, y: Y) {
  x = overloaded(y)
}
```

Solver would record a `IgnoreAssignmentDestinationType` fix per overload,
`diagnoseForAmbiguity` could be used to properly diagnose ambiguity cases
like that.

Author: xedin

lib/Sema/CSFix.cpp

@@ -1111,6 +1111,43 @@ bool IgnoreAssignmentDestinationType::diagnose(const Solution &solution,
   return failure.diagnose(asNote);
 }
 
+bool IgnoreAssignmentDestinationType::diagnoseForAmbiguity(
+    CommonFixesArray commonFixes) const {
+  auto &cs = getConstraintSystem();
+
+  // If all of the types are the same let's try to diagnose
+  // this as if there is no ambiguity.
+  if (ContextualMismatch::diagnoseForAmbiguity(commonFixes))
+    return true;
+
+  auto *commonLocator = getLocator();
+  auto *assignment = castToExpr<AssignExpr>(commonLocator->getAnchor());
+
+  auto &solution = *commonFixes.front().first;
+  auto *calleeLocator = solution.getCalleeLocator(
+      solution.getConstraintLocator(assignment->getSrc()));
+  auto overload = solution.getOverloadChoiceIfAvailable(calleeLocator);
+  if (!overload)
+    return false;
+
+  auto memberName = overload->choice.getName().getBaseName();
+  auto destType = solution.getType(assignment->getDest());
+
+  auto &DE = cs.getASTContext().Diags;
+  // TODO(diagnostics): It might be good to add a tailored diagnostic
+  // for cases like this instead of using "contextual" one.
+  DE.diagnose(assignment->getSrc()->getLoc(),
+              diag::no_candidates_match_result_type,
+              memberName.userFacingName(),
+              solution.simplifyType(destType)->getRValueType());
+
+  for (auto &entry : commonFixes) {
+    entry.second->diagnose(*entry.first, /*asNote=*/true);
+  }
+
+  return true;
+}
+
 IgnoreAssignmentDestinationType *
 IgnoreAssignmentDestinationType::create(ConstraintSystem &cs, Type sourceTy,
                                         Type destTy,

lib/Sema/CSFix.h

@@ -1550,6 +1550,8 @@ class IgnoreAssignmentDestinationType final : public ContextualMismatch {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override;
+
   static IgnoreAssignmentDestinationType *create(ConstraintSystem &cs,
                                                  Type sourceTy, Type destTy,
                                                  ConstraintLocator *locator);

test/Generics/deduction.swift

@@ -25,7 +25,7 @@ func useIdentity(_ x: Int, y: Float, i32: Int32) {
   // Deduction where the result type and input type can get different results
   var xx : X, yy : Y
   xx = identity(yy) // expected-error{{cannot assign value of type 'Y' to type 'X'}}
-  xx = identity2(yy) // expected-error{{no exact matches in call to global function 'identity2'}}
+  xx = identity2(yy) // expected-error{{no 'identity2' candidates produce the expected contextual result type 'X'}}
 }
 
 func twoIdentical<T>(_ x: T, _ y: T) -> T {}
@@ -89,7 +89,7 @@ func testReturnTuple(_ x: Int, y: Float) {
   var _ : (Float, Float) = returnTuple(y)
 
   // <rdar://problem/22333090> QoI: Propagate contextual information in a call to operands
-  var _ : (Int, Float) = returnTuple(y) // expected-error{{cannot convert value of type 'Float' to expected argument type 'Int'}}
+  var _ : (Int, Float) = returnTuple(y) // expected-error{{conflicting arguments to generic parameter 'T' ('Float' vs. 'Int')}}
 }
 
 

test/ModuleInterface/Inputs/opaque-result-types-client.swift

@@ -20,7 +20,7 @@ func someTypeIsTheSame() {
   a = foo("") // expected-error{{cannot assign value of type 'some Foo' (result of 'foo') to type 'some Foo' (result of 'foo')}}
 
   var b = foo("")
-  b = foo(0) // expected-error{{cannot assign value of type 'some Foo' (result of 'foo') to type 'some Foo' (result of 'foo')}}
+  b = foo(0) // expected-error{{no 'foo' candidates produce the expected contextual result type 'some Foo'}}
   b = foo("")
 
   var c = foo(MyFoo())
@@ -33,7 +33,7 @@ func someTypeIsTheSame() {
 
   var d = barInt.foo(0)
   d = barInt.foo(0)
-  d = barString.foo(0) // expected-error{{cannot assign}}
+  d = barString.foo(0) // expected-error{{no 'foo' candidates produce the expected contextual result type 'some Foo'}}
   d = getAssocType(barInt)
   d = getAssocType(barString) // expected-error{{cannot assign}}
 
@@ -50,7 +50,7 @@ func someTypeIsTheSame() {
   d3 = getAssocSubscriptType(barString) // expected-error{{cannot assign}}
 
   var e = barString.foo(0)
-  e = barInt.foo(0) // expected-error{{cannot assign}}
+  e = barInt.foo(0) // expected-error{{no 'foo' candidates produce the expected contextual result type 'some Foo'}}
   e = barString.foo(0)
   e = getAssocType(barInt) // expected-error{{cannot assign}}
   e = getAssocType(barString)