[dcl.type] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp9wi9n61u/{from.md → to.md} +205 -89

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

@@ -92,11 +92,11 @@ some other access path.
 [*Note 4*: Cv-qualifiers are supported by the type system so that they
 cannot be subverted without casting [[expr.const.cast]]. — *end note*]
 Any attempt to modify
-[[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]] a const object
 [[basic.type.qualifier]] during its lifetime [[basic.life]] results in
 undefined behavior.
 [*Example 1*:
@@ -144,27 +144,27 @@ The semantics of an access through a volatile glvalue are
 *implementation-defined*. If an attempt is made to access an object
 defined with a volatile-qualified type through the use of a non-volatile
 glvalue, the behavior is undefined.
 [*Note 5*: `volatile` is a hint to the implementation to avoid
-aggressive optimization involving the object because the value of the
-object might be changed by means undetectable by an implementation.
-Furthermore, for some implementations, `volatile` might indicate that
-special hardware instructions are required to access the object. See
-[[intro.execution]] for detailed semantics. In general, the semantics of
-`volatile` are intended to be the same in C++ as they are in
-C. — *end note*]
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 The simple type specifiers are
 ``` bnf
 simple-type-specifier:
     nested-name-specifierₒₚₜ type-name
     nested-name-specifier template simple-template-id
- decltype-specifier
     placeholder-type-specifier
     nested-name-specifierₒₚₜ template-name
     char
     char8_t
     char16_t
@@ -186,24 +186,36 @@ type-name:
     class-name
     enum-name
     typedef-name
 ```
 The component names of a *simple-type-specifier* are those of its
 *nested-name-specifier*, *type-name*, *simple-template-id*,
 *template-name*, and/or *type-constraint* (if it is a
 *placeholder-type-specifier*). The component name of a *type-name* is
 the first name in it.
 A *placeholder-type-specifier* is a placeholder for a type to be deduced
-[[dcl.spec.auto]]. A *type-specifier* of the form `typename`ₒₚₜ
-*nested-name-specifier*ₒₚₜ  *template-name* is a placeholder for a
-deduced class type [[dcl.type.class.deduct]]. The
-*nested-name-specifier*, if any, shall be non-dependent and the
-*template-name* shall name a deducible template. A *deducible template*
-is either a class template or is an alias template whose
-*defining-type-id* is of the form
 ``` bnf
 typenameₒₚₜ nested-name-specifierₒₚₜ templateₒₚₜ simple-template-id
 ```
@@ -224,12 +236,14 @@ combinations of *simple-type-specifier*s and the types they specify.
 | Specifier(s)                 | Type                                              |
 | ---------------------------- | ------------------------------------------------- |
 | *type-name*                  | the type named                                    |
 | *simple-template-id*         | the type as defined in~ [[temp.names]]            |
 | *decltype-specifier*         | the type as defined in~ [[dcl.type.decltype]]     |
 | *placeholder-type-specifier* | the type as defined in~ [[dcl.spec.auto]]         |
 | *template-name*              | the type as defined in~ [[dcl.type.class.deduct]] |
 | `char`                       | ```char`''                                        |
 | `unsigned char`              | ```unsigned char`''                               |
 | `signed char`                | ```signed char`''                                 |
 | `char8_t`                    | ```char8_t`''                                     |
 | `char16_t`                   | ```char16_t`''                                    |
@@ -271,10 +285,28 @@ intermixed with other *decl-specifier*s in any order.
 [*Note 2*: It is *implementation-defined* whether objects of `char`
 type are represented as signed or unsigned quantities. The `signed`
 specifier forces `char` objects to be signed; it is redundant in other
 contexts. — *end note*]
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
@@ -287,77 +319,77 @@ The component names of an *elaborated-type-specifier* are its
 *identifier* (if any) and those of its *nested-name-specifier* and
 *simple-template-id* (if any).
 If an *elaborated-type-specifier* is the sole constituent of a
 declaration, the declaration is ill-formed unless it is an explicit
-specialization [[temp.expl.spec]], an explicit instantiation
-[[temp.explicit]] or it has one of the following forms:
 ``` bnf
 class-key attribute-specifier-seqₒₚₜ identifier ';'
 class-key attribute-specifier-seqₒₚₜ simple-template-id ';'
 ```
 In the first case, the *elaborated-type-specifier* declares the
 *identifier* as a *class-name*. The second case shall appear only in an
 *explicit-specialization* [[temp.expl.spec]] or in a
-*template-declaration* (where it declares a partial specialization
-[[temp.decls]]). The *attribute-specifier-seq*, if any, appertains to
-the class or template being declared.
 Otherwise, an *elaborated-type-specifier* E shall not have an
 *attribute-specifier-seq*. If E contains an *identifier* but no
 *nested-name-specifier* and (unqualified) lookup for the *identifier*
 finds nothing, E shall not be introduced by the `enum` keyword and
 declares the *identifier* as a *class-name*. The target scope of E is
 the nearest enclosing namespace or block scope.
-If an *elaborated-type-specifier* appears with the `friend` specifier as
-an entire *member-declaration*, the *member-declaration* shall have one
-of the following forms:
 ``` bnf
-friend class-key nested-name-specifierₒₚₜ identifier ';'
-friend class-key simple-template-id ';'
-friend class-key nested-name-specifier templateₒₚₜ simple-template-id ';'
 ```
 Any unqualified lookup for the *identifier* (in the first case) does not
-consider scopes that contain the target scope; no name is bound.
 [*Note 1*: A *using-directive* in the target scope is ignored if it
-refers to a namespace not contained by that scope. [[basic.lookup.elab]]
-describes how name lookup proceeds in an
-*elaborated-type-specifier*. — *end note*]
-[*Note 2*: An *elaborated-type-specifier* can be used to refer to a
-previously declared *class-name* or *enum-name* even if the name has
-been hidden by a non-type declaration. — *end note*]
-If the *identifier* or *simple-template-id* resolves to a *class-name*
-or *enum-name*, the *elaborated-type-specifier* introduces it into the
-declaration the same way a *simple-type-specifier* introduces its
-*type-name* [[dcl.type.simple]]. If the *identifier* or
-*simple-template-id* resolves to a *typedef-name*
-[[dcl.typedef]], [[temp.names]], the *elaborated-type-specifier* is
-ill-formed.
 [*Note 3*:
 This implies that, within a class template with a template
 *type-parameter* `T`, the declaration
 ``` cpp
 friend class T;
 ```
-is ill-formed. However, the similar declaration `friend T;` is allowed
-[[class.friend]].
 — *end note*]
-The *class-key* or `enum` keyword present in the
 *elaborated-type-specifier* shall agree in kind with the declaration to
 which the name in the *elaborated-type-specifier* refers. This rule also
 applies to the form of *elaborated-type-specifier* that declares a
 *class-name* or friend class since it can be construed as referring to
 the definition of the class. Thus, in any *elaborated-type-specifier*,
@@ -389,17 +421,20 @@ follows:
 - if E is an unparenthesized *id-expression* naming a structured binding
   [[dcl.struct.bind]], `decltype(E)` is the referenced type as given in
   the specification of the structured binding declaration;
 - otherwise, if E is an unparenthesized *id-expression* naming a
- non-type *template-parameter* [[temp.param]], `decltype(E)` is the
- type of the *template-parameter* after performing any necessary type
   deduction [[dcl.spec.auto]], [[dcl.type.class.deduct]];
 - otherwise, if E is an unparenthesized *id-expression* or an
   unparenthesized class member access [[expr.ref]], `decltype(E)` is the
   type of the entity named by E. If there is no such entity, the program
   is ill-formed;
 - otherwise, if E is an xvalue, `decltype(E)` is `T&&`, where `T` is the
   type of E;
 - otherwise, if E is an lvalue, `decltype(E)` is `T&`, where `T` is the
   type of E;
 - otherwise, `decltype(E)` is the type of E.
@@ -416,10 +451,19 @@ struct A { double x; };
 const A* a = new A();
 decltype(foo()) x1 = 17;        // type is const int&&
 decltype(i) x2;                 // type is int
 decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
 — *end example*]
 [*Note 1*: The rules for determining types involving `decltype(auto)`
@@ -485,64 +529,76 @@ 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*]
-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
-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*.
 [*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*,
@@ -606,10 +662,25 @@ auto sum(int i) {
 }
 ```
 — *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.
@@ -617,11 +688,11 @@ operand.
 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; }
@@ -634,11 +705,11 @@ void g() { int (*p)(int*) = &f; }               // instantiates both fs to deter
 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
@@ -679,11 +750,11 @@ 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
@@ -729,32 +800,31 @@ A type `T` containing a placeholder type, and a corresponding
     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>
 auto x2 = { 1, 2.0 };           // error: cannot deduce element type
 auto x3{ 1, 2 };                // error: not a single element
@@ -762,11 +832,11 @@ auto x4 = { 3 };                // decltype(x4) is std::initializer_list<int>
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
-[*Example 9*:
 ``` cpp
 const auto &i = expr;
 ```
@@ -782,11 +852,11 @@ template <class U> void f(const U& u);
 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;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
@@ -861,5 +931,51 @@ auto d = container(v.begin(), v.end()); // OK, deduces double for T
 container e{5, 6};                      // error: int is not an iterator
 ```
 — *end example*]

 [*Note 4*: Cv-qualifiers are supported by the type system so that they
 cannot be subverted without casting [[expr.const.cast]]. — *end note*]
 Any attempt to modify
+[[expr.assign]], [[expr.post.incr]], [[expr.pre.incr]] a const object
 [[basic.type.qualifier]] during its lifetime [[basic.life]] results in
 undefined behavior.
 [*Example 1*:
 *implementation-defined*. If an attempt is made to access an object
 defined with a volatile-qualified type through the use of a non-volatile
 glvalue, the behavior is undefined.
 [*Note 5*: `volatile` is a hint to the implementation to avoid
+aggressive optimization involving the object because it is possible for
+the value of the object to change by means undetectable by an
+implementation. Furthermore, for some implementations, `volatile` can
+indicate that special hardware instructions are needed to access the
+object. See  [[intro.execution]] for detailed semantics. In general, the
+semantics of `volatile` are intended to be the same in C++ as they are
+in C. — *end note*]
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 The simple type specifiers are
 ``` bnf
 simple-type-specifier:
     nested-name-specifierₒₚₜ type-name
     nested-name-specifier template simple-template-id
+ computed-type-specifier
     placeholder-type-specifier
     nested-name-specifierₒₚₜ template-name
     char
     char8_t
     char16_t
     class-name
     enum-name
     typedef-name
 ```
+``` bnf
+computed-type-specifier:
+    decltype-specifier
+    pack-index-specifier
+    splice-type-specifier
+```
 The component names of a *simple-type-specifier* are those of its
 *nested-name-specifier*, *type-name*, *simple-template-id*,
 *template-name*, and/or *type-constraint* (if it is a
 *placeholder-type-specifier*). The component name of a *type-name* is
 the first name in it.
 A *placeholder-type-specifier* is a placeholder for a type to be deduced
+[[dcl.spec.auto]]. A *type-specifier* is a placeholder for a deduced
+class type [[dcl.type.class.deduct]] if either
+- it is of the form `typename`ₒₚₜ  *nested-name-specifier*ₒₚₜ
+ *template-name* or
+- it is of the form `typename`ₒₚₜ  *splice-specifier* and the
+ *splice-specifier* designates a class template or alias template.
+The *nested-name-specifier* or *splice-specifier*, if any, shall be
+non-dependent and the *template-name* or *splice-specifier* shall
+designate a deducible template. A *deducible template* is either a class
+template or is an alias template whose *defining-type-id* is of the form
 ``` bnf
 typenameₒₚₜ nested-name-specifierₒₚₜ templateₒₚₜ simple-template-id
 ```
 | Specifier(s)                 | Type                                              |
 | ---------------------------- | ------------------------------------------------- |
 | *type-name*                  | the type named                                    |
 | *simple-template-id*         | the type as defined in~ [[temp.names]]            |
 | *decltype-specifier*         | the type as defined in~ [[dcl.type.decltype]]     |
+| *pack-index-specifier*       | the type as defined in~ [[dcl.type.pack.index]]   |
 | *placeholder-type-specifier* | the type as defined in~ [[dcl.spec.auto]]         |
 | *template-name*              | the type as defined in~ [[dcl.type.class.deduct]] |
+| *splice-type-specifier*      | the type as defined in~ [[dcl.type.splice]]       |
 | `char`                       | ```char`''                                        |
 | `unsigned char`              | ```unsigned char`''                               |
 | `signed char`                | ```signed char`''                                 |
 | `char8_t`                    | ```char8_t`''                                     |
 | `char16_t`                   | ```char16_t`''                                    |
 [*Note 2*: It is *implementation-defined* whether objects of `char`
 type are represented as signed or unsigned quantities. The `signed`
 specifier forces `char` objects to be signed; it is redundant in other
 contexts. — *end note*]
+#### Pack indexing specifier <a id="dcl.type.pack.index">[[dcl.type.pack.index]]</a>
+``` bnf
+pack-index-specifier:
+    typedef-name '...' '[' constant-expression ']'
+```
+The *typedef-name* P in a *pack-index-specifier* shall denote a pack.
+The *constant-expression* shall be a converted constant expression
+[[expr.const]] of type `std::size_t` whose value V, termed the index, is
+such that 0 ≤ V < `sizeof...($P$)`.
+A *pack-index-specifier* is a pack expansion [[temp.variadic]].
+[*Note 1*: The *pack-index-specifier* denotes the type of the Vᵗʰ
+element of the pack. — *end note*]
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
 *identifier* (if any) and those of its *nested-name-specifier* and
 *simple-template-id* (if any).
 If an *elaborated-type-specifier* is the sole constituent of a
 declaration, the declaration is ill-formed unless it is an explicit
+specialization [[temp.expl.spec]], a partial specialization
+[[temp.spec.partial]], an explicit instantiation [[temp.explicit]], or
+it has one of the following forms:
 ``` bnf
 class-key attribute-specifier-seqₒₚₜ identifier ';'
 class-key attribute-specifier-seqₒₚₜ simple-template-id ';'
 ```
 In the first case, the *elaborated-type-specifier* declares the
 *identifier* as a *class-name*. The second case shall appear only in an
 *explicit-specialization* [[temp.expl.spec]] or in a
+*template-declaration* (where it declares a partial specialization). The
+*attribute-specifier-seq*, if any, appertains to the class or template
+being declared.
 Otherwise, an *elaborated-type-specifier* E shall not have an
 *attribute-specifier-seq*. If E contains an *identifier* but no
 *nested-name-specifier* and (unqualified) lookup for the *identifier*
 finds nothing, E shall not be introduced by the `enum` keyword and
 declares the *identifier* as a *class-name*. The target scope of E is
 the nearest enclosing namespace or block scope.
+A *friend-type-specifier* that is an *elaborated-type-specifier* shall
+have one of the following forms:
 ``` bnf
+class-key nested-name-specifierₒₚₜ identifier
+class-key simple-template-id
+class-key nested-name-specifier templateₒₚₜ simple-template-id
 ```
 Any unqualified lookup for the *identifier* (in the first case) does not
+consider scopes that contain the nearest enclosing namespace or block
+scope; no name is bound.
 [*Note 1*: A *using-directive* in the target scope is ignored if it
+refers to a namespace not contained by that scope. — *end note*]
+[*Note 2*:  [[basic.lookup.elab]] describes how name lookup proceeds in
+an *elaborated-type-specifier*. An *elaborated-type-specifier* can be
+used to refer to a previously declared *class-name* or *enum-name* even
+if the name has been hidden by a non-type declaration. — *end note*]
+If the *identifier* or *simple-template-id* in an
+*elaborated-type-specifier* resolves to a *class-name* or *enum-name*,
+the *elaborated-type-specifier* introduces it into the declaration the
+same way a *simple-type-specifier* introduces its *type-name*
+[[dcl.type.simple]]. If the *identifier* or *simple-template-id*
+resolves to a *typedef-name* [[dcl.typedef]], [[temp.names]], the
+*elaborated-type-specifier* is ill-formed.
 [*Note 3*:
 This implies that, within a class template with a template
 *type-parameter* `T`, the declaration
 ``` cpp
 friend class T;
 ```
+is ill-formed. However, the similar declaration `friend T;` is
+well-formed [[class.friend]].
 — *end note*]
+The *class-key* or `enum` keyword present in an
 *elaborated-type-specifier* shall agree in kind with the declaration to
 which the name in the *elaborated-type-specifier* refers. This rule also
 applies to the form of *elaborated-type-specifier* that declares a
 *class-name* or friend class since it can be construed as referring to
 the definition of the class. Thus, in any *elaborated-type-specifier*,
 - if E is an unparenthesized *id-expression* naming a structured binding
   [[dcl.struct.bind]], `decltype(E)` is the referenced type as given in
   the specification of the structured binding declaration;
 - otherwise, if E is an unparenthesized *id-expression* naming a
+ constant template parameter [[temp.param]], `decltype(E)` is the type
+  of the template parameter after performing any necessary type
   deduction [[dcl.spec.auto]], [[dcl.type.class.deduct]];
 - otherwise, if E is an unparenthesized *id-expression* or an
   unparenthesized class member access [[expr.ref]], `decltype(E)` is the
   type of the entity named by E. If there is no such entity, the program
   is ill-formed;
+- otherwise, if E is an unparenthesized *splice-expression*,
+  `decltype(E)` is the type of the entity, object, or value designated
+  by the *splice-specifier* of E;
 - otherwise, if E is an xvalue, `decltype(E)` is `T&&`, where `T` is the
   type of E;
 - otherwise, if E is an lvalue, `decltype(E)` is `T&`, where `T` is the
   type of E;
 - otherwise, `decltype(E)` is the type of E.
 const A* a = new A();
 decltype(foo()) x1 = 17;        // type is const int&&
 decltype(i) x2;                 // type is int
 decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
+decltype([:^^x1:]) x5 = 18;     // type is const int&&
+decltype(([:^^x1:])) x6 = 19;   // type is const int&
+void f() {
+  [](auto ...pack) {
+    decltype(pack...[0]) x7;    // type is int
+    decltype((pack...[0])) x8;  // type is int&
+  }(0);
+}
 ```
 — *end example*]
 [*Note 1*: The rules for determining types involving `decltype(auto)`
   type-constraintₒₚₜ auto
   type-constraintₒₚₜ decltype '(' auto ')'
 ```
 A *placeholder-type-specifier* designates a placeholder type that will
+be replaced later, typically by deduction from an initializer.
+The type of a *parameter-declaration* of a
+- function declaration [[dcl.fct]],
+- *lambda-expression* [[expr.prim.lambda]], or
+- *template-parameter* [[temp.param]]
+can be declared using a *placeholder-type-specifier* of the form
+*type-constraint*ₒₚₜ  `auto`. The placeholder type shall appear as one
+of the *decl-specifier*s in the *decl-specifier-seq* or as one of the
+*type-specifier*s in a *trailing-return-type* that specifies the type
+that replaces such a *decl-specifier* (see below); the placeholder type
+is a *generic parameter type placeholder* of the function declaration,
+*lambda-expression*, or *template-parameter*, respectively.
 [*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 in the *decl-specifier-seq* for a function
+declarator that includes a *trailing-return-type* [[dcl.fct]].
+A placeholder type can appear in the *decl-specifier-seq* or
+*type-specifier-seq* in the declared return type of a function
+declarator that declares a function; 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* or as one of the
+*type-specifier*s in a *trailing-return-type* that specifies the type
+that replaces such a *decl-specifier*; 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 (*fp)() -> auto = f;       // OK
 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* of the
+*new-type-id* or in the *type-id* of a *new-expression* [[expr.new]]. In
+such a *type-id*, the placeholder type shall appear as one of the
+*type-specifier*s in the *type-specifier-seq* or as one of the
+*type-specifier*s in a *trailing-return-type* that specifies the type
+that replaces such a *type-specifier*.
+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*,
 }
 ```
 — *end example*]
+A result binding never has an undeduced placeholder type
+[[dcl.contract.res]].
+[*Example 5*:
+``` cpp
+auto f()
+  post(r : r == 7)  // OK
+{
+  return 7;
+}
+```
+— *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.
 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; }
 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 7*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
 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
     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 constant template parameter declared with a type that contains a
+  placeholder type, `T` is the declared type of the constant 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 occurrence 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 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
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
+[*Example 10*:
 ``` cpp
 const auto &i = expr;
 ```
 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 11*:
 ``` cpp
 int i;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
 container e{5, 6};                      // error: int is not an iterator
 ```
 — *end example*]
+#### Type splicing <a id="dcl.type.splice">[[dcl.type.splice]]</a>
+``` bnf
+splice-type-specifier:
+   typenameₒₚₜ splice-specifier
+   typenameₒₚₜ splice-specialization-specifier
+```
+A *splice-specifier* or *splice-specialization-specifier* immediately
+followed by `::` is never interpreted as part of a
+*splice-type-specifier*. A *splice-specifier* or
+*splice-specialization-specifier* not preceded by `typename` is only
+interpreted as a *splice-type-specifier* within a type-only context
+[[temp.res.general]].
+[*Example 1*:
+``` cpp
+template<std::meta::info R> void tfn() {
+  typename [:R:]::type m;       // OK, typename applies to the qualified name
+}
+struct S { using type = int; };
+void fn() {
+  [:^^S::type:] *var;           // error: [:^^ S::type:] is an expression
+  typename [:^^S::type:] *var;  // OK, declares variable with type int*
+}
+using alias = [:^^S::type:];    // OK, type-only context
+```
+— *end example*]
+For a *splice-type-specifier* of the form `typename`ₒₚₜ
+*splice-specifier*, the *splice-specifier* shall designate a type, a
+class template, or an alias template. The *splice-type-specifier*
+designates the same entity as the *splice-specifier*.
+For a *splice-type-specifier* of the form `typename`ₒₚₜ
+*splice-specialization-specifier*, the *splice-specifier* of the
+*splice-specialization-specifier* shall designate a template `T` that is
+either a class template or an alias template. The
+*splice-type-specifier* designates the specialization of `T`
+corresponding to the template argument list of the
+*splice-specialization-specifier*.

Diff to HTML by rtfpessoa