[dcl.type.auto.deduct] - C++20 → C++23

Files changed (1) hide show

tmp/tmpi5fxs06g/{from.md → to.md} +49 -28

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

@@ -2,44 +2,63 @@
 *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>
@@ -66,12 +85,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;
@@ -86,10 +105,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 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