[dcl.spec.auto] - C++20 → C++23

Files changed (1) hide show

tmp/tmpzmt340_k/{from.md → to.md} +78 -62

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

@@ -1,7 +1,9 @@
 #### Placeholder type specifiers <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
 ``` bnf
 placeholder-type-specifier:
   type-constraintₒₚₜ auto
   type-constraintₒₚₜ decltype '(' auto ')'
 ```
@@ -18,11 +20,11 @@ placeholder* of the function declaration or *lambda-expression*.
 [*Note 1*: Having a generic parameter type placeholder signifies that
 the function is an abbreviated function template [[dcl.fct]] or the
 lambda is a generic lambda [[expr.prim.lambda]]. — *end note*]
-The placeholder type can appear with a function declarator in the
 *decl-specifier-seq*, *type-specifier-seq*, *conversion-function-id*, or
 *trailing-return-type*, in any context where such a declarator is valid.
 If the function declarator includes a *trailing-return-type*
 [[dcl.fct]], that *trailing-return-type* specifies the declared return
 type of the function. Otherwise, the function declarator shall declare a
@@ -34,54 +36,49 @@ non-discarded `return` statements, if any, in the body of the function
 The type of a variable declared using a placeholder type is deduced from
 its initializer. This use is allowed in an initializing declaration
 [[dcl.init]] of a variable. The placeholder type shall appear as one of
 the *decl-specifier*s in the *decl-specifier-seq* and the
 *decl-specifier-seq* shall be followed by one or more *declarator*s,
-each of which shall be followed by a non-empty *initializer*. In an
-*initializer* of the form
-``` cpp
-( expression-list )
-```
-the *expression-list* shall be a single *assignment-expression*.
 [*Example 1*:
 ``` cpp
-auto x = 5;                     // OK: x has type int
-const auto *v = &x, u = 6;      // OK: v has type const int*, u has type const int
-static auto y = 0.0;            // OK: y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
-auto f() -> int;                // OK: f returns int
-auto g() { return 0.0; }        // OK: g returns double
-auto h();                       // OK: h's return type will be deduced when it is defined
 ```
 — *end example*]
 The `auto` *type-specifier* can also be used to introduce a structured
 binding declaration [[dcl.struct.bind]].
 A placeholder type can also be used in the *type-specifier-seq* in the
 *new-type-id* or *type-id* of a *new-expression* [[expr.new]] and as a
 *decl-specifier* of the *parameter-declaration*'s *decl-specifier-seq*
-in a *template-parameter* [[temp.param]].
 A program that uses a placeholder type in a context not explicitly
-allowed in this subclause is ill-formed.
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
 variable is determined by placeholder type deduction
 [[dcl.type.auto.deduct]], and if the type that replaces the placeholder
 type is not the same in each deduction, the program is ill-formed.
 [*Example 2*:
 ``` cpp
-auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
 — *end example*]
@@ -109,15 +106,15 @@ type shall be defined in the translation unit containing its exported
 declaration, outside the *private-module-fragment* (if any).
 [*Note 2*: The deduced return type cannot have a name with internal
 linkage [[basic.link]]. — *end note*]
-If the name of an entity with an undeduced placeholder type appears in
-an expression, the program is ill-formed. Once a non-discarded `return`
-statement has been seen in a function, however, the return type deduced
-from that statement can be used in the rest of the function, including
-in other `return` statements.
 [*Example 4*:
 ``` cpp
 auto n = n;                     // error: n's initializer refers to n
@@ -131,14 +128,14 @@ auto sum(int i) {
 }
 ```
 — *end example*]
-Return type deduction for a templated entity that is a function or
-function template with a placeholder in its declared type occurs when
-the definition is instantiated even if the function body contains a
-`return` statement with a non-type-dependent operand.
 [*Note 3*: Therefore, any use of a specialization of the function
 template will cause an implicit instantiation. Any errors that arise
 from this instantiation are not in the immediate context of the function
 type and can result in the program being ill-formed
@@ -154,24 +151,22 @@ void g() { int (*p)(int*) = &f; }               // instantiates both fs to deter
                                                 // chooses second
 ```
 — *end example*]
-Redeclarations or specializations of a function or function template
-with a declared return type that uses a placeholder type shall also use
-that placeholder, not a deduced type. Similarly, redeclarations or
-specializations of a function or function template with a declared
-return type that does not use a placeholder type shall not use a
-placeholder.
 [*Example 6*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
-int f();                                        // error: cannot be overloaded with auto f()
 decltype(auto) f();                             // error: auto and decltype(auto) don't match
 template <typename T> auto g(T t) { return t; } // #1
 template auto g(int);                           // OK, return type is int
 template char g(char);                          // error: no matching template
@@ -223,44 +218,63 @@ int (*p)(int) = f;              // instantiates f<int> to determine its return t
 *Placeholder type deduction* is the process by which a type containing a
 placeholder type is replaced by a deduced type.
 A type `T` containing a placeholder type, and a corresponding
-initializer E, are determined as follows:
-- for a non-discarded `return` statement that occurs in a function
   declared with a return type that contains a placeholder type, `T` is
-  the declared return type and E is the operand of the `return`
- statement. If the `return` statement has no operand, then E is
- `void()`;
-- for a variable declared with a type that contains a placeholder type,
- `T` is the declared type of the variable and E is the initializer. If
-  the initialization is direct-list-initialization, the initializer
-  shall be a *braced-init-list* containing only a single
- *assignment-expression* and E is the *assignment-expression*;
-- for a non-type template parameter declared with a type that contains a
   placeholder type, `T` is the declared type of the non-type template
   parameter and E is the corresponding template argument.
-In the case of a `return` statement with no operand or with an operand
-of type `void`, `T` shall be either *type-constraint*ₒₚₜ
-`decltype(auto)` or cv *type-constraint*ₒₚₜ  `auto`.
-If the deduction is for a `return` statement and E is a
-*braced-init-list* [[dcl.init.list]], the program is ill-formed.
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `auto`, the deduced type T' replacing `T` is determined using the rules
-for template argument deduction. Obtain `P` from `T` by replacing the
-occurrences of *type-constraint*ₒₚₜ  `auto` either with a new invented
-type template parameter `U` or, if the initialization is
-copy-list-initialization, with `std::initializer_list<U>`. Deduce a
-value for `U` using the rules of template argument deduction from a
-function call [[temp.deduct.call]], where `P` is a function template
-parameter type and the corresponding argument is E. If the deduction
-fails, the declaration is ill-formed. Otherwise, T' is obtained by
-substituting the deduced `U` into `P`.
 [*Example 8*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
@@ -287,12 +301,12 @@ template <class U> void f(const U& u);
 — *end example*]
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `decltype(auto)`, `T` shall be the placeholder alone. The type deduced
-for `T` is determined as described in  [[dcl.type.simple]], as though E
-had been the operand of the `decltype`.
 [*Example 10*:
 ``` cpp
 int i;
@@ -307,10 +321,12 @@ auto           x5a = f();       // decltype(x5a) is int
 decltype(auto) x5d = f();       // decltype(x5d) is int&&
 auto           x6a = { 1, 2 };  // decltype(x6a) is std::initializer_list<int>
 decltype(auto) x6d = { 1, 2 };  // error: { 1, 2 } is not an expression
 auto          *x7a = &i;        // decltype(x7a) is int*
 decltype(auto)*x7d = &i;        // error: declared type is not plain decltype(auto)
 ```
 — *end example*]
 For a *placeholder-type-specifier* with a *type-constraint*, the

 #### Placeholder type specifiers <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
+##### General <a id="dcl.spec.auto.general">[[dcl.spec.auto.general]]</a>
 ``` bnf
 placeholder-type-specifier:
   type-constraintₒₚₜ auto
   type-constraintₒₚₜ decltype '(' auto ')'
 ```
 [*Note 1*: Having a generic parameter type placeholder signifies that
 the function is an abbreviated function template [[dcl.fct]] or the
 lambda is a generic lambda [[expr.prim.lambda]]. — *end note*]
+A placeholder type can appear with a function declarator in the
 *decl-specifier-seq*, *type-specifier-seq*, *conversion-function-id*, or
 *trailing-return-type*, in any context where such a declarator is valid.
 If the function declarator includes a *trailing-return-type*
 [[dcl.fct]], that *trailing-return-type* specifies the declared return
 type of the function. Otherwise, the function declarator shall declare a
 The type of a variable declared using a placeholder type is deduced from
 its initializer. This use is allowed in an initializing declaration
 [[dcl.init]] of a variable. The placeholder type shall appear as one of
 the *decl-specifier*s in the *decl-specifier-seq* and the
 *decl-specifier-seq* shall be followed by one or more *declarator*s,
+each of which shall be followed by a non-empty *initializer*.
 [*Example 1*:
 ``` cpp
+auto x = 5;                     // OK, x has type int
+const auto *v = &x, u = 6;      // OK, v has type const int*, u has type const int
+static auto y = 0.0;            // OK, y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
+auto f() -> int;                // OK, f returns int
+auto g() { return 0.0; }        // OK, g returns double
+auto h();                       // OK, h's return type will be deduced when it is defined
 ```
 — *end example*]
 The `auto` *type-specifier* can also be used to introduce a structured
 binding declaration [[dcl.struct.bind]].
 A placeholder type can also be used in the *type-specifier-seq* in the
 *new-type-id* or *type-id* of a *new-expression* [[expr.new]] and as a
 *decl-specifier* of the *parameter-declaration*'s *decl-specifier-seq*
+in a *template-parameter* [[temp.param]]. The `auto` *type-specifier*
+can also be used as the *simple-type-specifier* in an explicit type
+conversion (functional notation) [[expr.type.conv]].
 A program that uses a placeholder type in a context not explicitly
+allowed in [[dcl.spec.auto]] is ill-formed.
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
 variable is determined by placeholder type deduction
 [[dcl.type.auto.deduct]], and if the type that replaces the placeholder
 type is not the same in each deduction, the program is ill-formed.
 [*Example 2*:
 ``` cpp
+auto x = 5, *y = &x;            // OK, auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
 — *end example*]
 declaration, outside the *private-module-fragment* (if any).
 [*Note 2*: The deduced return type cannot have a name with internal
 linkage [[basic.link]]. — *end note*]
+If a variable or function with an undeduced placeholder type is named by
+an expression [[basic.def.odr]], the program is ill-formed. Once a
+non-discarded `return` statement has been seen in a function, however,
+the return type deduced from that statement can be used in the rest of
+the function, including in other `return` statements.
 [*Example 4*:
 ``` cpp
 auto n = n;                     // error: n's initializer refers to n
 }
 ```
 — *end example*]
+Return type deduction for a templated function with a placeholder in its
+declared type occurs when the definition is instantiated even if the
+function body contains a `return` statement with a non-type-dependent
+operand.
 [*Note 3*: Therefore, any use of a specialization of the function
 template will cause an implicit instantiation. Any errors that arise
 from this instantiation are not in the immediate context of the function
 type and can result in the program being ill-formed
                                                 // chooses second
 ```
 — *end example*]
+If a function or function template F has a declared return type that
+uses a placeholder type, redeclarations or specializations of F shall
+use that placeholder type, not a deduced type; otherwise, they shall not
+use a placeholder type.
 [*Example 6*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
+int f();                                        // error: auto and int don't match
 decltype(auto) f();                             // error: auto and decltype(auto) don't match
 template <typename T> auto g(T t) { return t; } // #1
 template auto g(int);                           // OK, return type is int
 template char g(char);                          // error: no matching template
 *Placeholder type deduction* is the process by which a type containing a
 placeholder type is replaced by a deduced type.
 A type `T` containing a placeholder type, and a corresponding
+*initializer-clause* E, are determined as follows:
+- For a non-discarded `return` statement that occurs in a function
   declared with a return type that contains a placeholder type, `T` is
+  the declared return type.
+ - If the `return` statement has no operand, then E is `void()`.
+ - If the operand is a *braced-init-list* [[dcl.init.list]], the
+    program is ill-formed.
+ - If the operand is an *expression* X that is not an
+    *assignment-expression*, E is `(X)`. \[*Note 4*: A comma expression
+    [[expr.comma]] is not an *assignment-expression*. — *end note*]
+  - Otherwise, E is the operand of the `return` statement.
+  If E has type `void`, `T` shall be either *type-constraint*ₒₚₜ
+  `decltype(auto)` or cv *type-constraint*ₒₚₜ  `auto`.
+- For a variable declared with a type that contains a placeholder type,
+  `T` is the declared type of the variable.
+  - If the initializer of the variable is a *brace-or-equal-initializer*
+    of the form `= initializer-clause`, E is the *initializer-clause*.
+  - If the initializer is a *braced-init-list*, it shall consist of a
+    single brace-enclosed *assignment-expression* and E is the
+    *assignment-expression*.
+  - If the initializer is a parenthesized *expression-list*, the
+    *expression-list* shall be a single *assignment-expression* and E is
+    the *assignment-expression*.
+- For an explicit type conversion [[expr.type.conv]], `T` is the
+  specified type, which shall be `auto`.
+  - If the initializer is a *braced-init-list*, it shall consist of a
+    single brace-enclosed *assignment-expression* and E is the
+    *assignment-expression*.
+  - If the initializer is a parenthesized *expression-list*, the
+    *expression-list* shall be a single *assignment-expression* and E is
+    the *assignment-expression*.
+- For a non-type template parameter declared with a type that contains a
   placeholder type, `T` is the declared type of the non-type template
   parameter and E is the corresponding template argument.
+`T` shall not be an array type.
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `auto`, the deduced type T' replacing `T` is determined using the rules
+for template argument deduction. If the initialization is
+copy-list-initialization, a declaration of `std::initializer_list` shall
+precede [[basic.lookup.general]] the *placeholder-type-specifier*.
+Obtain `P` from `T` by replacing the occurrences of
+*type-constraint*ₒₚₜ  `auto` either with a new invented type template
+parameter `U` or, if the initialization is copy-list-initialization,
+with `std::initializer_list<U>`. Deduce a value for `U` using the rules
+of template argument deduction from a function call
+[[temp.deduct.call]], where `P` is a function template parameter type
+and the corresponding argument is E. If the deduction fails, the
+declaration is ill-formed. Otherwise, T' is obtained by substituting the
+deduced `U` into `P`.
 [*Example 8*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
 — *end example*]
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `decltype(auto)`, `T` shall be the placeholder alone. The type deduced
+for `T` is determined as described in  [[dcl.type.decltype]], as though
+E had been the operand of the `decltype`.
 [*Example 10*:
 ``` cpp
 int i;
 decltype(auto) x5d = f();       // decltype(x5d) is int&&
 auto           x6a = { 1, 2 };  // decltype(x6a) is std::initializer_list<int>
 decltype(auto) x6d = { 1, 2 };  // error: { 1, 2 } is not an expression
 auto          *x7a = &i;        // decltype(x7a) is int*
 decltype(auto)*x7d = &i;        // error: declared type is not plain decltype(auto)
+auto f1(int x) -> decltype((x)) { return (x); }         // return type is int&
+auto f2(int x) -> decltype(auto) { return (x); }        // return type is int&&
 ```
 — *end example*]
 For a *placeholder-type-specifier* with a *type-constraint*, the

Diff to HTML by rtfpessoa