[AST][RecoveryExpr] Preserve the AST for invalid class constructions.

[hokein]

Avoid creating a recovery-expr when typo-correction fails, which will lead to
a typoexpr being corrected twice and crashes.

[hokein]

Tested with turning on -frecovery-ast, 3 failures, all of them are diagnostic improvements!

FAIL: Clang :: SemaCXX/constant-expression-cxx11.cpp (10868 of 18440)
******************** TEST 'Clang :: SemaCXX/constant-expression-cxx11.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /workspace/llvm-project/build/bin/clang -cc1 -internal-isystem /workspace/llvm-project/build/lib/clang/11.0.0/include -nostdsysteminc -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic /workspace/llvm-project/clang/test/SemaCXX/constant-expression-cxx11.cpp -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File /workspace/llvm-project/clang/test/SemaCXX/constant-expression-cxx11.cpp Line 2050: initialize all members
error: 'note' diagnostics expected but not seen: 
  File /workspace/llvm-project/clang/test/SemaCXX/constant-expression-cxx11.cpp Line 2053: not initialized
2 errors generated.

--

********************
FAIL: Clang :: SemaCXX/cxx0x-initializer-constructor.cpp (10884 of 18440)
******************** TEST 'Clang :: SemaCXX/cxx0x-initializer-constructor.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /workspace/llvm-project/build/bin/clang -cc1 -internal-isystem /workspace/llvm-project/build/lib/clang/11.0.0/include -nostdsysteminc -std=c++0x -fsyntax-only -fexceptions -verify /workspace/llvm-project/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected: 
  File /workspace/llvm-project/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp Line 166: expected ';' after expression
1 error generated.

--

********************
FAIL: Clang :: SemaCXX/cxx1z-copy-omission.cpp (10915 of 18440)
******************** TEST 'Clang :: SemaCXX/cxx1z-copy-omission.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /workspace/llvm-project/build/bin/clang -cc1 -internal-isystem /workspace/llvm-project/build/lib/clang/11.0.0/include -nostdsysteminc -std=c++1z -verify -Wno-unused /workspace/llvm-project/clang/test/SemaCXX/cxx1z-copy-omission.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected: 
  File /workspace/llvm-project/clang/test/SemaCXX/cxx1z-copy-omission.cpp Line 109: you need to include <typeinfo> before using the 'typeid' operator
1 error generated.

--

********************
********************
Failing Tests (3):
  Clang :: SemaCXX/constant-expression-cxx11.cpp
  Clang :: SemaCXX/cxx0x-initializer-constructor.cpp
  Clang :: SemaCXX/cxx1z-copy-omission.cpp

[sammccall]

Awesome!

/workspace/llvm-project/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp Line 166: expected ';' after expression

This is just a previously-uncaught typo in the test, you may want to fix that either now or when flipping the flag.

[hokein]

rebase to master and adjust the diagnostic tests after "-frecovery-ast" is flipped on.

[hokein]

rebase

clang/lib/Sema/SemaExprCXX.cpp

Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep,
   auto Result = BuildCXXTypeConstructExpr(TInfo, LParenOrBraceLoc, exprs,
                                           RParenOrBraceLoc, ListInitialization);
   // Avoid creating a non-type-dependent expression that contains typos.
   // Non-type-dependent expressions are liable to be discarded without
   // checking for embedded typos.
   if (!Result.isInvalid() && Result.get()->isInstantiationDependent() &&
       !Result.get()->isTypeDependent())
     Result = CorrectDelayedTyposInExpr(Result.get());
+  else if (Result.isInvalid())
+    Result = CreateRecoveryExpr(TInfo->getTypeLoc().getBeginLoc(),
+                                RParenOrBraceLoc, exprs, Ty);
   return Result;
 }
 
 ExprResult
 Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo,
                                 SourceLocation LParenOrBraceLoc,
                                 MultiExprArg Exprs,
                                 SourceLocation RParenOrBraceLoc,

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

void InvalidInitalizer(int x) {
   // CHECK:     `-VarDecl {{.*}} b1 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-IntegerLiteral {{.*}} 'int' 1
   Bar b1 = 1;
   // CHECK:     `-VarDecl {{.*}} b2 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-InitListExpr
   Bar b2 = {1};
-  // FIXME: preserve the invalid initializer.
-  // CHECK: `-VarDecl {{.*}} b3 'Bar'
+  // CHECK:     `-VarDecl {{.*}} b3 'Bar'
+  // CHECK-NEXT:  `-RecoveryExpr {{.*}} 'Bar' contains-errors
+  // CHECK-NEXT:    `-DeclRefExpr {{.*}} 'x' 'int'
   Bar b3 = Bar(x);
-  // FIXME: preserve the invalid initializer.
-  // CHECK: `-VarDecl {{.*}} b4 'Bar'
+  // CHECK:     `-VarDecl {{.*}} b4 'Bar'
+  // CHECK-NEXT:  `-RecoveryExpr {{.*}} 'Bar' contains-errors
+  // CHECK-NEXT:    `-InitListExpr {{.*}} 'void'
+  // CHECK-NEXT:      `-DeclRefExpr {{.*}} 'x' 'int'
   Bar b4 = Bar{x};
   // CHECK:     `-VarDecl {{.*}} b5 'Bar'
   // CHECK-NEXT: `-CXXUnresolvedConstructExpr {{.*}} 'Bar' contains-errors 'Bar'
   // CHECK-NEXT:   `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:     `-UnresolvedLookupExpr {{.*}} 'invalid'
   Bar b5 = Bar(invalid());
   // CHECK:     `-VarDecl {{.*}} b6 'Bar'
   // CHECK-NEXT: `-CXXUnresolvedConstructExpr {{.*}} 'Bar' contains-errors 'Bar'
   // CHECK-NEXT:  `-InitListExpr {{.*}} contains-errors
   // CHECK-NEXT:   `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:     `-UnresolvedLookupExpr {{.*}} 'invalid'
   Bar b6 = Bar{invalid()};
+
+  // CHECK:     `-RecoveryExpr {{.*}} 'Bar' contains-errors
+  // CHECK-NEXT:  `-IntegerLiteral {{.*}} 'int' 1
+  Bar(1);
 }
 void InitializerForAuto() {
   // CHECK:     `-VarDecl {{.*}} invalid a 'auto'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} '<dependent type>' contains-errors
   // CHECK-NEXT:   `-UnresolvedLookupExpr {{.*}} 'invalid'
   auto a = invalid();
 
   // CHECK:     `-VarDecl {{.*}} invalid b 'auto'

clang/test/SemaCXX/constant-expression-cxx11.cpp

 // RUN: %clang_cc1 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fsyntax-only -fcxx-exceptions -verify -std=c++11 -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
 
 namespace StaticAssertFoldTest {
 
 int x;
 static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
 static_assert(false, "test"); // expected-error {{test}}
 
 }

 namespace BadDefaultInit {
   template<int N> struct X { static const int n = N; };
 
   struct A { // expected-error {{default member initializer for 'k' needed within definition of enclosing class}}
     int k = // expected-note {{default member initializer declared here}}
         X<A().k>::n; // expected-note {{in evaluation of exception specification for 'BadDefaultInit::A::A' needed here}}
   };
 
-  // FIXME: The "constexpr constructor must initialize all members" diagnostic
-  // here is bogus (we discard the k(k) initializer because the parameter 'k'
-  // has been marked invalid).
   struct B {
-    constexpr B( // expected-warning {{initialize all members}}
+    constexpr B(
         int k = X<B().k>::n) : // expected-error {{default argument to function 'B' that is declared later}} expected-note {{here}}
       k(k) {}
-    int k; // expected-note {{not initialized}}
+    int k;
   };
 }
 
 namespace NeverConstantTwoWays {
   // If we see something non-constant but foldable followed by something
   // non-constant and not foldable, we want the first diagnostic, not the
   // second.
   constexpr int f(int n) { // expected-error {{never produces a constant expression}}

clang/test/SemaCXX/cxx0x-initializer-constructor.cpp

 // RUN: %clang_cc1 -std=c++0x -fsyntax-only -fexceptions -verify %s
 
 struct one { char c[1]; };
 struct two { char c[2]; };
 
 namespace std {
   typedef decltype(sizeof(int)) size_t;
 
   // libc++'s implementation
struct H { // expected-note 6 {{not viable}}
     H(int, void*); // expected-note 3 {{not viable}}
   };
 
   void edge_cases() {
     // invalid (the first phase only considers init-list ctors)
     // (for the second phase, no constructor is viable)
     G g1{1, 2, 3}; // expected-error {{no matching constructor}}
     (void) new G{1, 2, 3}; // expected-error {{no matching constructor}}
-    (void) G{1, 2, 3} // expected-error {{no matching constructor}}
+    (void) G{1, 2, 3}; // expected-error {{no matching constructor}}
 
     // valid (T deduced to <>).
     G g2({1, 2, 3});
     (void) new G({1, 2, 3});
     (void) G({1, 2, 3});
 
     // invalid
     H h1({1, 2}); // expected-error {{no matching constructor}}

clang/test/SemaCXX/cxx1z-copy-omission.cpp

void test_expressions(bool b) {
   make_incomplete().a; // expected-error {{incomplete}}
   make_incomplete().*(int Incomplete::*)nullptr; // expected-error {{incomplete}}
   dynamic_cast<Incomplete&&>(make_incomplete()); // expected-error {{incomplete}}
   const_cast<Incomplete&&>(make_incomplete()); // expected-error {{incomplete}}
 
   sizeof(Indestructible{}); // expected-error {{deleted}}
   sizeof(make_indestructible()); // expected-error {{deleted}}
   sizeof(make_incomplete()); // expected-error {{incomplete}}
-  typeid(Indestructible{}); // expected-error {{deleted}}
+  typeid(Indestructible{}); // expected-error {{deleted}} expected-error {{you need to include <typeinfo>}}
   typeid(make_indestructible()); // expected-error {{deleted}} \
                                  // expected-error {{need to include <typeinfo>}}
   typeid(make_incomplete()); // expected-error {{incomplete}} \
                              // expected-error {{need to include <typeinfo>}}
 
   // FIXME: The first two cases here are now also valid in C++17 onwards.
   using I = decltype(Indestructible()); // expected-error {{deleted}}
   using I = decltype(Indestructible{}); // expected-error {{deleted}}