[CodeCompletion] Avoid prechecking twice when typeCheckForCodeCompletion is given a non-applicable expression (NFC)

For code completion within a multi-statement closure, typeCheckExpression will
be called on the expression containing the closure, and potentially again on
the expression within the closure body that contains the completion location.
In the first call, the typeCheckForCodeCompletion pre-checks the expression as
part of determining whether a second call is going to be made (in which case
the first is not applicable for completion purposes) or not. In the case where
it's not applicable control is returned to the regular typeCheckExpression
code path, which would then precheck the expression again.

This just moves the precheck before the call out to typeCheckForCodeCompletion
so we avoid prechecking twice unecessarily.

Author: Nathan Hawes

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -825,7 +825,7 @@ static bool isViableForReTypeCheck(const Solution &S) {
 }
 
 bool TypeChecker::typeCheckForCodeCompletion(
-    SolutionApplicationTarget &target,
+    SolutionApplicationTarget &target, bool needsPrecheck,
     llvm::function_ref<void(const Solution &)> callback) {
   auto *DC = target.getDeclContext();
   auto &Context = DC->getASTContext();
@@ -867,7 +867,7 @@ bool TypeChecker::typeCheckForCodeCompletion(
   // (that are type-checked together with enclosing context)
   // and regular closures which are type-checked separately.
 
-  {
+  if (needsPrecheck) {
     // First, pre-check the expression, validating any types that occur in the
     // expression and folding sequence expressions.
     auto failedPreCheck = ConstraintSystem::preCheckExpression(
@@ -953,18 +953,8 @@ bool TypeChecker::typeCheckForCodeCompletion(
                                                fallback->DC, CTP_Unused,
                                                /*contextualType=*/Type(),
                                                /*isDiscarded=*/true);
-    if (fallback->SeparatePrecheck) {
-      typeCheckForCodeCompletion(completionTarget, callback);
-      return true;
-    }
-
-    switch (solveForCodeCompletion(completionTarget)) {
-    case CompletionResult::Ok:
-    case CompletionResult::Fallback:
-      break;
-    case CompletionResult::NotApplicable:
-      llvm_unreachable("fallback expr not applicable?");
-    }
+    typeCheckForCodeCompletion(completionTarget, fallback->SeparatePrecheck,
+                               callback);
   }
   return true;
 }
@@ -1084,7 +1074,8 @@ void DotExprTypeCheckCompletionCallback::fallbackTypeCheck() {
                                              /*isDiscared=*/true);
 
   TypeChecker::typeCheckForCodeCompletion(
-      completionTarget, [&](const Solution &S) { sawSolution(S); });
+      completionTarget, /*needsPrecheck*/true,
+      [&](const Solution &S) { sawSolution(S); });
 }
 
 void DotExprTypeCheckCompletionCallback::

lib/Sema/TypeCheckConstraints.cpp

@@ -326,14 +326,6 @@ TypeChecker::typeCheckExpression(
                                   "typecheck-expr", expr);
   PrettyStackTraceExpr stackTrace(Context, "type-checking", expr);
 
-  // First let's check whether given expression has a code completion
-  // token which requires special handling.
-  if (Context.CompletionCallback &&
-      typeCheckForCodeCompletion(target, [&](const constraints::Solution &S) {
-        Context.CompletionCallback->sawSolution(S);
-      }))
-    return None;
-
   // First, pre-check the expression, validating any types that occur in the
   // expression and folding sequence expressions.
   if (ConstraintSystem::preCheckExpression(
@@ -343,6 +335,15 @@ TypeChecker::typeCheckExpression(
   }
   target.setExpr(expr);
 
+  // Check whether given expression has a code completion token which requires
+  // special handling.
+  if (Context.CompletionCallback &&
+      typeCheckForCodeCompletion(target, /*needsPrecheck*/false,
+                                 [&](const constraints::Solution &S) {
+        Context.CompletionCallback->sawSolution(S);
+      }))
+    return None;
+
   // Construct a constraint system from this expression.
   ConstraintSystemOptions csOptions = ConstraintSystemFlags::AllowFixes;
 

lib/Sema/TypeChecker.h

@@ -591,7 +591,7 @@ FunctionType *getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
 /// \returns `true` if target was applicable and it was possible to infer
 /// types for code completion, `false` othrewise.
 bool typeCheckForCodeCompletion(
-    constraints::SolutionApplicationTarget &target,
+    constraints::SolutionApplicationTarget &target, bool needsPrecheck,
     llvm::function_ref<void(const constraints::Solution &)> callback);
 
 /// Check the key-path expression.