[CodeComplete] Skip conjunction elements unrelated to the code completion token

Author: ahoppen

lib/Sema/BuilderTransform.cpp

@@ -195,6 +195,15 @@ class ResultBuilderTransform
       // Allocate variable with a placeholder type
       auto *resultVar = buildPlaceholderVar(stmt->getStartLoc(), newBody);
 
+      if (ctx.CompletionCallback && stmt->getSourceRange().isValid() &&
+          !containsIDEInspectionTarget(stmt->getSourceRange(), ctx.SourceMgr) &&
+          !isa<GuardStmt>(stmt)) {
+        // A statement that doesn't contain the code completion expression can't
+        // influence the type of the code completion expression, so we can skip
+        // it to improve performance.
+        return None;
+      }
+
       auto result = visit(stmt, resultVar);
       if (!result)
         return UnsupportedElt(stmt);
@@ -223,6 +232,16 @@ class ResultBuilderTransform
       // to rank code completion items that match the type expected by
       // buildBlock higher.
       buildBlockArguments.push_back(expr);
+    } else if (ctx.CompletionCallback && expr->getSourceRange().isValid() &&
+               !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.
+      auto *resultVar = buildPlaceholderVar(expr->getStartLoc(), newBody);
+      buildBlockArguments.push_back(
+          builder.buildVarRef(resultVar, expr->getStartLoc()));
     } else {
       auto *capture = captureExpr(expr, newBody);
       // A reference to the synthesized variable is passed as an argument

lib/Sema/CSSyntacticElement.cpp

@@ -1167,17 +1167,26 @@ class SyntacticElementConstraintGenerator
     for (auto element : braceStmt->getElements()) {
       if (cs.isForCodeCompletion() &&
           !cs.containsIDEInspectionTarget(element)) {
-        // Statements and expressions can't influence the expresion that
-        // contains the code completion token. To improve performance, skip
-        // type checking them entirely.
-        if (element.is<Expr *>() && !element.isExpr(ExprKind::TypeJoin)) {
-          // Type join expressions are not really pure expressions, they kind of
-          // declare new type variables and are important to a result builder's
-          // structure. Don't skip them.
-          continue;
-        } else if (element.is<Stmt *>() && !element.isStmt(StmtKind::Guard)) {
+        // To improve performance, skip type checking elements that can't
+        // influence the code completion token.
+        if (element.is<Stmt *>() && !element.isStmt(StmtKind::Guard) && !element.isStmt(StmtKind::Return)) {
+          // Statements can't influence the expresion that contains the code
+          // completion token.
           // Guard statements might define variables that are used in the code
           // completion expression. Don't skip them.
+          // Return statements influence the type of the closure itself. Don't
+          // skip them either.
+          continue;
+        }
+        if (element.isExpr(ExprKind::Assign)) {
+          // Assignments are also similar to statements and can't influence the
+          // code completion token.
+          continue;
+        }
+        if (element.isExpr(ExprKind::Error)) {
+          // ErrorExpr can't influcence the expresssion that contains the code
+          // completion token. Since they are causing type checking to abort
+          // early, just skip them.
           continue;
         }
       }

test/IDE/complete_trailing_if_expr.swift

@@ -0,0 +1,24 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+struct MyStruct {
+  func takeAnotherClosure(_ y: () -> Void) {}
+}
+
+func takeClosure(_ x: () -> Void) -> MyStruct {}
+
+func foo() {
+  takeClosure {
+    #^COMPLETE^#
+  }.takeAnotherClosure {
+    if true {
+      1
+    } else {
+      1
+    }
+  }
+}
+
+// COMPLETE: Begin completions
+// COMPLETE: Decl[Struct]/CurrModule:            MyStruct[#MyStruct#]; name=MyStruct
+// COMPLETE: End completions

test/IDE/complete_with_adjacent_string_literal.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+func takeClosure(x: () -> Void) {}
+func takeString(_ a: String) -> MyStruct {}
+
+struct MyStruct {
+  func style() {}
+}
+
+func foo() {
+  takeClosure {
+    takeString("\(1)")
+      .style(#^COMPLETE^#)
+  }
+}