[IDE] Don't fallback type check if the completion expression is inside a closure

Author: ahoppen

lib/IDE/PostfixCompletion.cpp

@@ -95,6 +95,14 @@ void PostfixCompletionCallback::fallbackTypeCheck(DeclContext *DC) {
     }
   }
 
+  if (isa<AbstractClosureExpr>(fallbackDC)) {
+    // If the expression is embedded in a closure, the constraint system tries
+    // to retrieve that closure's type, which will fail since we won't have
+    // generated any type variables for it. Thus, fallback type checking isn't
+    // available in this case.
+    return;
+  }
+
   SyntacticElementTarget completionTarget(fallbackExpr, fallbackDC, CTP_Unused,
                                           Type(),
                                           /*isDiscared=*/true);

lib/IDE/TypeCheckCompletionCallback.cpp

@@ -28,8 +28,13 @@ void TypeCheckCompletionCallback::fallbackTypeCheck(DeclContext *DC) {
     return;
 
   auto fallback = finder.getFallbackCompletionExpr();
-  if (!fallback)
+  if (!fallback || isa<AbstractClosureExpr>(fallback->DC)) {
+    // If the expression is embedded in a closure, the constraint system tries
+    // to retrieve that closure's type, which will fail since we won't have
+    // generated any type variables for it. Thus, fallback type checking isn't
+    // available in this case.
     return;
+  }
 
   SyntacticElementTarget completionTarget(fallback->E, fallback->DC, CTP_Unused,
                                           Type(),

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -301,6 +301,13 @@ static Type
 getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
                                    ConcreteDeclRef &referencedDecl,
                                  FreeTypeVariableBinding allowFreeTypeVariables) {
+  if (isa<AbstractClosureExpr>(dc)) {
+    // If the expression is embedded in a closure, the constraint system tries
+    // to retrieve that closure's type, which will fail since we won't have
+    // generated any type variables for it. Thus, fallback type checking isn't
+    // available in this case.
+    return Type();
+  }
   auto &Context = dc->getASTContext();
 
   expr = expr->walk(SanitizeExpr(Context));
@@ -647,18 +654,27 @@ bool TypeChecker::typeCheckForCodeCompletion(
 
   // Determine the best subexpression to use based on the collected context
   // of the code completion expression.
-  if (auto fallback = contextAnalyzer.getFallbackCompletionExpr()) {
-    if (auto *expr = target.getAsExpr()) {
-      assert(fallback->E != expr);
-      (void)expr;
-    }
-    SyntacticElementTarget completionTarget(fallback->E, fallback->DC,
-                                            CTP_Unused,
-                                            /*contextualType=*/Type(),
-                                            /*isDiscarded=*/true);
-    typeCheckForCodeCompletion(completionTarget, fallback->SeparatePrecheck,
-                               callback);
+  auto fallback = contextAnalyzer.getFallbackCompletionExpr();
+  if (!fallback) {
+    return true;
+  }
+  if (isa<AbstractClosureExpr>(fallback->DC)) {
+    // If the expression is embedded in a closure, the constraint system tries
+    // to retrieve that closure's type, which will fail since we won't have
+    // generated any type variables for it. Thus, fallback type checking isn't
+    // available in this case.
+    return true;
+  }
+  if (auto *expr = target.getAsExpr()) {
+    assert(fallback->E != expr);
+    (void)expr;
   }
+  SyntacticElementTarget completionTarget(fallback->E, fallback->DC,
+                                          CTP_Unused,
+                                          /*contextualType=*/Type(),
+                                          /*isDiscarded=*/true);
+  typeCheckForCodeCompletion(completionTarget, fallback->SeparatePrecheck,
+                             callback);
   return true;
 }
 

test/IDE/complete_in_closures.swift

@@ -498,3 +498,56 @@ func testBinaryOperatorWithEnum() {
 // BINARY_OPERATOR_WITH_ENUM: End completions
 
 }
+
+func testPreviousSyntacticElementHasError() {
+  struct MyStruct {}
+
+  class MyClass {
+    var myMember: Int = 1
+    var myString: String = "1"
+  }
+
+  @resultBuilder struct ViewBuilder {
+    static func buildBlock<Content>(_ content: Content) -> Content { content }
+  }
+
+  func buildView<Content>(@ViewBuilder content: () -> Content) -> Int { 0 }
+
+  func takeClosure(_ action: () -> Void) {}
+
+  func test(x: MyClass) {
+    // Not that the previous syntactic element (let a) has an error because we
+    // skip MyStruct inside the result builder for performance reasons.
+    takeClosure {
+      let a = buildView {
+        MyStruct()
+      }
+      x.#^PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR^#myMember = 1234
+    }
+  }
+// PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR: Begin completions
+// PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR-DAG: Keyword[self]/CurrNominal:          self[#MyClass#]; name=self
+// PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: myMember[#Int#]; name=myMember
+// PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR-DAG: Decl[InstanceVar]/CurrNominal:      myString[#String#]; name=myString
+// PREVIOUS_SYNTACTIC_ELEMENT_HAS_ERROR: End completions
+}
+
+func testCompleteAfterClosureWithIfExprThatContainErrors() {
+  _ = {
+    if true {
+      invalid(1)
+    } else if true {
+      invalid(2)
+    } else {
+      invalid(3)
+    }
+  }#^AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS^#
+
+  // FIXME: We shouldn't be suggesting 'self' and '()' twice here
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS: Begin completions, 4 items
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS-DAG: Keyword[self]/CurrNominal:          .self[#() -> _#]; name=self
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS-DAG: Keyword[self]/CurrNominal:          .self[#() -> ()#]; name=self
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS-DAG: Pattern/CurrModule/Flair[ArgLabels]: ()[#_#]; name=()
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS-DAG: Pattern/CurrModule/Flair[ArgLabels]: ()[#Void#]; name=()
+  // AFTER_CLOSURE_WITH_IF_EXPR_THAT_CONTAIN_ERRORS: End completions
+}

test/IDE/complete_multiple_trailingclosure_signatures.swift

@@ -24,3 +24,17 @@ func test() {
 // GLOBALFUNC_SAMELINE-DAG: Pattern/Local/Flair[ArgLabels]: {#fn7:  (inout Int) -> Void {<#inout Int#> in|}#}[#(inout Int) -> Void#];
 // GLOBALFUNC_SAMELINE-DAG: Pattern/Local/Flair[ArgLabels]: {#fn8:  (Int...) -> Void {<#Int...#> in|}#}[#(Int...) -> Void#];
 }
+
+func testStringAndMulipleTrailingClosures() {
+  func stringAndClosure(_ key: String, _ body: () -> Void) {}
+
+  func takeClosure(_ x: () -> Void) {}
+
+  takeClosure {
+    stringAndClosure("\(1)") { }#^STRING_AND_MULTIPLE_TRAILING_CLOSURES^#
+  }
+  // STRING_AND_MULTIPLE_TRAILING_CLOSURES: Begin completions
+  // STRING_AND_MULTIPLE_TRAILING_CLOSURES-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]/IsSystem:  == {#()#}[#Bool#];
+  // STRING_AND_MULTIPLE_TRAILING_CLOSURES-DAG: Keyword[self]/CurrNominal:          .self[#Void#]; name=self
+  // STRING_AND_MULTIPLE_TRAILING_CLOSURES: End completions
+}