[CSSimplify] Propagate contextual result type into result builder transformed closure

Propagate fully or partially resolved contextual type down into
the body of result builder transformed closure by eagerly binding
intermediate body result type to the contextual one. This helps to
determine when closure body could be solved early.

Resolves: rdar://106364495

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -3532,11 +3532,29 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     }
   }
 
+  auto resultMatchKind = subKind;
+  // Performance optimization: Propagate fully or partially resolved contextual
+  // type down into the body of result builder transformed closure by eagerly
+  // binding intermediate body result type to the contextual one. This helps to
+  // determine when closure body could be solved early.
+  //
+  // TODO: This could be extended to cover all multi-statement closures.
+  //
+  // See \c BindingSet::favoredOverConjunction for more details.
+  if (resultMatchKind >= ConstraintKind::Subtype &&
+      !func2->getResult()->isTypeVariableOrMember()) {
+    if (auto *closure = getAsExpr<ClosureExpr>(locator.trySimplifyToExpr())) {
+      if (!closure->hasExplicitResultType() &&
+          getAppliedResultBuilderTransform(closure)) {
+        resultMatchKind = ConstraintKind::Equal;
+      }
+    }
+  }
+
   // Result type can be covariant (or equal).
-  return matchTypes(func1->getResult(), func2->getResult(), subKind,
-                     subflags,
-                     locator.withPathElement(
-                       ConstraintLocator::FunctionResult));
+  return matchTypes(func1->getResult(), func2->getResult(), resultMatchKind,
+                    subflags,
+                    locator.withPathElement(ConstraintLocator::FunctionResult));
 }
 
 ConstraintSystem::TypeMatchResult

test/Constraints/result_builder.swift

@@ -1383,3 +1383,22 @@ testOptionalIfElseSequences()
 // CHECK-NEXT: second(Optional(main.B()), nil)
 // CHECK-NEXT: second(nil, Optional(main.Either<main.C, main.D>.first(main.C())))
 // CHECK-NEXT: second(nil, Optional(main.Either<main.C, main.D>.second(main.D())))
+
+// rdar://106364495 - ambiguous use of `buildFinalResult`
+func testBuildFinalResultDependentOnContextualType() {
+  @resultBuilder
+  struct MyBuilder {
+    static func buildBlock(_ v: Int) -> Int { v }
+    static func buildFinalResult(_ v: Int) -> Int { v }
+    static func buildFinalResult(_ v: Int) -> String { "" }
+  }
+
+  func test(@MyBuilder _ fn: () -> Int?) { print(fn()) }
+
+  test {
+    42
+  }
+}
+
+testBuildFinalResultDependentOnContextualType()
+// CHECK: Optional(42)