[AST][RecoveryAST] Preseve invalid return stmt, and suppress the diagnostics for missing return stmt in constexpr func.

[sammccall]

This is a nice coverage improvement but diagnostic changes don't seem to particularly be improvements... not opposed to landing as-is but want to consider if we can mitigate these...

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

1798

an idea (not sure if feasible) - do we want to suppress "not valid in constant expression" errors when the expressions contains errors?
If so, may want a (different) FIXME here

clang/test/SemaCXX/lambda-expressions.cpp

522

this seems like a regression - what exactly is going on here?

in a perfect world I guess we'd e.g. leave the type undeduced from the first return, rather than deduce it as undeduced-auto (at least for the purposes of diagnostics).

clang/test/SemaCXX/typo-correction-crash.cpp

19

this is also a regression, though this code is pretty broken and is really just asserting no crash.

[sammccall]

Any interest in chasing these diagnostic regressions (they seem like they might be tractable) or should we abandon this?

[hokein]

rebase and update

[hokein]

sorry for the long delay, picking it up.

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

1798

the extra diagnostics don't exit any more in the trunk (I think it is because we support the error-dependent expression in const evaluator).

clang/test/SemaCXX/lambda-expressions.cpp

522

this is an exiting issue in clang, and our tests don't cover that. https://reviews.llvm.org/D92211 will fix that.

clang/test/SemaCXX/typo-correction-crash.cpp

19

this seems non-trivial to fix (we have a too strong invalidation for decltype on an error expression, the declarator is marked invalid), I'd defer the fix (since this is not a critical case, and the code is pretty broken).

[sammccall]

LG once D92211 lands.

clang/lib/Sema/SemaStmt.cpp

bool Sema::DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
   return false;
 }
 
 StmtResult
 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
                       Scope *CurScope) {
   // Correct typos, in case the containing function returns 'auto' and
   // RetValExp should determine the deduced type.
-  ExprResult RetVal = CorrectDelayedTyposInExpr(RetValExp);
+  ExprResult RetVal = CorrectDelayedTyposInExpr(
+      RetValExp, nullptr, /*RecoverUncorrectedTypos=*/true);
   if (RetVal.isInvalid())
     return StmtError();
   StmtResult R = BuildReturnStmt(ReturnLoc, RetVal.get());
   if (R.isInvalid() || ExprEvalContexts.back().Context ==
                            ExpressionEvaluationContext::DiscardedStatement)
     return R;
 
   if (VarDecl *VD =

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

void test(int x) {
   foo->func(x);
 }
 
 // CHECK:     |-AlignedAttr {{.*}} alignas
 // CHECK-NEXT:| `-RecoveryExpr {{.*}} contains-errors
 // CHECK-NEXT:|   `-UnresolvedLookupExpr {{.*}} 'invalid'
 struct alignas(invalid()) Aligned {};
 
+void InvalidReturn() {
+  // CHECK:     `-ReturnStmt {{.*}}
+  // CHECK-NEXT:  `-RecoveryExpr {{.*}} '<dependent type>' contains-errors
+  return undef;
+}
+
 void InvalidInitalizer(int x) {
   struct Bar { Bar(); };
   // CHECK:     `-VarDecl {{.*}} a1 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-IntegerLiteral {{.*}} 'int' 1
   Bar a1(1);
   // CHECK:     `-VarDecl {{.*}} a2 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors

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 PR15884 {
   constexpr S *p = &f();
   // expected-error@-1 {{taking the address of a temporary}}
   // expected-error@-2 {{constexpr variable 'p' must be initialized by a constant expression}}
   // expected-note@-3 {{pointer to temporary is not a constant expression}}
   // expected-note@-4 {{temporary created here}}
 }
 
 namespace AfterError {
-  // FIXME: Suppress the 'no return statements' diagnostic if the body is invalid.
-  constexpr int error() { // expected-error {{no return statement}}
-    return foobar; // expected-error {{undeclared identifier}}
+  constexpr int error() { // expected-error {{constexpr function never produces a constant expression}}
+    return foobar; // expected-error {{undeclared identifier}} expected-note 2{{subexpression not valid in a constant expression}}
   }
-  constexpr int k = error();
+  constexpr int k = error(); // expected-error {{constexpr variable 'k' must be initialized by a constant expression}} \
+                             // expected-note {{in call to 'error()'}}
 }
 
 namespace std {
   typedef decltype(sizeof(int)) size_t;
 
   template <class _E>
   class initializer_list
   {

clang/test/SemaCXX/lambda-expressions.cpp

 // RUN: %clang_cc1 -std=c++14 -Wno-unused-value -fsyntax-only -verify -verify=expected-cxx14 -fblocks %s
 // RUN: %clang_cc1 -std=c++17 -Wno-unused-value -fsyntax-only -verify -fblocks %s
 
 namespace std { class type_info; };
 
 namespace ExplicitCapture {
   class C {
     int Member;
 

 }
 
 // rdar://22032373
 namespace rdar22032373 {
 void foo() {
   auto blk = [](bool b) {
     if (b)
       return undeclared_error; // expected-error {{use of undeclared identifier}}
-    return 0;
+    return 0; // expected-error {{cannot initialize return object of type 'auto' with an rvalue of type 'int'}}
   };
 }
 }
 
 namespace nested_lambda {
 template <int N>
 class S {};
 

clang/test/SemaCXX/typo-correction-crash.cpp

return tes; // expected-error {{use of undeclared identifier 'tes'; did you mean 'test'?}}
               // expected-error@-1 {{deduced as 'int' here but deduced as 'const char *' in earlier}}
 }
 
 template <class A, class B> struct is_same { static constexpr bool value = false; };
 template <class A> struct is_same<A,A> { static constexpr bool value = true; };
 
 auto L1 = [] { return s; }; // expected-error {{use of undeclared identifier 's'}}
 using T1 = decltype(L1());
-static_assert(is_same<T1, void>::value, "Return statement should be discarded");
+// FIXME: Suppress the 'undeclared identifier T1' diagnostic, the UsingDecl T1 is discarded because of an invalid L1().
+static_assert(is_same<T1, void>::value, "Return statement should be discarded"); // expected-error {{use of undeclared identifier 'T1'}}
 auto L2 = [] { return tes; }; // expected-error {{use of undeclared identifier 'tes'; did you mean 'test'?}}
 using T2 = decltype(L2());
 static_assert(is_same<T2, int>::value, "Return statement was corrected");
 
 namespace BarNamespace {
 namespace NestedNamespace { // expected-note {{'BarNamespace::NestedNamespace' declared here}}
 typedef int type;
 }
 }
 struct FooRecord { };
 FooRecord::NestedNamespace::type x; // expected-error {{no member named 'NestedNamespace' in 'FooRecord'; did you mean 'BarNamespace::NestedNamespace'?}}
 
 void cast_expr(int g) { +int(n)(g); } // expected-error {{undeclared identifier 'n'}}
 
 void bind() { for (const auto& [test,_] : _test_) { }; } // expected-error {{undeclared identifier '_test_'}}