[ConstraintSystem] Favor resolving closures over any disjunction bind…

lib/Sema/CSBindings.cpp

@@ -246,7 +246,14 @@ bool ConstraintSystem::PotentialBindings::favoredOverDisjunction(
     // if it's something like a collection (where it has to pick
     // between a conversion and bridging conversion) or concrete
     // type let's prefer the disjunction.
-    return boundType->is<TypeVariableType>();
+    //
+    // We are looking through optionals here because it could be
+    // a situation where disjunction is formed to match optionals
+    // either as deep equality or optional-to-optional conversion.
+    // Such type variables might be connected to closure as well
+    // e.g. when result type is optional, so it makes sense to
+    // open closure before attempting such disjunction.
+    return boundType->lookThroughAllOptionalTypes()->is<TypeVariableType>();
   }
 
   return !InvolvesTypeVariables;

test/Constraints/closures.swift

@@ -953,3 +953,21 @@ class Foo<State: StateType> {
 func test_explicit_variadic_is_interpreted_correctly() {
   _ = { (T: String...) -> String in T[0] + "" } // Ok
 }
+
+// rdar://problem/59208419 - closure result type is incorrectly inferred to be a supertype
+func test_correct_inference_of_closure_result_in_presence_of_optionals() {
+  class A {}
+  class B : A {}
+
+  func foo(_: B) -> Int? { return 42 }
+
+  func bar<T: A>(_: (A) -> T?) -> T? {
+    return .none
+  }
+
+  guard let v = bar({ $0 as? B }),
+        let _ = foo(v) // Ok, v is inferred as `B`
+  else {
+    return;
+  }
+}