[CSOptimizer] Consider choices marked as @_disfavoredOverload

These choices could be better than some other non-disfavored ones
in certain situations i.e. when `async` overload is disfavored
but appears in async context it's preferrable to a non-async
overload choice.

Note that the code that mimic old hacks still needs to filter on
`@_disfavoredOverload` in few places to maintain source compatibility.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -371,10 +371,9 @@ static ValueDecl *isViableOverloadChoice(ConstraintSystem &cs,
     }
   }
 
-  // If disjunction choice is unavailable or disfavored we cannot
+  // If disjunction choice is unavailable we cannot
   // do anything with it.
-  if (decl->getAttrs().hasAttribute<DisfavoredOverloadAttr>() ||
-      cs.isDeclUnavailable(decl, locator))
+  if (cs.isDeclUnavailable(decl, locator))
     return nullptr;
 
   return decl;
@@ -621,8 +620,13 @@ static void findFavoredChoicesBasedOnArity(
   forEachDisjunctionChoice(
       cs, disjunction,
       [&](Constraint *choice, ValueDecl *decl, FunctionType *overloadType) {
-        if (isVariadicGenericOverload(decl))
+        if (decl->getAttrs().hasAttribute<DisfavoredOverloadAttr>())
+          return;
+
+        if (isVariadicGenericOverload(decl)) {
           hasVariadicGenerics = true;
+          return;
+        }
 
         if (overloadType->getNumParams() == argumentList->size() ||
             llvm::count_if(*getParameterList(decl), [](auto *param) {
@@ -661,7 +665,8 @@ static std::optional<DisjunctionInfo> preserveFavoringOfUnlabeledUnaryArgument(
           return false;
 
         return isa<ProtocolDecl>(decl->getDeclContext()) ||
-               isVariadicGenericOverload(decl);
+               (!decl->getAttrs().hasAttribute<DisfavoredOverloadAttr>() &&
+                isVariadicGenericOverload(decl));
       }))
     return std::nullopt;
 
@@ -721,6 +726,9 @@ static std::optional<DisjunctionInfo> preserveFavoringOfUnlabeledUnaryArgument(
       cs, disjunction,
       [&argumentType, &favoredChoices, &argument](
           Constraint *choice, ValueDecl *decl, FunctionType *overloadType) {
+        if (decl->getAttrs().hasAttribute<DisfavoredOverloadAttr>())
+          return;
+
         if (overloadType->getNumParams() != 1)
           return;
 

test/Constraints/old_hack_related_ambiguities.swift

@@ -360,3 +360,26 @@ class TestFailableOnly {
     }
   }
 }
+
+do {
+  @_disfavoredOverload
+  func test(over: Int, that: String = "", block: @escaping (Int) throws -> Void) async throws {}
+  func test(over: Int, that: String = "", block: @escaping (Int) throws -> Void) throws {} // expected-note {{found this candidate}}
+  func test(over: Int, other: String = "", block: @escaping (Int) throws -> Void) throws {} // expected-note {{found this candidate}}
+
+  func performLocal(v: Int, block: @escaping (Int) throws -> Void) async throws {
+    try await test(over: v, block: block) // expected-error {{ambiguous use of 'test'}}
+  }
+
+  // The hack applied only to `OverloadedDeclRefExpr`s.
+  struct MemberTest {
+    @_disfavoredOverload
+    func test(over: Int, that: String = "", block: @escaping (Int) throws -> Void) async throws {}
+    func test(over: Int, that: String = "", block: @escaping (Int) throws -> Void) throws {}
+    func test(over: Int, other: String = "", block: @escaping (Int) throws -> Void) throws {}
+
+    func performMember(v: Int, block: @escaping (Int) throws -> Void) async throws {
+      try await test(over: v, block: block) // Ok
+    }
+  }
+}