[CSBindings] Allow subtype inference from Void? for closure result types

We don't want to do that in general because injection should happen
only in one place but Void is special because it allows conversions
in that position.

Author: xedin

lib/Sema/CSBindings.cpp

@@ -2584,7 +2584,8 @@ bool TypeVarBindingProducer::computeNext() {
         //
         // Let's not perform $T? -> $T for closure result types to avoid having
         // to re-discover solutions that differ only in location of optional
-        // injection.
+        // injection. `Void` is a special case because in $T_result position
+        // it has special semantics and enables T? -> Void conversions.
         //
         // The pattern with such type variables is:
         //
@@ -2595,7 +2596,7 @@ bool TypeVarBindingProducer::computeNext() {
         // expression is non-optional), if we allow  both the solver would
         // find two solutions that differ only in location of optional
         // injection.
-        if (!TypeVar->getImpl().isClosureResultType()) {
+        if (!TypeVar->getImpl().isClosureResultType() || objTy->isVoid()) {
           // If T is a type variable, only attempt this if both the
           // type variable we are trying bindings for, and the type
           // variable we will attempt to bind, both have the same

test/Constraints/closures.swift

@@ -1283,3 +1283,25 @@ do {
     }
   }
 }
+
+// Make sure that closure gets both Void? and Void attempted
+// otherwise it won't be possible to type-check the second closure.
+do {
+  struct Semaphore {
+    func signal() -> Int {}
+  }
+
+  func compute(_ completion: (Semaphore?) -> Void?) {}
+
+  func test() {
+    compute { $0?.signal() }
+    // expected-warning@-1 {{result of call to 'signal()' is unused}}
+
+    true
+      ? compute({ $0?.signal() }) // expected-warning {{result of call to 'signal()' is unused}}
+      : compute({
+           let sem = $0!
+           sem.signal() // expected-warning {{result of call to 'signal()' is unused}}
+        })
+  }
+}