[AST][RecoveryExpr] Preserve the AST for invalid conditions.

[hokein]

Summary

Tested with enabling "-frecovery-ast", only 1 failure, which is
an improvement of secondary diagnostic.

--
error: 'error' diagnostics seen but not expected:
  File /workspace/llvm-project/clang/test/SemaTemplate/instantiate-expr-3.cpp Line 68: invalid operands to binary expression ('N1::X' and 'int')
1 error generated.

--

[sammccall]

Nice!

[hokein]

rebase and adjust the test.

clang/lib/Sema/SemaExpr.cpp

Sema::ConditionResult Sema::ActOnCondition(Scope *S, SourceLocation Loc,
   case ConditionKind::ConstexprIf:
     Cond = CheckBooleanCondition(Loc, SubExpr, true);
     break;
 
   case ConditionKind::Switch:
     Cond = CheckSwitchCondition(Loc, SubExpr);
     break;
   }
-  if (Cond.isInvalid())
+  if (Cond.isInvalid()) {
+    Cond = CreateRecoveryExpr(SubExpr->getBeginLoc(), SubExpr->getEndLoc(),
+                              {SubExpr});
+    if (!Cond.get())
       return ConditionError();
-
+  }
   // FIXME: FullExprArg doesn't have an invalid bit, so check nullness instead.
   FullExprArg FullExpr = MakeFullExpr(Cond.get(), Loc);
   if (!FullExpr.get())
     return ConditionError();
 
   return ConditionResult(*this, nullptr, FullExpr,
                          CK == ConditionKind::ConstexprIf);
 }

clang/test/AST/ast-dump-recovery.cpp

 void ValueCategory() {
   // CHECK:  RecoveryExpr {{.*}} 'int' contains-errors
   prvalue(); // call to a function (nonreference return type) yields a prvalue (not print by default)
   // CHECK:  RecoveryExpr {{.*}} 'int' contains-errors lvalue
   lvalue(); // call to a function (lvalue reference return type) yields an lvalue.
   // CHECK:  RecoveryExpr {{.*}} 'int' contains-errors xvalue
   xvalue(); // call to a function (rvalue reference return type) yields an xvalue.
 }
+
+void InvalidCondition() {
+  // CHECK:      IfStmt {{.*}}
+  // CHECK-NEXT: |-RecoveryExpr {{.*}} <col:7, col:15> '<dependent type>' contains-errors
+  // CHECK-NEXT: | `-UnresolvedLookupExpr {{.*}} <col:7>
+  if (invalid()) {}
+
+  // CHECK:      WhileStmt {{.*}}
+  // CHECK-NEXT: |-RecoveryExpr {{.*}} <col:10, col:18> '<dependent type>' contains-errors
+  // CHECK-NEXT: | `-UnresolvedLookupExpr {{.*}} <col:10>
+  while (invalid()) {}
+
+  // CHECK:      SwitchStmt {{.*}}
+  // CHECK-NEXT: |-RecoveryExpr {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT: | `-UnresolvedLookupExpr {{.*}} <col:10>
+  switch(invalid()) {
+    case 1:
+      break;
+  }
+  // FIXME: figure out why the type of ConditionalOperator is not int.
+  // CHECK:      ConditionalOperator {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT: |-RecoveryExpr {{.*}} '<dependent type>' contains-errors
+  // CHECK-NEXT: | `-UnresolvedLookupExpr {{.*}}
+  // CHECK-NEXT: |-IntegerLiteral {{.*}} 'int' 1
+  // CHECK-NEXT: `-IntegerLiteral {{.*}} 'int' 2
+  invalid() ? 1 : 2;
+}

clang/test/SemaTemplate/instantiate-expr-3.cpp

 // ---------------------------------------------------------------------
 // Statement expressions
 // ---------------------------------------------------------------------
 template<typename T>
 struct StatementExpr0 {
   void f(T t) {
     (void)({
         if (t) // expected-error{{contextually convertible}}
-          t = t + 17;
+          t = t + 17; // expected-error {{invalid operands to binary expression ('N1::X' and 'int')}}
         t + 12; // expected-error{{invalid operands}}
       });
   }
 };
 
 template struct StatementExpr0<int>;
 template struct StatementExpr0<N1::X>; // expected-note{{instantiation}}