[Sema] Make change less risky for 6.2

Revert assertion changes and flip the condition to only apply when
doing completion.

Author: hamishknight

lib/Sema/TypeCheckExpr.cpp

@@ -288,31 +288,51 @@ static Expr *makeBinOp(ASTContext &Ctx, Expr *Op, Expr *LHS, Expr *RHS,
 
   if (auto *ternary = dyn_cast<TernaryExpr>(Op)) {
     // Resolve the ternary expression.
-    ASSERT(!ternary->isFolded() && "already folded if expr in sequence?!");
+    if (!Ctx.CompletionCallback) {
+      // In code completion we might call preCheckTarget twice - once for
+      // the first pass and once for the second pass. This is fine since
+      // preCheckTarget is idempotent.
+      assert(!ternary->isFolded() && "already folded if expr in sequence?!");
+    }
     ternary->setCondExpr(LHS);
     ternary->setElseExpr(RHS);
     return ternary;
   }
 
   if (auto *assign = dyn_cast<AssignExpr>(Op)) {
     // Resolve the assignment expression.
-    ASSERT(!assign->isFolded() && "already folded assign expr in sequence?!");
+    if (!Ctx.CompletionCallback) {
+      // In code completion we might call preCheckTarget twice - once for
+      // the first pass and once for the second pass. This is fine since
+      // preCheckTarget is idempotent.
+      assert(!assign->isFolded() && "already folded assign expr in sequence?!");
+    }
     assign->setDest(LHS);
     assign->setSrc(RHS);
     return assign;
   }
 
   if (auto *as = dyn_cast<ExplicitCastExpr>(Op)) {
     // Resolve the 'as' or 'is' expression.
-    ASSERT(!as->isFolded() && "already folded 'as' expr in sequence?!");
+    if (!Ctx.CompletionCallback) {
+      // In code completion we might call preCheckTarget twice - once for
+      // the first pass and once for the second pass. This is fine since
+      // preCheckTarget is idempotent.
+      assert(!as->isFolded() && "already folded 'as' expr in sequence?!");
+    }
     assert(RHS == as && "'as' with non-type RHS?!");
     as->setSubExpr(LHS);    
     return as;
   }
 
   if (auto *arrow = dyn_cast<ArrowExpr>(Op)) {
     // Resolve the '->' expression.
-    ASSERT(!arrow->isFolded() && "already folded '->' expr in sequence?!");
+    if (!Ctx.CompletionCallback) {
+      // In code completion we might call preCheckTarget twice - once for
+      // the first pass and once for the second pass. This is fine since
+      // preCheckTarget is idempotent.
+      assert(!arrow->isFolded() && "already folded '->' expr in sequence?!");
+    }
     arrow->setArgsExpr(LHS);
     arrow->setResultExpr(RHS);
     return arrow;
@@ -617,10 +637,9 @@ Expr *TypeChecker::foldSequence(SequenceExpr *expr, DeclContext *dc) {
   // the folded expression if we've already folded the sequence.
   // FIXME: We ought to fix completion to not pre-check multiple times, strictly
   // speaking it isn't idempotent (e.g for things like `markDirectCallee`).
-  if (auto *folded = expr->getFoldedExpr()) {
-    ASSERT(dc->getASTContext().CompletionCallback &&
-           "Attempting to fold sequence twice?");
-    return folded;
+  if (dc->getASTContext().CompletionCallback) {
+    if (auto *folded = expr->getFoldedExpr())
+      return folded;
   }
   // First resolve any unresolved decl references in operator positions.
   for (auto i : indices(expr->getElements())) {