[Completion] Skip tryOptimizeGenericDisjunction if there's a completion child

Attempting to favor a disjunction choice here
can lead to unhelpful results if there's e.g a code
completion token argument, since it acts as a
placeholder.

rdar://127844278

Author: hamishknight

lib/Sema/CSSolver.cpp

@@ -2064,9 +2064,20 @@ Constraint *ConstraintSystem::getUnboundBindOverloadDisjunction(
 
 // Performance hack: if there are two generic overloads, and one is
 // more specialized than the other, prefer the more-specialized one.
-static Constraint *tryOptimizeGenericDisjunction(
-                                          DeclContext *dc,
-                                          ArrayRef<Constraint *> constraints) {
+static Constraint *
+tryOptimizeGenericDisjunction(ConstraintSystem &cs, Constraint *disjunction,
+                              ArrayRef<Constraint *> constraints) {
+  auto *dc = cs.DC;
+
+  // If we're solving for code completion, and have a child completion token,
+  // skip this optimization since the completion token being a placeholder can
+  // allow us to prefer an unhelpful disjunction choice.
+  if (cs.isForCodeCompletion()) {
+    auto anchor = disjunction->getLocator()->getAnchor();
+    if (cs.containsIDEInspectionTarget(cs.includingParentApply(anchor)))
+      return nullptr;
+  }
+
   llvm::SmallVector<Constraint *, 4> choices;
   for (auto *choice : constraints) {
     if (choices.size() > 2)
@@ -2311,7 +2322,7 @@ void DisjunctionChoiceProducer::partitionDisjunction(
     SmallVectorImpl<unsigned> &PartitionBeginning) {
   // Apply a special-case rule for favoring one generic function over
   // another.
-  if (auto favored = tryOptimizeGenericDisjunction(CS.DC, Choices)) {
+  if (auto favored = tryOptimizeGenericDisjunction(CS, Disjunction, Choices)) {
     CS.favorConstraint(favored);
   }
 

test/IDE/complete_rdar127844278.swift

@@ -0,0 +1,35 @@
+// RUN: %batch-code-completion
+
+// rdar://127844278 - Make sure we don't attempt to favor one buildExpression
+// call over the other when there's a child code completion.
+
+protocol P {}
+protocol Q: P {}
+
+struct S<T>: P {
+  private init() {}
+}
+
+extension S where T == () {
+  init(a: Void) {}
+}
+extension S: Q where T == String {
+  init(b: String) {}
+}
+
+@resultBuilder struct Builder {
+  static func buildExpression<T: P>(_ x: T) -> T { x }
+  static func buildExpression<T: Q>(_ x: T) -> T { x }
+
+  static func buildBlock<T: P>(_ x: T) -> some P { x }
+  static func buildBlock<T: Q>(_ x: T) -> some P { x }
+}
+
+func foo<T>(@Builder _: () -> T) where T: P {}
+func foo<T>(@Builder _: () -> T) where T: Q {}
+
+foo {
+  S(#^COMPLETE^#)
+}
+// COMPLETE-DAG: Decl[Constructor]/CurrNominal/Flair[ArgLabels]: ['(']{#a: Void#}[')'][#S<()>#]; name=a:
+// COMPLETE-DAG: Decl[Constructor]/CurrNominal/Flair[ArgLabels]: ['(']{#b: String#}[')'][#S<String>#]; name=b: