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

Files changed (1) hide show

tmp/tmppvd3j7tt/{from.md → to.md} +129 -103

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

@@ -1,54 +1,53 @@
-#### The `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` and `decltype(auto)` *type-specifier*s are used to designate
-a placeholder type that will be replaced later by deduction from an
-initializer. The `auto` *type-specifier* is also used to introduce a
-function type having a *trailing-return-type* or to signify that a
-lambda is a generic lambda ([[expr.prim.lambda.closure]]). The `auto`
-*type-specifier* is also used to introduce a structured binding
-declaration ([[dcl.struct.bind]]).
 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
 function. If the declared return type of the function contains a
 placeholder type, the return type of the function is deduced from
-non-discarded `return` statements, if any, in the body of the function (
-[[stmt.if]]).
-If the `auto` *type-specifier* appears as one of the *decl-specifier*s
-in the *decl-specifier-seq* of a *parameter-declaration* of a
-*lambda-expression*, the lambda is a *generic lambda* (
-[[expr.prim.lambda.closure]]).
-[*Example 1*:
-``` cpp
-auto glambda = [](int i, auto a) { return i; };     // OK: a generic lambda
-```
-— *end example*]
-The type of a variable declared using `auto` or `decltype(auto)` is
-deduced from its initializer. This use is allowed in an initializing
-declaration ([[dcl.init]]) of a variable. `auto` or `decltype(auto)`
-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 2*:
 ``` 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
@@ -58,25 +57,28 @@ 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*]
 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 `auto` or `decltype(auto)` in a context not
-explicitly allowed in this section 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 3*:
 ``` cpp
 auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
@@ -91,53 +93,60 @@ same in each deduction, the program is ill-formed.
 If a function with a declared return type that uses a placeholder type
 has no non-discarded `return` statements, the return type is deduced as
 though from a `return` statement with no operand at the closing brace of
 the function body.
-[*Example 4*:
 ``` cpp
 auto  f() { }                   // OK, return type is void
-auto* g() { }                   // error, cannot deduce auto* from void()
 ```
 — *end example*]
-If the type of an entity with an undeduced placeholder type is needed to
-determine the type of 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 5*:
 ``` cpp
-auto n = n;                     // error, n's type is unknown
 auto f();
-void g() { &f; }                // error, f's return type is unknown
 auto sum(int i) {
   if (i == 1)
     return i;                   // sum's return type is int
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 — *end example*]
-Return type deduction for a 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 1*: 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 (
-[[temp.deduct]]). — *end note*]
-[*Example 6*:
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
@@ -147,49 +156,61 @@ void g() { int (*p)(int*) = &f; }               // instantiates both fs to deter
 — *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.
-[*Example 7*:
 ``` 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
 template<> auto g(double);                      // OK, forward declaration with unknown return type
 template <class T> T g(T t) { return t; }       // OK, not functionally equivalent to #1
 template char g(char);                          // OK, now there is a matching template
 template auto g(float);                         // still matches #1
-void h() { return g(42); }                      // error, ambiguous
 template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
 ```
 — *end example*]
 A function declared with a return type that uses a placeholder type
-shall not be `virtual` ([[class.virtual]]).
-An explicit instantiation declaration ([[temp.explicit]]) does not
-cause the instantiation of an entity declared using a placeholder type,
-but it also does not prevent that entity from being instantiated as
-needed to determine its type.
-[*Example 8*:
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
@@ -202,45 +223,46 @@ 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 `decltype(auto)` or cv `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 is the `auto` *type-specifier*, the deduced type T'
-replacing `T` is determined using the rules for template argument
-deduction. Obtain `P` from `T` by replacing the occurrences of `auto`
-with either 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 9*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
 auto x2 = { 1, 2.0 };           // error: cannot deduce element type
 auto x3{ 1, 2 };                // error: not a single element
@@ -248,11 +270,11 @@ auto x4 = { 3 };                // decltype(x4) is std::initializer_list<int>
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
-[*Example 10*:
 ``` cpp
 const auto &i = expr;
 ```
@@ -263,16 +285,16 @@ The type of `i` is the deduced type of the parameter `u` in the call
 template <class U> void f(const U& u);
 ```
 — *end example*]
-If the placeholder is the `decltype(auto)` *type-specifier*, `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 11*:
 ``` cpp
 int i;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
@@ -282,12 +304,16 @@ decltype(auto) x3d = i;         // decltype(x3d) is int
 auto           x4a = (i);       // decltype(x4a) is int
 decltype(auto) x4d = (i);       // decltype(x4d) is int&
 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*]

+#### Placeholder type specifiers <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
+``` bnf
+placeholder-type-specifier:
+ type-constraintₒₚₜ auto
+ type-constraintₒₚₜ decltype '(' auto ')'
+```
+A *placeholder-type-specifier* designates a placeholder type that will
+be replaced later by deduction from an initializer.
+A *placeholder-type-specifier* of the form *type-constraint*ₒₚₜ  `auto`
+can be used as a *decl-specifier* of the *decl-specifier-seq* of a
+*parameter-declaration* of a function declaration or *lambda-expression*
+and, if it is not the `auto` *type-specifier* introducing a
+*trailing-return-type* (see below), is a *generic parameter type
+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
 function. If the declared return type of the function contains a
 placeholder type, the return type of the function is deduced from
+non-discarded `return` statements, if any, in the body of the function
+[[stmt.if]].
+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 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
 ```
 If a function with a declared return type that uses a placeholder type
 has no non-discarded `return` statements, the return type is deduced as
 though from a `return` statement with no operand at the closing brace of
 the function body.
+[*Example 3*:
 ``` cpp
 auto  f() { }                   // OK, return type is void
+auto* g() { }                   // error: cannot deduce auto* from void()
 ```
 — *end example*]
+An exported function with a declared return type that uses a placeholder
+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
 auto f();
+void g() { &f; }                // error: f's return type is unknown
 auto sum(int i) {
   if (i == 1)
     return i;                   // sum's return type is int
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 — *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
+[[temp.deduct]]. — *end note*]
+[*Example 5*:
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
 — *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
 template<> auto g(double);                      // OK, forward declaration with unknown return type
 template <class T> T g(T t) { return t; }       // OK, not functionally equivalent to #1
 template char g(char);                          // OK, now there is a matching template
 template auto g(float);                         // still matches #1
+void h() { return g(42); }                      // error: ambiguous
 template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
+extern int v;
+auto v = 17;                                    // OK, redeclares v
+struct S {
+  static int i;
+};
+auto S::i = 23;                                 // OK
 ```
 — *end example*]
 A function declared with a return type that uses a placeholder type
+shall not be `virtual` [[class.virtual]].
+A function declared with a return type that uses a placeholder type
+shall not be a coroutine [[dcl.fct.def.coroutine]].
+An explicit instantiation declaration [[temp.explicit]] does not cause
+the instantiation of an entity declared using a placeholder type, but it
+also does not prevent that entity from being instantiated as needed to
+determine its type.
+[*Example 7*:
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
 *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>
 auto x2 = { 1, 2.0 };           // error: cannot deduce element type
 auto x3{ 1, 2 };                // error: not a single element
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
+[*Example 9*:
 ``` cpp
 const auto &i = expr;
 ```
 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;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
 auto           x4a = (i);       // decltype(x4a) is int
 decltype(auto) x4d = (i);       // decltype(x4d) is int&
 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
+immediately-declared constraint [[temp.param]] of the *type-constraint*
+for the type deduced for the placeholder shall be satisfied.

Diff to HTML by rtfpessoa