[Completion] Only skip result builder expressions in the same builder

Previously we would skip any expression in a
result builder that didn't contain the completion
token, but that would cause issues if e.g the
result builder was needed to infer the type of a
variable that we're completing on. Instead, only
skip expressions in a result builder if the
completion token is in the same builder and the
expression itself doesn't contain the completion.

rdar://127154780

Author: hamishknight

lib/Sema/BuilderTransform.cpp

@@ -72,6 +72,9 @@ class ResultBuilderTransform
   DeclContext *dc;
   ResultBuilder builder;
 
+  /// The source range of the body.
+  SourceRange bodyRange;
+
   /// The result type of this result builder body.
   Type ResultType;
 
@@ -80,9 +83,9 @@ class ResultBuilderTransform
 
 public:
   ResultBuilderTransform(ConstraintSystem &cs, DeclContext *dc,
-                         Type builderType, Type resultTy)
+                         SourceRange bodyRange, Type builderType, Type resultTy)
       : ctx(cs.getASTContext()), dc(dc), builder(cs, dc, builderType),
-        ResultType(resultTy) {}
+        bodyRange(bodyRange), ResultType(resultTy) {}
 
   UnsupportedElt getUnsupportedElement() const { return FirstUnsupported; }
 
@@ -238,12 +241,14 @@ class ResultBuilderTransform
       // buildBlock higher.
       buildBlockArguments.push_back(expr);
     } else if (ctx.CompletionCallback && expr->getSourceRange().isValid() &&
+               containsIDEInspectionTarget(bodyRange, ctx.SourceMgr) &&
                !containsIDEInspectionTarget(expr->getSourceRange(),
                                             ctx.SourceMgr)) {
-      // A statement that doesn't contain the code completion expression can't
-      // influence the type of the code completion expression. Add a variable
-      // for it that we can put into the buildBlock call but don't add the
-      // expression itself into the transformed body to improve performance.
+      // A top-level expression that doesn't contain the code completion
+      // expression can't influence the type of the code completion expression
+      // if they're in the same result builder. Add a variable for it that we
+      // can put into the buildBlock call but don't add the expression itself
+      // into the transformed body to improve performance.
       auto *resultVar = buildPlaceholderVar(expr->getStartLoc(), newBody);
       buildBlockArguments.push_back(
           builder.buildVarRef(resultVar, expr->getStartLoc()));
@@ -1176,6 +1181,7 @@ ConstraintSystem::matchResultBuilder(AnyFunctionRef fn, Type builderType,
   // let's do it and cache the result.
   if (!transformedBody) {
     ResultBuilderTransform transform(*this, fn.getAsDeclContext(),
+                                     fn.getBody()->getSourceRange(),
                                      builderType, bodyResultType);
     auto *body = transform.apply(fn.getBody());
 

test/IDE/complete_rdar127154780.swift

@@ -0,0 +1,36 @@
+// RUN: %empty-directory(%t)
+// RUN: %swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+// rdar://127154780 - Make sure we provide completions on variables that rely
+// on result builders being solved.
+
+@resultBuilder
+enum Builder {
+  static func buildBlock<T>(_ x: T) -> T { x }
+}
+
+struct S {}
+
+struct R<T> {
+  init(@Builder _: () -> T) {}
+}
+
+extension R where T == S {
+  func bar() {}
+}
+
+func foo() {
+  let r = R() {
+    S()
+  }
+  r.#^COMPLETE1?check=COMPLETE^#
+
+  let fn = {
+    let r = R() {
+      S()
+    }
+    r.#^COMPLETE2?check=COMPLETE^#
+  }
+}
+// COMPLETE-DAG: Keyword[self]/CurrNominal:          self[#R<S>#]; name=self
+// COMPLETE-DAG: Decl[InstanceMethod]/CurrNominal:   bar()[#Void#]; name=bar()