[CSOptimizer] Disable unary argument hack if overload set has requirements or variadic overloads

This matches the behavior of the old hack where favoring choices
were rolled back if `mustConsider` produced `true` which happened
only for protocol requirements and variadic overload choice regardless
of their viability.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -529,6 +529,20 @@ static unsigned numOverloadChoicesMatchingOnArity(OverloadedDeclRefExpr *ODRE,
   });
 }
 
+static bool isVariadicGenericOverload(ValueDecl *choice) {
+  auto genericContext = choice->getAsGenericContext();
+  if (!genericContext)
+    return false;
+
+  auto *GPL = genericContext->getGenericParams();
+  if (!GPL)
+    return false;
+
+  return llvm::any_of(GPL->getParams(), [&](const GenericTypeParamDecl *GP) {
+    return GP->isParameterPack();
+  });
+}
+
 /// This maintains an "old hack" behavior where overloads  of some
 /// `OverloadedDeclRef` calls were favored purely based on number of
 /// argument and (non-defaulted) parameters matching.
@@ -542,20 +556,6 @@ static void findFavoredChoicesBasedOnArity(
   if (numOverloadChoicesMatchingOnArity(ODRE, argumentList) > 1)
     return;
 
-  auto isVariadicGenericOverload = [&](ValueDecl *choice) {
-    auto genericContext = choice->getAsGenericContext();
-    if (!genericContext)
-      return false;
-
-    auto *GPL = genericContext->getGenericParams();
-    if (!GPL)
-      return false;
-
-    return llvm::any_of(GPL->getParams(), [&](const GenericTypeParamDecl *GP) {
-      return GP->isParameterPack();
-    });
-  };
-
   bool hasVariadicGenerics = false;
   SmallVector<Constraint *> favored;
 
@@ -591,6 +591,21 @@ static std::optional<DisjunctionInfo> preserveFavoringOfUnlabeledUnaryArgument(
           cs.getParentExpr(argumentList->getUnlabeledUnaryExpr())))
     return std::nullopt;
 
+  // The hack rolled back favoring choices if one of the overloads was a
+  // protocol requirement or variadic generic.
+  //
+  // Note that it doesn't matter whether such overload choices are viable
+  // or not, their presence disabled this "optimization".
+  if (llvm::any_of(disjunction->getNestedConstraints(), [](Constraint *choice) {
+        auto *decl = getOverloadChoiceDecl(choice);
+        if (!decl)
+          return false;
+
+        return isa<ProtocolDecl>(decl->getDeclContext()) ||
+               isVariadicGenericOverload(decl);
+      }))
+    return std::nullopt;
+
   auto ODRE = isOverloadedDeclRef(disjunction);
   bool preserveFavoringOfUnlabeledUnaryArgument =
       !ODRE || numOverloadChoicesMatchingOnArity(ODRE, argumentList) < 2;

test/Constraints/old_hack_related_ambiguities.swift

@@ -290,3 +290,39 @@ func test_that_unary_argument_hacks_do_not_apply_to_subscripts(dict: [String: My
   let value = dict["hello"]
   let _: MyValue? = value // Ok
 }
+
+// Unlabeled unary argument hack was disabled if there were any protocol requirements
+// or variadic generic overloads present in the result set (regadless of their viability).
+//
+// Remove the requirement and variadic overloads and this code would start failing even
+// though it shouldn't!
+
+struct Future<T> {
+}
+
+protocol DB {
+  func get(_: Int, _: Int) -> Future<Int?>
+}
+
+extension DB {
+  func get(_: Int, _: Int = 42) async throws -> Int? { nil }
+  func get(_: Int) -> Future<Int?> { .init() }
+
+  func fetch(_: Int, _: Int = 42) async throws -> Int? { nil }
+  func fetch(_: Int) -> Future<Int?> { .init() }
+  func fetch<each T>(values: repeat each T) -> Int { 42 }
+}
+
+struct TestUnary {
+  var db: any DB
+
+  func get(v: Int) async throws {
+    guard let _ = try await self.db.get(v) else { // Ok
+      return
+    }
+
+    guard let _ = try await self.db.fetch(v) else { // Ok
+      return
+    }
+  }
+}