[CodeComplete] Fall back to typechecking a single expression result builder doesn't typecheck

If a result builder body fails to typecheck, we currently don't provide any code completion results at all. Instead, try to recovery by type checking the expression in the result builder that conatins the code completion token on its own. This might be missing some information about contextual types but is preferrable over not providing any results at all.

Resolves rdar://78015510

Author: ahoppen

lib/Sema/TypeCheckStmt.cpp

@@ -1922,11 +1922,18 @@ bool TypeCheckASTNodeAtLocRequest::evaluate(Evaluator &evaluator,
     if (Type builderType = getResultBuilderType(func)) {
       auto optBody =
           TypeChecker::applyResultBuilderBodyTransform(func, builderType);
-      if (!optBody || !*optBody)
-        return true;
-      // Wire up the function body now.
-      func->setBody(*optBody, AbstractFunctionDecl::BodyKind::TypeChecked);
-      return false;
+      if (optBody && *optBody) {
+        // Wire up the function body now.
+        func->setBody(*optBody, AbstractFunctionDecl::BodyKind::TypeChecked);
+        return false;
+      }
+      // FIXME: We failed to apply the result builder transform. Fall back to
+      // just type checking the node that contains the code completion token.
+      // This may be missing some context from the result builder but in
+      // practice it often contains sufficient information to provide a decent
+      // level of code completion that's better than providing nothing at all.
+      // The proper solution would be to only partially type check the result
+      // builder so that this fall back would not be necessary.
     } else if (func->hasSingleExpressionBody() &&
                 func->getResultInterfaceType()->isVoid()) {
        // The function returns void.  We don't need an explicit return, no matter

test/IDE/complete_in_result_builder.swift

@@ -61,7 +61,7 @@ func testGlobalLookup() {
   @TupleBuilder<String> var x5 {
     "hello: \(#^GLOBAL_LOOKUP_IN_STRING_LITERAL^#)"
 // GLOBAL_LOOKUP_IN_STRING_LITERAL: Begin completions
-// GLOBAL_LOOKUP_IN_STRING_LITERAL: Decl[GlobalVar]/CurrModule: MyConstantString[#String#];
+// GLOBAL_LOOKUP_IN_STRING_LITERAL: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: MyConstantString[#String#];
 // GLOBAL_LOOKUP_IN_STRING_LITERAL: End completions
   }
 
@@ -103,7 +103,7 @@ struct FooStruct {
 func testPatternMatching() {
   @TupleBuilder<String> var x1 {
     let x = Letters.b
-    if case .#^COMPLETE_PATTERN_MATCHING_IN_IF?check=COMPLETE_CASE;xfail=rdar78015510^# = x {
+    if case .#^COMPLETE_PATTERN_MATCHING_IN_IF?check=COMPLETE_CASE^# = x {
 // COMPLETE_CASE: Begin completions
 // COMPLETE_CASE-DAG: Decl[EnumElement]/ExprSpecific/TypeRelation[Identical]: a[#Letters#];
 // COMPLETE_CASE-DAG: Decl[EnumElement]/ExprSpecific/TypeRelation[Identical]: b[#Letters#];
@@ -115,14 +115,14 @@ func testPatternMatching() {
   @TupleBuilder<String> var x2 {
     let x = Letters.a
     switch x {
-    case .#^COMPLETE_CASE_IN_SWITCH?check=COMPLETE_CASE;xfail=rdar78015510^#:
+    case .#^COMPLETE_CASE_IN_SWITCH?check=COMPLETE_CASE^#:
       break
     }
   }
 
   @TupleBuilder<String> var x3 {
     let x: FooStruct? = FooStruct()
-    guard case .#^GUARD_CASE_PATTERN_1?check=OPTIONAL_FOOSTRUCT;xfail=rdar78015510^# = x {}
+    guard case .#^GUARD_CASE_PATTERN_1?check=OPTIONAL_FOOSTRUCT^# = x {}
     // OPTIONAL_FOOSTRUCT: Begin completions, 9 items
     // OPTIONAL_FOOSTRUCT-DAG: Keyword[nil]/None/Erase[1]/TypeRelation[Identical]:         nil[#FooStruct?#]; name=nil
     // OPTIONAL_FOOSTRUCT-DAG: Decl[EnumElement]/CurrNominal/IsSystem/TypeRelation[Identical]: none[#Optional<FooStruct>#]; name=none
@@ -141,7 +141,7 @@ func testPatternMatching() {
 
   @TupleBuilder<String> var x4 {
     let x: FooStruct? = FooStruct()
-    guard case .#^GUARD_CASE_PATTERN_2?check=OPTIONAL_FOOSTRUCT;xfail=rdar78015510^#some() = x {}
+    guard case .#^GUARD_CASE_PATTERN_2?check=OPTIONAL_FOOSTRUCT^#some() = x {}
   }
 }