[stmt.jump] - C++17 → C++20

Files changed (1) hide show

tmp/tmp3i4lvy39/{from.md → to.md} +87 -31

tmp/tmp3i4lvy39/{from.md → to.md} RENAMED Viewed

@@ -2,33 +2,37 @@
 Jump statements unconditionally transfer control.
 ``` bnf
 jump-statement:
- 'break ;'
- 'continue ;'
- 'return' expr-or-braced-init-listₒₚₜ ';'
- 'goto' identifier ';'
 ```
 On exit from a scope (however accomplished), objects with automatic
-storage duration ([[basic.stc.auto]]) that have been constructed in
-that scope are destroyed in the reverse order of their construction.
 [*Note 1*: For temporaries, see  [[class.temporary]]. — *end note*]
 Transfer out of a loop, out of a block, or back past an initialized
 variable with automatic storage duration involves the destruction of
 objects with automatic storage duration that are in scope at the point
 transferred from but not at the point transferred to. (See  [[stmt.dcl]]
 for transfers into blocks).
 [*Note 2*: However, the program can be terminated (by calling
-`std::exit()` or `std::abort()` ([[support.start.term]]), for example)
-without destroying class objects with automatic storage
 duration. — *end note*]
 ### The `break` statement <a id="stmt.break">[[stmt.break]]</a>
 The `break` statement shall occur only in an *iteration-statement* or a
 `switch` statement and causes termination of the smallest enclosing
 *iteration-statement* or `switch` statement; control passes to the
@@ -67,33 +71,33 @@ for (;;) {
 contin: ;
 }
 ```
 a `continue` not contained in an enclosed iteration statement is
-equivalent to `goto` `contin`.
 ### The `return` statement <a id="stmt.return">[[stmt.return]]</a>
 A function returns to its caller by the `return` statement.
-The *expr-or-braced-init-list* of a return statement is called its
-operand. A return statement with no operand shall be used only in a
-function whose return type is cv `void`, a constructor (
-[[class.ctor]]), or a destructor ([[class.dtor]]). A return statement
-with an operand of type `void` shall be used only in a function whose
-return type is cv `void`. A return statement with any other operand
-shall be used only in a function whose return type is not cv `void`; the
-return statement initializes the glvalue result or prvalue result object
-of the (explicit or implicit) function call by copy-initialization (
-[[dcl.init]]) from the operand.
-[*Note 1*: A return statement can involve an invocation of a
 constructor to perform a copy or move of the operand if it is not a
 prvalue or if its type differs from the return type of the function. A
-copy operation associated with a return statement may be elided or
 converted to a move operation if an automatic storage duration variable
-is returned ([[class.copy]]). — *end note*]
 [*Example 1*:
 ``` cpp
 std::pair<std::string,int> f(const char* p, int x) {
@@ -101,22 +105,74 @@ std::pair<std::string,int> f(const char* p, int x) {
 }
 ```
 — *end example*]
-Flowing off the end of a constructor, a destructor, or a function with a
-cv `void` return type is equivalent to a `return` with no operand.
-Otherwise, flowing off the end of a function other than `main` (
-[[basic.start.main]]) results in undefined behavior.
 The copy-initialization of the result of the call is sequenced before
 the destruction of temporaries at the end of the full-expression
-established by the operand of the return statement, which, in turn, is
-sequenced before the destruction of local variables ([[stmt.jump]]) of
-the block enclosing the return statement.
 ### The `goto` statement <a id="stmt.goto">[[stmt.goto]]</a>
 The `goto` statement unconditionally transfers control to the statement
-labeled by the identifier. The identifier shall be a label (
-[[stmt.label]]) located in the current function.

 Jump statements unconditionally transfer control.
 ``` bnf
 jump-statement:
+    break ';'
+    continue ';'
+    return expr-or-braced-init-listₒₚₜ ';'
+ coroutine-return-statement
+    goto identifier ';'
 ```
 On exit from a scope (however accomplished), objects with automatic
+storage duration [[basic.stc.auto]] that have been constructed in that
+scope are destroyed in the reverse order of their construction.
 [*Note 1*: For temporaries, see  [[class.temporary]]. — *end note*]
 Transfer out of a loop, out of a block, or back past an initialized
 variable with automatic storage duration involves the destruction of
 objects with automatic storage duration that are in scope at the point
 transferred from but not at the point transferred to. (See  [[stmt.dcl]]
 for transfers into blocks).
 [*Note 2*: However, the program can be terminated (by calling
+`std::exit()` or `std::abort()` [[support.start.term]], for example)
+without destroying objects with automatic storage
 duration. — *end note*]
+[*Note 3*: A suspension of a coroutine [[expr.await]] is not considered
+to be an exit from a scope. — *end note*]
 ### The `break` statement <a id="stmt.break">[[stmt.break]]</a>
 The `break` statement shall occur only in an *iteration-statement* or a
 `switch` statement and causes termination of the smallest enclosing
 *iteration-statement* or `switch` statement; control passes to the
 contin: ;
 }
 ```
 a `continue` not contained in an enclosed iteration statement is
+equivalent to `goto` *`contin`*.
 ### The `return` statement <a id="stmt.return">[[stmt.return]]</a>
 A function returns to its caller by the `return` statement.
+The *expr-or-braced-init-list* of a `return` statement is called its
+operand. A `return` statement with no operand shall be used only in a
+function whose return type is cv `void`, a constructor [[class.ctor]],
+or a destructor [[class.dtor]]. A `return` statement with an operand of
+type `void` shall be used only in a function whose return type is
+cv `void`. A `return` statement with any other operand shall be used
+only in a function whose return type is not cv `void`; the `return`
+statement initializes the glvalue result or prvalue result object of the
+(explicit or implicit) function call by copy-initialization [[dcl.init]]
+from the operand.
+[*Note 1*: A `return` statement can involve an invocation of a
 constructor to perform a copy or move of the operand if it is not a
 prvalue or if its type differs from the return type of the function. A
+copy operation associated with a `return` statement may be elided or
 converted to a move operation if an automatic storage duration variable
+is returned [[class.copy.elision]]. — *end note*]
 [*Example 1*:
 ``` cpp
 std::pair<std::string,int> f(const char* p, int x) {
 }
 ```
 — *end example*]
+The destructor for the returned object is potentially invoked (
+[[class.dtor]], [[except.ctor]]).
+[*Example 2*:
+``` cpp
+class A {
+  ~A() {}
+};
+A f() { return A(); }   // error: destructor of A is private (even though it is never invoked)
+```
+— *end example*]
+Flowing off the end of a constructor, a destructor, or a non-coroutine
+function with a cv `void` return type is equivalent to a `return` with
+no operand. Otherwise, flowing off the end of a function other than
+`main` [[basic.start.main]] or a coroutine [[dcl.fct.def.coroutine]]
+results in undefined behavior.
 The copy-initialization of the result of the call is sequenced before
 the destruction of temporaries at the end of the full-expression
+established by the operand of the `return` statement, which, in turn, is
+sequenced before the destruction of local variables [[stmt.jump]] of the
+block enclosing the `return` statement.
+### The `co_return` statement <a id="stmt.return.coroutine">[[stmt.return.coroutine]]</a>
+``` bnf
+coroutine-return-statement:
+    'co_return' expr-or-braced-init-listₒₚₜ ';'
+```
+A coroutine returns to its caller or resumer [[dcl.fct.def.coroutine]]
+by the `co_return` statement or when suspended [[expr.await]]. A
+coroutine shall not enclose a `return` statement [[stmt.return]].
+[*Note 1*: For this determination, it is irrelevant whether the
+`return` statement is enclosed by a discarded statement
+[[stmt.if]]. — *end note*]
+The *expr-or-braced-init-list* of a `co_return` statement is called its
+operand. Let *p* be an lvalue naming the coroutine promise object
+[[dcl.fct.def.coroutine]]. A `co_return` statement is equivalent to:
+``` bnf
+'{' S';' 'goto' final-suspend';' '}'
+```
+where *`final-suspend`* is the exposition-only label defined in
+[[dcl.fct.def.coroutine]] and *S* is defined as follows:
+- If the operand is a *braced-init-list* or an expression of non-`void`
+  type, *S* is *p*`.return_value(`*expr-or-braced-init-list*`)`. The
+  expression *S* shall be a prvalue of type `void`.
+- Otherwise, *S* is the *compound-statement* `{` *expression*ₒₚₜ  `;`
+  *p*`.return_void()``; }`. The expression *p*`.return_void()` shall be
+  a prvalue of type `void`.
+If *p*`.return_void()` is a valid expression, flowing off the end of a
+coroutine is equivalent to a `co_return` with no operand; otherwise
+flowing off the end of a coroutine results in undefined behavior.
 ### The `goto` statement <a id="stmt.goto">[[stmt.goto]]</a>
 The `goto` statement unconditionally transfers control to the statement
+labeled by the identifier. The identifier shall be a label
+[[stmt.label]] located in the current function.

Diff to HTML by rtfpessoa