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

Files changed (1) hide show

tmp/tmp8l55vvjw/{from.md → to.md} +308 -198

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

@@ -1,7 +1,9 @@
 # Statements <a id="stmt.stmt">[[stmt.stmt]]</a>
 Except as indicated, statements are executed in sequence.
 ``` bnf
 statement:
     labeled-statement
@@ -23,50 +25,58 @@ condition:
 ```
 The optional *attribute-specifier-seq* appertains to the respective
 statement.
 The rules for *condition*s apply both to *selection-statement*s and to
-the `for` and `while` statements ([[stmt.iter]]). The *declarator*
-shall not specify a function or an array. The *decl-specifier-seq* shall
-not define a class or enumeration. If the `auto` *type-specifier*
-appears in the *decl-specifier-seq*, the type of the identifier being
-declared is deduced from the initializer as described in
-[[dcl.spec.auto]].
-A name introduced by a declaration in a *condition* (either introduced
-by the *decl-specifier-seq* or the *declarator* of the condition) is in
-scope from its point of declaration until the end of the substatements
-controlled by the condition. If the name is redeclared in the outermost
-block of a substatement controlled by the condition, the declaration
-that redeclares the name is ill-formed.
-[*Example 1*:
-``` cpp
-if (int x = f()) {
-  int x;            // ill-formed, redeclaration of x
-}
-else {
-  int x;            // ill-formed, redeclaration of x
-}
-```
-— *end example*]
 The value of a *condition* that is an initialized declaration in a
 statement other than a `switch` statement is the value of the declared
-variable contextually converted to `bool` (Clause  [[conv]]). If that
-conversion is ill-formed, the program is ill-formed. The value of a
-*condition* that is an initialized declaration in a `switch` statement
-is the value of the declared variable if it has integral or enumeration
-type, or of that variable implicitly converted to integral or
-enumeration type otherwise. The value of a *condition* that is an
-expression is the value of the expression, contextually converted to
-`bool` for statements other than `switch`; if that conversion is
-ill-formed, the program is ill-formed. The value of the condition will
-be referred to as simply “the condition” where the usage is unambiguous.
 If a *condition* can be syntactically resolved as either an expression
 or the declaration of a block-scope name, it is interpreted as a
 declaration.
@@ -78,12 +88,12 @@ shall be either a *type-specifier* or `constexpr`.
 A statement can be labeled.
 ``` bnf
 labeled-statement:
     attribute-specifier-seqₒₚₜ identifier ':' statement
-    attribute-specifier-seqₒₚₜ 'case' constant-expression ':' statement
-    attribute-specifier-seqₒₚₜ 'default :' statement
 ```
 The optional *attribute-specifier-seq* appertains to the label. An
 *identifier label* declares the identifier. The only use of an
 identifier label is as the target of a `goto`. The scope of a label is
@@ -92,34 +102,34 @@ a function. A label can be used in a `goto` statement before its
 declaration. Labels have their own name space and do not interfere with
 other identifiers.
 [*Note 1*: A label may have the same name as another declaration in the
 same scope or a *template-parameter* from an enclosing scope.
-Unqualified name lookup ([[basic.lookup.unqual]]) ignores
 labels. — *end note*]
-Case labels and default labels shall occur only in switch statements.
 ## Expression statement <a id="stmt.expr">[[stmt.expr]]</a>
 Expression statements have the form
 ``` bnf
 expression-statement:
     expressionₒₚₜ ';'
 ```
-The expression is a discarded-value expression (Clause  [[expr]]). All
 side effects from an expression statement are completed before the next
 statement is executed. An expression statement with the expression
 missing is called a *null statement*.
 [*Note 1*: Most statements are expression statements — usually
 assignments or function calls. A null statement is useful to carry a
 label just before the `}` of a compound statement and to supply a null
-body to an iteration statement such as a `while` statement (
-[[stmt.while]]). — *end note*]
 ## Compound statement or block <a id="stmt.block">[[stmt.block]]</a>
 So that several statements can be used where one is expected, the
 compound statement (also, and equivalently, called “block”) is provided.
@@ -133,39 +143,36 @@ compound-statement:
 statement-seq:
     statement
     statement-seq statement
 ```
-A compound statement defines a block scope ([[basic.scope]]).
-[*Note 1*: A declaration is a *statement* (
-[[stmt.dcl]]). — *end note*]
 ## Selection statements <a id="stmt.select">[[stmt.select]]</a>
 Selection statements choose one of several flows of control.
 ``` bnf
 selection-statement:
- 'if constexprₒₚₜ (' init-statementₒₚₜ condition ')' statement
- 'if constexprₒₚₜ (' init-statementₒₚₜ condition ')' statement 'else' statement
- 'switch (' init-statementₒₚₜ condition ')' statement
 ```
 See  [[dcl.meaning]] for the optional *attribute-specifier-seq* in a
 condition.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
-In Clause  [[stmt.stmt]], the term *substatement* refers to the
-contained *statement* or *statement*s that appear in the syntax
-notation. The substatement in a *selection-statement* (each
-substatement, in the `else` form of the `if` statement) implicitly
-defines a block scope ([[basic.scope]]). If the substatement in a
-selection-statement is a single statement and not a
-*compound-statement*, it is as if it was rewritten to be a
-compound-statement containing the original substatement.
 [*Example 1*:
 ``` cpp
 if (x)
@@ -184,37 +191,37 @@ Thus after the `if` statement, `i` is no longer in scope.
 — *end example*]
 ### The `if` statement <a id="stmt.if">[[stmt.if]]</a>
-If the condition ([[stmt.select]]) yields `true` the first substatement
-is executed. If the `else` part of the selection statement is present
-and the condition yields `false`, the second substatement is executed.
-If the first substatement is reached via a label, the condition is not
 evaluated and the second substatement is not executed. In the second
 form of `if` statement (the one including `else`), if the first
 substatement is also an `if` statement then that inner `if` statement
 shall contain an `else` part.[^1]
 If the `if` statement is of the form `if constexpr`, the value of the
 condition shall be a contextually converted constant expression of type
-`bool` ([[expr.const]]); this form is called a *constexpr if*
-statement. If the value of the converted condition is `false`, the first
 substatement is a *discarded statement*, otherwise the second
 substatement, if present, is a discarded statement. During the
-instantation of an enclosing templated entity (Clause  [[temp]]), if the
 condition is not value-dependent after its instantiation, the discarded
 substatement (if any) is not instantiated.
-[*Note 1*: Odr-uses ([[basic.def.odr]]) in a discarded statement do
-not require an entity to be defined. — *end note*]
 A `case` or `default` label appearing within such an `if` statement
-shall be associated with a `switch` statement ([[stmt.switch]]) within
-the same `if` statement. A label ([[stmt.label]]) declared in a
-substatement of a constexpr if statement shall only be referred to by a
-statement ([[stmt.goto]]) in the same substatement.
 [*Example 1*:
 ``` cpp
 template<typename T, typename ... Rest> void g(T&& p, Rest&& ...rs) {
@@ -239,47 +246,61 @@ int f() {
 — *end example*]
 An `if` statement of the form
 ``` bnf
-'if constexprₒₚₜ (' init-statement condition ')' statement
 ```
 is equivalent to
 and an `if` statement of the form
 ``` bnf
-'if constexprₒₚₜ (' init-statement condition ')' statement 'else' statement
 ```
 is equivalent to
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*.
 ### The `switch` statement <a id="stmt.switch">[[stmt.switch]]</a>
 The `switch` statement causes control to be transferred to one of
 several statements depending on the value of a condition.
 The condition shall be of integral type, enumeration type, or class
 type. If of class type, the condition is contextually implicitly
-converted (Clause  [[conv]]) to an integral or enumeration type. If the
-(possibly converted) type is subject to integral promotions (
-[[conv.prom]]), the condition is converted to the promoted type. Any
-statement within the `switch` statement can be labeled with one or more
-case labels as follows:
 ``` bnf
-'case' constant-expression ':'
 ```
-where the *constant-expression* shall be a converted constant
-expression ([[expr.const]]) of the adjusted type of the switch
-condition. No two of the case constants in the same switch shall have
-the same value after conversion.
 There shall be at most one label of the form
 ``` cpp
 default :
@@ -288,49 +309,56 @@ default :
 within a `switch` statement.
 Switch statements can be nested; a `case` or `default` label is
 associated with the smallest switch enclosing it.
-When the `switch` statement is executed, its condition is evaluated and
-compared with each case constant. If one of the case constants is equal
-to the value of the condition, control is passed to the statement
-following the matched case label. If no case constant matches the
-condition, and if there is a `default` label, control passes to the
-statement labeled by the default label. If no case matches and if there
-is no `default` then none of the statements in the switch is executed.
 `case` and `default` labels in themselves do not alter the flow of
 control, which continues unimpeded across such labels. To exit from a
-switch, see `break`,  [[stmt.break]].
 [*Note 1*: Usually, the substatement that is the subject of a switch is
 compound and `case` and `default` labels appear on the top-level
 statements contained within the (compound) substatement, but this is not
 required. Declarations can appear in the substatement of a `switch`
 statement. — *end note*]
 A `switch` statement of the form
 ``` bnf
-'switch (' init-statement condition ')' statement
 ```
 is equivalent to
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*.
 ## Iteration statements <a id="stmt.iter">[[stmt.iter]]</a>
 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
- 'while (' condition ')' statement
- 'do' statement 'while (' expression ') ;'
- 'for (' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
- 'for (' for-range-declaration ':' for-range-initializer ')' statement
 ```
 ``` bnf
 for-range-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
@@ -346,16 +374,14 @@ See  [[dcl.meaning]] for the optional *attribute-specifier-seq* in a
 *for-range-declaration*.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
 The substatement in an *iteration-statement* implicitly defines a block
-scope ([[basic.scope]]) which is entered and exited each time through
-the loop.
-If the substatement in an iteration-statement is a single statement and
-not a *compound-statement*, it is as if it was rewritten to be a
-compound-statement containing the original statement.
 [*Example 1*:
 ``` cpp
 while (--x >= 0)
@@ -392,36 +418,31 @@ void f() {
 — *end example*]
 ### The `while` statement <a id="stmt.while">[[stmt.while]]</a>
 In the `while` statement the substatement is executed repeatedly until
-the value of the condition ([[stmt.select]]) becomes `false`. The test
 takes place before each execution of the substatement.
 When the condition of a `while` statement is a declaration, the scope of
-the variable that is declared extends from its point of declaration (
-[[basic.scope.pdecl]]) to the end of the `while` *statement*. A `while`
-statement of the form
-``` cpp
-while (T t = x) statement
-```
-is equivalent to
-``` cpp
-label:
-{                   // start of condition scope
-  T t = x;
-  if (t) {
       statement
- goto label;
- }
-}                   // end of condition scope
 ```
-The variable created in a condition is destroyed and created with each
 iteration of the loop.
 [*Example 1*:
 ``` cpp
@@ -442,39 +463,51 @@ In the while-loop, the constructor and destructor are each called twice,
 once for the condition that succeeds and once for the condition that
 fails.
 — *end example*]
 ### The `do` statement <a id="stmt.do">[[stmt.do]]</a>
-The expression is contextually converted to `bool` (Clause  [[conv]]);
-if that conversion is ill-formed, the program is ill-formed.
 In the `do` statement the substatement is executed repeatedly until the
 value of the expression becomes `false`. The test takes place after each
 execution of the statement.
 ### The `for` statement <a id="stmt.for">[[stmt.for]]</a>
 The `for` statement
 ``` bnf
-'for (' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
 ```
 is equivalent to
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*, and except that
 a `continue` in *statement* (not enclosed in another iteration
 statement) will execute *expression* before re-evaluating *condition*.
 [*Note 1*: Thus the first statement specifies initialization for the
-loop; the condition ([[stmt.select]]) specifies a test, sequenced
-before each iteration, such that the loop is exited when the condition
-becomes `false`; the expression often specifies incrementing that is
-sequenced after each iteration. — *end note*]
 Either or both of the *condition* and the *expression* can be omitted. A
 missing *condition* makes the implied `while` clause equivalent to
 `while(true)`.
@@ -498,39 +531,52 @@ int j = i;          // j = 42
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
-'for (' for-range-declaration ':' for-range-initializer ')' statement
 ```
 is equivalent to
 where
 - if the *for-range-initializer* is an *expression*, it is regarded as
   if it were surrounded by parentheses (so that a comma operator cannot
   be reinterpreted as delimiting two *init-declarator*s);
-- `__range`, `__begin`, and `__end` are variables defined for exposition
   only; and
 - *begin-expr* and *end-expr* are determined as follows:
   - if the *for-range-initializer* is an expression of array type `R`,
-    *begin-expr* and *end-expr* are `__range` and `__range + __bound`,
-    respectively, where `__bound` is the array bound. If `R` is an array
- of unknown bound or an array of incomplete type, the program is
     ill-formed;
   - if the *for-range-initializer* is an expression of class type `C`,
     the *unqualified-id*s `begin` and `end` are looked up in the scope
-    of `C` as if by class member access lookup (
-    [[basic.lookup.classref]]), and if either (or both) finds at least
- one declaration, *begin-expr* and *end-expr* are `__range.begin()`
- and `__range.end()`, respectively;
-  - otherwise, *begin-expr* and *end-expr* are `begin(__range)` and
-    `end(__range)`, respectively, where `begin` and `end` are looked up
- in the associated namespaces ([[basic.lookup.argdep]]).
-    \[*Note 1*: Ordinary unqualified lookup ([[basic.lookup.unqual]])
- is not performed. — *end note*]
 [*Example 1*:
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };
@@ -548,33 +594,37 @@ In the *decl-specifier-seq* of a *for-range-declaration*, each
 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
@@ -613,33 +663,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) {
@@ -647,26 +697,78 @@ 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.
 ## Declaration statement <a id="stmt.dcl">[[stmt.dcl]]</a>
 A declaration statement introduces one or more new identifiers into a
 block; it has the form
@@ -678,30 +780,30 @@ declaration-statement:
 If an identifier introduced by a declaration was previously declared in
 an outer block, the outer declaration is hidden for the remainder of the
 block, after which it resumes its force.
-Variables with automatic storage duration ([[basic.stc.auto]]) are
 initialized each time their *declaration-statement* is executed.
 Variables with automatic storage duration declared in the block are
-destroyed on exit from the block ([[stmt.jump]]).
 It is possible to transfer into a block, but not in a way that bypasses
-declarations with initialization. A program that jumps[^2] from a point
-where a variable with automatic storage duration is not in scope to a
-point where it is in scope is ill-formed unless the variable has scalar
-type, class type with a trivial default constructor and a trivial
-destructor, a cv-qualified version of one of these types, or an array of
-one of the preceding types and is declared without an *initializer* (
-[[dcl.init]]).
 [*Example 1*:
 ``` cpp
 void f() {
   // ...
-  goto lx;          // ill-formed: jump into scope of a
   // ...
 ly:
   X a = 1;
   // ...
 lx:
@@ -711,12 +813,12 @@ lx:
 ```
 — *end example*]
 Dynamic initialization of a block-scope variable with static storage
-duration ([[basic.stc.static]]) or thread storage duration (
-[[basic.stc.thread]]) is performed the first time control passes through
 its declaration; such a variable is considered initialized upon the
 completion of its initialization. If the initialization exits by
 throwing an exception, the initialization is not complete, so it will be
 tried again the next time control enters the declaration. If control
 enters the declaration concurrently while the variable is being
@@ -726,29 +828,29 @@ while the variable is being initialized, the behavior is undefined.
 [*Example 2*:
 ``` cpp
 int foo(int i) {
-  static int s = foo(2*i);      // recursive call - undefined
   return i+1;
 }
 ```
 — *end example*]
-The destructor for a block-scope object with static or thread storage
-duration will be executed if and only if it was constructed.
 [*Note 1*:  [[basic.start.term]] describes the order in which
 block-scope objects with static and thread storage duration are
 destroyed. — *end note*]
 ## Ambiguity resolution <a id="stmt.ambig">[[stmt.ambig]]</a>
 There is an ambiguity in the grammar involving *expression-statement*s
 and *declaration*s: An *expression-statement* with a function-style
-explicit type conversion ([[expr.type.conv]]) as its leftmost
 subexpression can be indistinguishable from a *declaration* where the
 first *declarator* starts with a `(`. In those cases the *statement* is
 a *declaration*.
 [*Note 1*:
@@ -758,11 +860,11 @@ ambiguity, so this rule does not apply. The whole *statement* might need
 to be examined to determine whether this is the case. This resolves the
 meaning of many examples.
 [*Example 1*:
-Assuming `T` is a *simple-type-specifier* ([[dcl.type]]),
 ``` cpp
 T(a)->m = 7;        // expression-statement
 T(a)++;             // expression-statement
 T(a,5)<<c;          // expression-statement
@@ -838,32 +940,38 @@ void f() {
 — *end example*]
 <!-- Link reference definitions -->
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope]: basic.md#basic.scope
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
-[class.copy]: special.md#class.copy
-[class.ctor]: special.md#class.ctor
-[class.dtor]: special.md#class.dtor
-[class.temporary]: special.md#class.temporary
-[conv]: conv.md#conv
-[conv.prom]: conv.md#conv.prom
 [dcl.init]: dcl.md#dcl.init
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type]: dcl.md#dcl.type
-[expr]: expr.md#expr
 [expr.const]: expr.md#expr.const
 [expr.type.conv]: expr.md#expr.type.conv
 [stmt.ambig]: #stmt.ambig
 [stmt.block]: #stmt.block
 [stmt.break]: #stmt.break
 [stmt.cont]: #stmt.cont
@@ -874,18 +982,20 @@ void f() {
 [stmt.goto]: #stmt.goto
 [stmt.if]: #stmt.if
 [stmt.iter]: #stmt.iter
 [stmt.jump]: #stmt.jump
 [stmt.label]: #stmt.label
 [stmt.ranged]: #stmt.ranged
 [stmt.return]: #stmt.return
 [stmt.select]: #stmt.select
 [stmt.stmt]: #stmt.stmt
 [stmt.switch]: #stmt.switch
 [stmt.while]: #stmt.while
-[support.start.term]: language.md#support.start.term
-[temp]: temp.md#temp
 [^1]: In other words, the `else` is associated with the nearest un-elsed
     `if`.
 [^2]: The transfer from the condition of a `switch` statement to a

 # Statements <a id="stmt.stmt">[[stmt.stmt]]</a>
+## Preamble <a id="stmt.pre">[[stmt.pre]]</a>
 Except as indicated, statements are executed in sequence.
 ``` bnf
 statement:
     labeled-statement
 ```
 The optional *attribute-specifier-seq* appertains to the respective
 statement.
+A *substatement* of a *statement* is one of the following:
+- for a *labeled-statement*, its contained *statement*,
+- for a *compound-statement*, any *statement* of its *statement-seq*,
+- for a *selection-statement*, any of its *statement*s (but not its
+  *init-statement*), or
+- for an *iteration-statement*, its contained *statement* (but not an
+  *init-statement*).
+[*Note 1*: The *compound-statement* of a *lambda-expression* is not a
+substatement of the *statement* (if any) in which the
+*lambda-expression* lexically appears. — *end note*]
+A *statement* `S1` *encloses* a *statement* `S2` if
+- `S2` is a substatement of `S1` [[dcl.dcl]],
+- `S1` is a *selection-statement* or *iteration-statement* and `S2` is
+  the *init-statement* of `S1`,
+- `S1` is a *try-block* and `S2` is its *compound-statement* or any of
+  the *compound-statement*s of its *handler*s, or
+- `S1` encloses a statement `S3` and `S3` encloses `S2`.
 The rules for *condition*s apply both to *selection-statement*s and to
+the `for` and `while` statements [[stmt.iter]]. A *condition* that is
+not an *expression* is a declaration [[dcl.dcl]]. The *declarator* shall
+not specify a function or an array. The *decl-specifier-seq* shall not
+define a class or enumeration. If the `auto` *type-specifier* appears in
+the *decl-specifier-seq*, the type of the identifier being declared is
+deduced from the initializer as described in  [[dcl.spec.auto]].
+[*Note 2*: A name introduced in a *selection-statement* or
+*iteration-statement* outside of any substatement is in scope from its
+point of declaration until the end of the statement’s substatements.
+Such a name cannot be redeclared in the outermost block of any of the
+substatements [[basic.scope.block]]. — *end note*]
 The value of a *condition* that is an initialized declaration in a
 statement other than a `switch` statement is the value of the declared
+variable contextually converted to `bool` [[conv]]. If that conversion
+is ill-formed, the program is ill-formed. The value of a *condition*
+that is an initialized declaration in a `switch` statement is the value
+of the declared variable if it has integral or enumeration type, or of
+that variable implicitly converted to integral or enumeration type
+otherwise. The value of a *condition* that is an expression is the value
+of the expression, contextually converted to `bool` for statements other
+than `switch`; if that conversion is ill-formed, the program is
+ill-formed. The value of the condition will be referred to as simply
+“the condition” where the usage is unambiguous.
 If a *condition* can be syntactically resolved as either an expression
 or the declaration of a block-scope name, it is interpreted as a
 declaration.
 A statement can be labeled.
 ``` bnf
 labeled-statement:
     attribute-specifier-seqₒₚₜ identifier ':' statement
+    attribute-specifier-seqₒₚₜ case constant-expression ':' statement
+    attribute-specifier-seqₒₚₜ default ':' statement
 ```
 The optional *attribute-specifier-seq* appertains to the label. An
 *identifier label* declares the identifier. The only use of an
 identifier label is as the target of a `goto`. The scope of a label is
 declaration. Labels have their own name space and do not interfere with
 other identifiers.
 [*Note 1*: A label may have the same name as another declaration in the
 same scope or a *template-parameter* from an enclosing scope.
+Unqualified name lookup [[basic.lookup.unqual]] ignores
 labels. — *end note*]
+Case labels and default labels shall occur only in `switch` statements.
 ## Expression statement <a id="stmt.expr">[[stmt.expr]]</a>
 Expression statements have the form
 ``` bnf
 expression-statement:
     expressionₒₚₜ ';'
 ```
+The expression is a discarded-value expression [[expr.context]]. All
 side effects from an expression statement are completed before the next
 statement is executed. An expression statement with the expression
 missing is called a *null statement*.
 [*Note 1*: Most statements are expression statements — usually
 assignments or function calls. A null statement is useful to carry a
 label just before the `}` of a compound statement and to supply a null
+body to an iteration statement such as a `while` statement
+[[stmt.while]]. — *end note*]
 ## Compound statement or block <a id="stmt.block">[[stmt.block]]</a>
 So that several statements can be used where one is expected, the
 compound statement (also, and equivalently, called “block”) is provided.
 statement-seq:
     statement
     statement-seq statement
 ```
+A compound statement defines a block scope [[basic.scope]].
+[*Note 1*: A declaration is a *statement* [[stmt.dcl]]. — *end note*]
 ## Selection statements <a id="stmt.select">[[stmt.select]]</a>
 Selection statements choose one of several flows of control.
 ``` bnf
 selection-statement:
+    if constexprₒₚₜ '(' init-statementₒₚₜ condition ')' statement
+    if constexprₒₚₜ '(' init-statementₒₚₜ condition ')' statement else statement
+    switch '(' init-statementₒₚₜ condition ')' statement
 ```
 See  [[dcl.meaning]] for the optional *attribute-specifier-seq* in a
 condition.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
+The substatement in a *selection-statement* (each substatement, in the
+`else` form of the `if` statement) implicitly defines a block scope
+[[basic.scope]]. If the substatement in a *selection-statement* is a
+single statement and not a *compound-statement*, it is as if it was
+rewritten to be a *compound-statement* containing the original
+substatement.
 [*Example 1*:
 ``` cpp
 if (x)
 — *end example*]
 ### The `if` statement <a id="stmt.if">[[stmt.if]]</a>
+If the condition [[stmt.select]] yields `true` the first substatement is
+executed. If the `else` part of the selection statement is present and
+the condition yields `false`, the second substatement is executed. If
+the first substatement is reached via a label, the condition is not
 evaluated and the second substatement is not executed. In the second
 form of `if` statement (the one including `else`), if the first
 substatement is also an `if` statement then that inner `if` statement
 shall contain an `else` part.[^1]
 If the `if` statement is of the form `if constexpr`, the value of the
 condition shall be a contextually converted constant expression of type
+`bool` [[expr.const]]; this form is called a *constexpr if* statement.
+If the value of the converted condition is `false`, the first
 substatement is a *discarded statement*, otherwise the second
 substatement, if present, is a discarded statement. During the
+instantiation of an enclosing templated entity [[temp.pre]], if the
 condition is not value-dependent after its instantiation, the discarded
 substatement (if any) is not instantiated.
+[*Note 1*: Odr-uses [[basic.def.odr]] in a discarded statement do not
+require an entity to be defined. — *end note*]
 A `case` or `default` label appearing within such an `if` statement
+shall be associated with a `switch` statement [[stmt.switch]] within the
+same `if` statement. A label [[stmt.label]] declared in a substatement
+of a constexpr if statement shall only be referred to by a statement
+[[stmt.goto]] in the same substatement.
 [*Example 1*:
 ``` cpp
 template<typename T, typename ... Rest> void g(T&& p, Rest&& ...rs) {
 — *end example*]
 An `if` statement of the form
 ``` bnf
+if constexprₒₚₜ '(' init-statement condition ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statement
+   if constexprₒₚₜ '(' condition ')' statement
+'}'
+```
 and an `if` statement of the form
 ``` bnf
+if constexprₒₚₜ '(' init-statement condition ')' statement else statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statement
+   if constexprₒₚₜ '(' condition ')' statement else statement
+'}'
+```
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*.
 ### The `switch` statement <a id="stmt.switch">[[stmt.switch]]</a>
 The `switch` statement causes control to be transferred to one of
 several statements depending on the value of a condition.
 The condition shall be of integral type, enumeration type, or class
 type. If of class type, the condition is contextually implicitly
+converted [[conv]] to an integral or enumeration type. If the (possibly
+converted) type is subject to integral promotions [[conv.prom]], the
+condition is converted to the promoted type. Any statement within the
+`switch` statement can be labeled with one or more case labels as
+follows:
 ``` bnf
+case constant-expression ':'
 ```
+where the *constant-expression* shall be a converted constant expression
+[[expr.const]] of the adjusted type of the switch condition. No two of
+the case constants in the same switch shall have the same value after
+conversion.
 There shall be at most one label of the form
 ``` cpp
 default :
 within a `switch` statement.
 Switch statements can be nested; a `case` or `default` label is
 associated with the smallest switch enclosing it.
+When the `switch` statement is executed, its condition is evaluated. If
+one of the case constants has the same value as the condition, control
+is passed to the statement following the matched case label. If no case
+constant matches the condition, and if there is a `default` label,
+control passes to the statement labeled by the default label. If no case
+matches and if there is no `default` then none of the statements in the
+switch is executed.
 `case` and `default` labels in themselves do not alter the flow of
 control, which continues unimpeded across such labels. To exit from a
+switch, see `break`, [[stmt.break]].
 [*Note 1*: Usually, the substatement that is the subject of a switch is
 compound and `case` and `default` labels appear on the top-level
 statements contained within the (compound) substatement, but this is not
 required. Declarations can appear in the substatement of a `switch`
 statement. — *end note*]
 A `switch` statement of the form
 ``` bnf
+switch '(' init-statement condition ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statement
+   switch '(' condition ')' statement
+'}'
+```
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*.
 ## Iteration statements <a id="stmt.iter">[[stmt.iter]]</a>
 Iteration statements specify looping.
 ``` bnf
 iteration-statement:
+    while '(' condition ')' statement
+    do statement while '(' expression ')' ';'
+    for '(' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
+    for '(' init-statementₒₚₜ for-range-declaration ':' for-range-initializer ')' statement
 ```
 ``` bnf
 for-range-declaration:
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
 *for-range-declaration*.
 [*Note 1*: An *init-statement* ends with a semicolon. — *end note*]
 The substatement in an *iteration-statement* implicitly defines a block
+scope [[basic.scope]] which is entered and exited each time through the
+loop. If the substatement in an *iteration-statement* is a single
+statement and not a *compound-statement*, it is as if it was rewritten
+to be a *compound-statement* containing the original statement.
 [*Example 1*:
 ``` cpp
 while (--x >= 0)
 — *end example*]
 ### The `while` statement <a id="stmt.while">[[stmt.while]]</a>
 In the `while` statement the substatement is executed repeatedly until
+the value of the condition [[stmt.select]] becomes `false`. The test
 takes place before each execution of the substatement.
 When the condition of a `while` statement is a declaration, the scope of
+the variable that is declared extends from its point of declaration
+[[basic.scope.pdecl]] to the end of the `while` *statement*. A `while`
+statement is equivalent to
+``` bnf
+label ':'
+'{'
+   if '(' condition ')' '{'
       statement
+ goto label ';'
+   '}'
+'}'
 ```
+[*Note 1*:
+The variable created in the condition is destroyed and created with each
 iteration of the loop.
 [*Example 1*:
 ``` cpp
 once for the condition that succeeds and once for the condition that
 fails.
 — *end example*]
+— *end note*]
 ### The `do` statement <a id="stmt.do">[[stmt.do]]</a>
+The expression is contextually converted to `bool` [[conv]]; if that
+conversion is ill-formed, the program is ill-formed.
 In the `do` statement the substatement is executed repeatedly until the
 value of the expression becomes `false`. The test takes place after each
 execution of the statement.
 ### The `for` statement <a id="stmt.for">[[stmt.for]]</a>
 The `for` statement
 ``` bnf
+for '(' init-statement conditionₒₚₜ ';' expressionₒₚₜ ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statement
+   while '(' condition ')' '{'
+     statement
+     expression ';'
+   '}'
+'}'
+```
 except that names declared in the *init-statement* are in the same
 declarative region as those declared in the *condition*, and except that
 a `continue` in *statement* (not enclosed in another iteration
 statement) will execute *expression* before re-evaluating *condition*.
 [*Note 1*: Thus the first statement specifies initialization for the
+loop; the condition [[stmt.select]] specifies a test, sequenced before
+each iteration, such that the loop is exited when the condition becomes
+`false`; the expression often specifies incrementing that is sequenced
+after each iteration. — *end note*]
 Either or both of the *condition* and the *expression* can be omitted. A
 missing *condition* makes the implied `while` clause equivalent to
 `while(true)`.
 ### The range-based `for` statement <a id="stmt.ranged">[[stmt.ranged]]</a>
 The range-based `for` statement
 ``` bnf
+for '(' init-statementₒₚₜ for-range-declaration ':' for-range-initializer ')' statement
 ```
 is equivalent to
+``` bnf
+'{'
+   init-statementₒₚₜ
+   auto '&&'range '=' for-range-initializer ';'
+   auto begin '=' begin-expr ';'
+   auto end '=' end-expr ';'
+   for '(' ';' begin '!=' end';' '++'begin ')' '{'
+     for-range-declaration '=' '*' begin ';'
+     statement
+   '}'
+'}'
+```
 where
 - if the *for-range-initializer* is an *expression*, it is regarded as
   if it were surrounded by parentheses (so that a comma operator cannot
   be reinterpreted as delimiting two *init-declarator*s);
+- *`range`*, *`begin`*, and *`end`* are variables defined for exposition
   only; and
 - *begin-expr* and *end-expr* are determined as follows:
   - if the *for-range-initializer* is an expression of array type `R`,
+    *begin-expr* and *end-expr* are *`range`* and *`range`* `+` `N`,
+    respectively, where `N` is the array bound. If `R` is an array of
+    unknown bound or an array of incomplete type, the program is
     ill-formed;
   - if the *for-range-initializer* is an expression of class type `C`,
     the *unqualified-id*s `begin` and `end` are looked up in the scope
+    of `C` as if by class member access lookup
+    [[basic.lookup.classref]], and if both find at least one
+    declaration, *begin-expr* and *end-expr* are `range.begin()` and
+    `range.end()`, respectively;
+  - otherwise, *begin-expr* and *end-expr* are `begin(range)` and
+    `end(range)`, respectively, where `begin` and `end` are looked up in
+    the associated namespaces [[basic.lookup.argdep]].
+    \[*Note 1*: Ordinary unqualified lookup [[basic.lookup.unqual]] is
+    not performed. — *end note*]
 [*Example 1*:
 ``` cpp
 int array[5] = { 1, 2, 3, 4, 5 };
 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.
 ## Declaration statement <a id="stmt.dcl">[[stmt.dcl]]</a>
 A declaration statement introduces one or more new identifiers into a
 block; it has the form
 If an identifier introduced by a declaration was previously declared in
 an outer block, the outer declaration is hidden for the remainder of the
 block, after which it resumes its force.
+Variables with automatic storage duration [[basic.stc.auto]] are
 initialized each time their *declaration-statement* is executed.
 Variables with automatic storage duration declared in the block are
+destroyed on exit from the block [[stmt.jump]].
 It is possible to transfer into a block, but not in a way that bypasses
+declarations with initialization (including ones in *condition*s and
+*init-statement*s). A program that jumps[^2] from a point where a
+variable with automatic storage duration is not in scope to a point
+where it is in scope is ill-formed unless the variable has vacuous
+initialization [[basic.life]]. In such a case, the variables with
+vacuous initialization are constructed in the order of their
+declaration.
 [*Example 1*:
 ``` cpp
 void f() {
   // ...
+  goto lx;          // error: jump into scope of a
   // ...
 ly:
   X a = 1;
   // ...
 lx:
 ```
 — *end example*]
 Dynamic initialization of a block-scope variable with static storage
+duration [[basic.stc.static]] or thread storage duration
+[[basic.stc.thread]] is performed the first time control passes through
 its declaration; such a variable is considered initialized upon the
 completion of its initialization. If the initialization exits by
 throwing an exception, the initialization is not complete, so it will be
 tried again the next time control enters the declaration. If control
 enters the declaration concurrently while the variable is being
 [*Example 2*:
 ``` cpp
 int foo(int i) {
+  static int s = foo(2*i);      // undefined behavior: recursive call
   return i+1;
 }
 ```
 — *end example*]
+A block-scope object with static or thread storage duration will be
+destroyed if and only if it was constructed.
 [*Note 1*:  [[basic.start.term]] describes the order in which
 block-scope objects with static and thread storage duration are
 destroyed. — *end note*]
 ## Ambiguity resolution <a id="stmt.ambig">[[stmt.ambig]]</a>
 There is an ambiguity in the grammar involving *expression-statement*s
 and *declaration*s: An *expression-statement* with a function-style
+explicit type conversion [[expr.type.conv]] as its leftmost
 subexpression can be indistinguishable from a *declaration* where the
 first *declarator* starts with a `(`. In those cases the *statement* is
 a *declaration*.
 [*Note 1*:
 to be examined to determine whether this is the case. This resolves the
 meaning of many examples.
 [*Example 1*:
+Assuming `T` is a *simple-type-specifier* [[dcl.type]],
 ``` cpp
 T(a)->m = 7;        // expression-statement
 T(a)++;             // expression-statement
 T(a,5)<<c;          // expression-statement
 — *end example*]
 <!-- Link reference definitions -->
 [basic.def.odr]: basic.md#basic.def.odr
+[basic.life]: basic.md#basic.life
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope]: basic.md#basic.scope
+[basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
+[class.copy.elision]: class.md#class.copy.elision
+[class.ctor]: class.md#class.ctor
+[class.dtor]: class.md#class.dtor
+[class.temporary]: basic.md#class.temporary
+[conv]: expr.md#conv
+[conv.prom]: expr.md#conv.prom
+[dcl.dcl]: dcl.md#dcl.dcl
+[dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.init]: dcl.md#dcl.init
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type]: dcl.md#dcl.type
+[except.ctor]: except.md#except.ctor
+[expr.await]: expr.md#expr.await
 [expr.const]: expr.md#expr.const
+[expr.context]: expr.md#expr.context
 [expr.type.conv]: expr.md#expr.type.conv
 [stmt.ambig]: #stmt.ambig
 [stmt.block]: #stmt.block
 [stmt.break]: #stmt.break
 [stmt.cont]: #stmt.cont
 [stmt.goto]: #stmt.goto
 [stmt.if]: #stmt.if
 [stmt.iter]: #stmt.iter
 [stmt.jump]: #stmt.jump
 [stmt.label]: #stmt.label
+[stmt.pre]: #stmt.pre
 [stmt.ranged]: #stmt.ranged
 [stmt.return]: #stmt.return
+[stmt.return.coroutine]: #stmt.return.coroutine
 [stmt.select]: #stmt.select
 [stmt.stmt]: #stmt.stmt
 [stmt.switch]: #stmt.switch
 [stmt.while]: #stmt.while
+[support.start.term]: support.md#support.start.term
+[temp.pre]: temp.md#temp.pre
 [^1]: In other words, the `else` is associated with the nearest un-elsed
     `if`.
 [^2]: The transfer from the condition of a `switch` statement to a

Diff to HTML by rtfpessoa