Merge pull request #67915 from xedin/rdar-113745963

Revert "[CSBindings] Prefer conjunctions over closure variables without bindings"

Author: xedin

lib/Sema/CSBindings.cpp

@@ -1094,13 +1094,6 @@ bool BindingSet::favoredOverConjunction(Constraint *conjunction) const {
   if (locator->directlyAt<ClosureExpr>()) {
     auto *closure = castToExpr<ClosureExpr>(locator->getAnchor());
 
-    // If there are no bindings for the closure yet we cannot prioritize
-    // it because that runs into risk of missing a result builder transform.
-    if (TypeVar->getImpl().isClosureType()) {
-      if (Bindings.empty())
-        return false;
-    }
-
     if (auto transform = CS.getAppliedResultBuilderTransform(closure)) {
       // Conjunctions that represent closures with result builder transformed
       // bodies could be attempted right after their resolution if they meet

test/Constraints/closure_resolution_order.swift

@@ -0,0 +1,61 @@
+// RUN: %target-typecheck-verify-swift
+
+// rdar://113745963
+
+// https://github.com/apple/swift/pull/67441 changed closure resolution order which makes the following code fail to type-check.
+
+struct Date : Equatable {
+  static var distantPast = Date()
+}
+
+enum Request {
+  struct Options: OptionSet {
+    static let option1 = Options(rawValue: 1 << 0)
+    static let option2 = Options(rawValue: 1 << 1)
+
+    let rawValue: Int
+
+    init(rawValue: Int) {
+      self.rawValue = rawValue
+    }
+  }
+
+  enum Source : Comparable {
+    case automatic
+    case manual(Date)
+
+    static func < (lhs: Source, rhs: Source) -> Bool { true }
+  }
+
+  case problem(options: Options, source: Source)
+}
+
+enum OuterSource {
+  case automatic, manual, unknown
+}
+
+struct Test {
+  func test(arr: [Int]) {
+    let _: [Request] = arr.map { value in
+      let source: OuterSource = .automatic
+      let dateAdded = Date.distantPast
+      return .problem(
+             options: {
+               switch source {
+               case .automatic:
+                 return [.option1, .option2]
+               case .manual, .unknown:
+                 return []
+               }
+             }(),
+             source: {
+               switch source {
+               case .manual:
+                 return .manual(dateAdded)
+               case .automatic, .unknown:
+                 return .automatic
+               }
+             }())
+    }
+  }
+}

test/Constraints/issue67363.swift

@@ -713,7 +713,8 @@ func test_result_builder_in_member_chaining() {
   Test.test {
     let test = Test()
     return test
-  }.builder { // Ok
+  // FIXME: This call should type-check, currently closure is resolved before overload of `builder` is picked.
+  }.builder { // expected-error {{cannot convert value of type '()' to closure result type 'Int'}}
     let result = ""
     result
   }