diff options
author | Brian Gesiak <modocache@gmail.com> | 2019-03-22 16:08:29 +0000 |
---|---|---|
committer | Brian Gesiak <modocache@gmail.com> | 2019-03-22 16:08:29 +0000 |
commit | 55c482d7c1862a534afabee4bec00995226e5c89 (patch) | |
tree | dff9b89fee31ee711e8a2d1417e6f313f047e2b4 | |
parent | 29f42bb2962f052b4bf94caa9ead47a30f9911d7 (diff) |
Revert "[coroutines][PR40978] Emit error for co_yield within catch block"
The commit https://reviews.llvm.org/rC356296 is causing a regression in nested
catch scopes, https://bugs.llvm.org/show_bug.cgi?id=41171. Revert this change
for now in order to un-break that problem report.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@356774 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r-- | include/clang/Basic/DiagnosticSemaKinds.td | 2 | ||||
-rw-r--r-- | include/clang/Sema/Scope.h | 3 | ||||
-rw-r--r-- | lib/Parse/ParseStmt.cpp | 8 | ||||
-rw-r--r-- | lib/Sema/Scope.cpp | 4 | ||||
-rw-r--r-- | lib/Sema/SemaCoroutine.cpp | 64 | ||||
-rw-r--r-- | test/SemaCXX/coroutines.cpp | 63 |
6 files changed, 25 insertions, 119 deletions
diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index a8776d9b43..5467293ea6 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -9271,8 +9271,6 @@ def err_coroutine_objc_method : Error< "Objective-C methods as coroutines are not yet supported">; def err_coroutine_unevaluated_context : Error< "'%0' cannot be used in an unevaluated context">; -def err_coroutine_within_handler : Error< - "'%0' cannot be used in the handler of a try block">; def err_coroutine_outside_function : Error< "'%0' cannot be used outside a function">; def err_coroutine_invalid_func_context : Error< diff --git a/include/clang/Sema/Scope.h b/include/clang/Sema/Scope.h index 7848df8f70..a1b451c85e 100644 --- a/include/clang/Sema/Scope.h +++ b/include/clang/Sema/Scope.h @@ -131,9 +131,6 @@ public: /// We are between inheritance colon and the real class/struct definition scope. ClassInheritanceScope = 0x800000, - - /// This is the scope of a C++ catch statement. - CatchScope = 0x1000000, }; private: diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp index fde19b9ad8..267003b518 100644 --- a/lib/Parse/ParseStmt.cpp +++ b/lib/Parse/ParseStmt.cpp @@ -2260,10 +2260,8 @@ StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) { // C++ 3.3.2p3: // The name in a catch exception-declaration is local to the handler and // shall not be redeclared in the outermost block of the handler. - unsigned ScopeFlags = Scope::DeclScope | Scope::ControlScope | - Scope::CatchScope | - (FnCatch ? Scope::FnTryCatchScope : 0); - ParseScope CatchScope(this, ScopeFlags); + ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope | + (FnCatch ? Scope::FnTryCatchScope : 0)); // exception-declaration is equivalent to '...' or a parameter-declaration // without default arguments. @@ -2292,7 +2290,7 @@ StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) { return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace); // FIXME: Possible draft standard bug: attribute-specifier should be allowed? - StmtResult Block(ParseCompoundStatement(/*isStmtExpr=*/false, ScopeFlags)); + StmtResult Block(ParseCompoundStatement()); if (Block.isInvalid()) return Block; diff --git a/lib/Sema/Scope.cpp b/lib/Sema/Scope.cpp index 51b0b24e57..09940688ef 100644 --- a/lib/Sema/Scope.cpp +++ b/lib/Sema/Scope.cpp @@ -166,9 +166,7 @@ void Scope::dumpImpl(raw_ostream &OS) const { {SEHExceptScope, "SEHExceptScope"}, {SEHFilterScope, "SEHFilterScope"}, {CompoundStmtScope, "CompoundStmtScope"}, - {ClassInheritanceScope, "ClassInheritanceScope"}, - {CatchScope, "CatchScope"}, - }; + {ClassInheritanceScope, "ClassInheritanceScope"}}; for (auto Info : FlagInfo) { if (Flags & Info.first) { diff --git a/lib/Sema/SemaCoroutine.cpp b/lib/Sema/SemaCoroutine.cpp index 9d328f4926..22a12801da 100644 --- a/lib/Sema/SemaCoroutine.cpp +++ b/lib/Sema/SemaCoroutine.cpp @@ -185,8 +185,21 @@ static QualType lookupCoroutineHandleType(Sema &S, QualType PromiseType, static bool isValidCoroutineContext(Sema &S, SourceLocation Loc, StringRef Keyword) { - // [expr.await]p2 dictates that 'co_await' and 'co_yield' must be used within - // a function body. + // 'co_await' and 'co_yield' are not permitted in unevaluated operands, + // such as subexpressions of \c sizeof. + // + // [expr.await]p2, emphasis added: "An await-expression shall appear only in + // a *potentially evaluated* expression within the compound-statement of a + // function-body outside of a handler [...] A context within a function where + // an await-expression can appear is called a suspension context of the + // function." And per [expr.yield]p1: "A yield-expression shall appear only + // within a suspension context of a function." + if (S.isUnevaluatedContext()) { + S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword; + return false; + } + + // Per [expr.await]p2, any other usage must be within a function. // FIXME: This also covers [expr.await]p2: "An await-expression shall not // appear in a default argument." But the diagnostic QoI here could be // improved to inform the user that default arguments specifically are not @@ -655,57 +668,12 @@ bool Sema::ActOnCoroutineBodyStart(Scope *SC, SourceLocation KWLoc, return true; } -// Recursively walks up the scope hierarchy until either a 'catch' or a function -// scope is found, whichever comes first. -static bool isWithinCatchScope(Scope *S) { - // 'co_await' and 'co_yield' keywords are disallowed within catch blocks, but - // lambdas that use 'co_await' are allowed. The loop below ends when a - // function scope is found in order to ensure the following behavior: - // - // void foo() { // <- function scope - // try { // - // co_await x; // <- 'co_await' is OK within a function scope - // } catch { // <- catch scope - // co_await x; // <- 'co_await' is not OK within a catch scope - // []() { // <- function scope - // co_await x; // <- 'co_await' is OK within a function scope - // }(); - // } - // } - while (S && !(S->getFlags() & Scope::FnScope)) { - if (S->getFlags() & Scope::CatchScope) - return true; - S = S->getParent(); - } - return false; -} - -// [expr.await]p2, emphasis added: "An await-expression shall appear only in -// a *potentially evaluated* expression within the compound-statement of a -// function-body *outside of a handler* [...] A context within a function -// where an await-expression can appear is called a suspension context of the -// function." -static void checkSuspensionContext(Sema &S, SourceLocation Loc, - StringRef Keyword) { - // First emphasis of [expr.await]p2: must be a potentially evaluated context. - // That is, 'co_await' and 'co_yield' cannot appear in subexpressions of - // \c sizeof. - if (S.isUnevaluatedContext()) - S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword; - - // Second emphasis of [expr.await]p2: must be outside of an exception handler. - if (isWithinCatchScope(S.getCurScope())) - S.Diag(Loc, diag::err_coroutine_within_handler) << Keyword; -} - ExprResult Sema::ActOnCoawaitExpr(Scope *S, SourceLocation Loc, Expr *E) { if (!ActOnCoroutineBodyStart(S, Loc, "co_await")) { CorrectDelayedTyposInExpr(E); return ExprError(); } - checkSuspensionContext(*this, Loc, "co_await"); - if (E->getType()->isPlaceholderType()) { ExprResult R = CheckPlaceholderExpr(E); if (R.isInvalid()) return ExprError(); @@ -803,8 +771,6 @@ ExprResult Sema::ActOnCoyieldExpr(Scope *S, SourceLocation Loc, Expr *E) { return ExprError(); } - checkSuspensionContext(*this, Loc, "co_yield"); - // Build yield_value call. ExprResult Awaitable = buildPromiseCall( *this, getCurFunction()->CoroutinePromise, Loc, "yield_value", E); diff --git a/test/SemaCXX/coroutines.cpp b/test/SemaCXX/coroutines.cpp index 99964ef6bc..5e1ff34c40 100644 --- a/test/SemaCXX/coroutines.cpp +++ b/test/SemaCXX/coroutines.cpp @@ -314,23 +314,13 @@ struct CtorDtor { } }; -namespace std { class type_info; } - void unevaluated() { - decltype(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}} - // expected-warning@-1 {{declaration does not declare anything}} - sizeof(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}} - // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}} - typeid(co_await a); // expected-error {{'co_await' cannot be used in an unevaluated context}} - // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}} - // expected-warning@-2 {{expression result unused}} - decltype(co_yield 1); // expected-error {{'co_yield' cannot be used in an unevaluated context}} - // expected-warning@-1 {{declaration does not declare anything}} - sizeof(co_yield 2); // expected-error {{'co_yield' cannot be used in an unevaluated context}} - // expected-error@-1 {{invalid application of 'sizeof' to an incomplete type 'void'}} - typeid(co_yield 3); // expected-error {{'co_yield' cannot be used in an unevaluated context}} - // expected-warning@-1 {{expression with side effects has no effect in an unevaluated context}} - // expected-warning@-2 {{expression result unused}} + decltype(co_await a); // expected-error {{cannot be used in an unevaluated context}} + sizeof(co_await a); // expected-error {{cannot be used in an unevaluated context}} + typeid(co_await a); // expected-error {{cannot be used in an unevaluated context}} + decltype(co_yield a); // expected-error {{cannot be used in an unevaluated context}} + sizeof(co_yield a); // expected-error {{cannot be used in an unevaluated context}} + typeid(co_yield a); // expected-error {{cannot be used in an unevaluated context}} } // [expr.await]p2: "An await-expression shall not appear in a default argument." @@ -338,47 +328,6 @@ void unevaluated() { // not allowed. A user may not understand that this is "outside a function." void default_argument(int arg = co_await 0) {} // expected-error {{'co_await' cannot be used outside a function}} -void await_in_catch_coroutine() { - try { - } catch (...) { // FIXME: Emit a note diagnostic pointing out the try handler on this line. - []() -> void { co_await a; }(); // OK - co_await a; // expected-error {{'co_await' cannot be used in the handler of a try block}} - } -} - -void await_nested_in_catch_coroutine() { - try { - } catch (...) { // FIXME: Emit a note diagnostic pointing out the try handler on this line. - try { - co_await a; // expected-error {{'co_await' cannot be used in the handler of a try block}} - []() -> void { co_await a; }(); // OK - } catch (...) { - co_return 123; - } - } -} - -void await_in_lambda_in_catch_coroutine() { - try { - } catch (...) { - []() -> void { co_await a; }(); // OK - } -} - -void yield_in_catch_coroutine() { - try { - } catch (...) { - co_yield 1; // expected-error {{'co_yield' cannot be used in the handler of a try block}} - } -} - -void return_in_catch_coroutine() { - try { - } catch (...) { - co_return 123; // OK - } -} - constexpr auto constexpr_deduced_return_coroutine() { co_yield 0; // expected-error {{'co_yield' cannot be used in a constexpr function}} // expected-error@-1 {{'co_yield' cannot be used in a function with a deduced return type}} |