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

Files changed (1) hide show

tmp/tmp98pnvehg/{from.md → to.md} +284 -156

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

@@ -27,14 +27,14 @@ The optional *attribute-specifier-seq* in a *decl-specifier-seq*
 appertains to the type determined by the preceding *decl-specifier*s
 [[dcl.meaning]]. The *attribute-specifier-seq* affects the type only for
 the declaration it appears in, not other declarations involving the same
 type.
-Each *decl-specifier* shall appear at most once in a complete
-*decl-specifier-seq*, except that `long` may appear twice. At most one
-of the `constexpr`, `consteval`, and `constinit` keywords shall appear
-in a *decl-specifier-seq*.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
 is no previous *defining-type-specifier* other than a *cv-qualifier* in
 the *decl-specifier-seq*. The sequence shall be self-consistent as
@@ -225,11 +225,13 @@ modification of the mutable class member even though the rest of the
 object is const
 [[basic.type.qualifier]], [[dcl.type.cv]]. — *end note*]
 ### Function specifiers <a id="dcl.fct.spec">[[dcl.fct.spec]]</a>
-A *function-specifier* can be used only in a function declaration.
 ``` bnf
 function-specifier:
     virtual
     explicit-specifier
@@ -268,32 +270,30 @@ struct S {
 — *end example*]
 ### The `typedef` specifier <a id="dcl.typedef">[[dcl.typedef]]</a>
-Declarations containing the *decl-specifier* `typedef` declare
-identifiers that can be used later for naming fundamental
-[[basic.fundamental]] or compound [[basic.compound]] types. The
-`typedef` specifier shall not be combined in a *decl-specifier-seq* with
-any other kind of specifier except a *defining-type-specifier*, and it
-shall not be used in the *decl-specifier-seq* of a
-*parameter-declaration* [[dcl.fct]] nor in the *decl-specifier-seq* of a
-*function-definition* [[dcl.fct.def]]. If a `typedef` specifier appears
-in a declaration without a *declarator*, the program is ill-formed.
 ``` bnf
 typedef-name:
     identifier
     simple-template-id
 ```
-A name declared with the `typedef` specifier becomes a *typedef-name*. A
-*typedef-name* names the type associated with the *identifier*
-[[dcl.decl]] or *simple-template-id* [[temp.pre]]; a *typedef-name* is
-thus a synonym for another type. A *typedef-name* does not introduce a
-new type the way a class declaration [[class.name]] or enum declaration
-[[dcl.enum]] does.
 [*Example 1*:
 After
@@ -311,16 +311,16 @@ extern KLICKSP metricp;
 are all correct declarations; the type of `distance` is `int` and that
 of `metricp` is “pointer to `int`”.
 — *end example*]
-A *typedef-name* can also be introduced by an *alias-declaration*. The
 *identifier* following the `using` keyword is not looked up; it becomes
-a *typedef-name* and the optional *attribute-specifier-seq* following
-the *identifier* appertains to that *typedef-name*. Such a
-*typedef-name* has the same semantics as if it were introduced by the
-`typedef` specifier. In particular, it does not define a new type.
 [*Example 2*:
 ``` cpp
 using handler_t = void (*)(int);
@@ -335,11 +335,11 @@ using cell = P<cell*>;              // error: cell not found[basic.scope.pdecl]
 The *defining-type-specifier-seq* of the *defining-type-id* shall not
 define a class or enumeration if the *alias-declaration* is the
 *declaration* of a *template-declaration*.
 A *simple-template-id* is only a *typedef-name* if its *template-name*
-names an alias template or a template *template-parameter*.
 [*Note 1*: A *simple-template-id* that names a class template
 specialization is a *class-name* [[class.name]]. If a *typedef-name* is
 used to identify the subject of an *elaborated-type-specifier*
 [[dcl.type.elab]], a class definition [[class]], a constructor
@@ -405,14 +405,15 @@ The `friend` specifier is used to specify access to class members; see
 [[class.friend]].
 ### The `constexpr` and `consteval` specifiers <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
-variable or variable template or the declaration of a function or
-function template. The `consteval` specifier shall be applied only to
-the declaration of a function or function template. A function or static
-data member declared with the `constexpr` or `consteval` specifier is
 implicitly an inline function or variable [[dcl.inline]]. If any
 declaration of a function or function template has a `constexpr` or
 `consteval` specifier, then all its declarations shall contain the same
 specifier.
@@ -452,21 +453,18 @@ extern constexpr int memsz;     // error: not a definition
 — *end example*]
 A `constexpr` or `consteval` specifier used in the declaration of a
 function declares that function to be a *constexpr function*.
-[*Note 3*: A function or constructor declared with the `consteval`
-specifier is an immediate function [[expr.const]]. — *end note*]
 A destructor, an allocation function, or a deallocation function shall
 not be declared with the `consteval` specifier.
-A function is *constexpr-suitable* if:
-- it is not a coroutine [[dcl.fct.def.coroutine]], and
-- if the function is a constructor or destructor, its class does not
-  have any virtual base classes.
 Except for instantiated constexpr functions, non-templated constexpr
 functions shall be constexpr-suitable.
 [*Example 2*:
@@ -536,12 +534,11 @@ int bar(int x, int y)                   // error: redefinition of bar
 — *end example*]
 A `constexpr` specifier used in an object declaration declares the
 object as const. Such an object shall have literal type and shall be
-initialized. In any `constexpr` variable declaration, the
-full-expression of the initialization shall be a constant expression
 [[expr.const]]. A `constexpr` variable that is an object, as well as any
 temporary to which a `constexpr` reference is bound, shall have constant
 destruction.
 [*Example 4*:
@@ -550,28 +547,44 @@ destruction.
 struct pixel {
   int x, y;
 };
 constexpr pixel ur = { 1294, 1024 };    // OK
 constexpr pixel origin;                 // error: initializer missing
 ```
 — *end example*]
 ### The `constinit` specifier <a id="dcl.constinit">[[dcl.constinit]]</a>
 The `constinit` specifier shall be applied only to a declaration of a
-variable with static or thread storage duration. If the specifier is
-applied to any declaration of a variable, it shall be applied to the
-initializing declaration. No diagnostic is required if no `constinit`
-declaration is reachable at the point of the initializing declaration.
 If a variable declared with the `constinit` specifier has dynamic
 initialization [[basic.start.dynamic]], the program is ill-formed, even
 if the implementation would perform that initialization as a static
 initialization [[basic.start.static]].
-[*Note 1*: The `constinit` specifier ensures that the variable is
 initialized during static initialization. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -584,50 +597,49 @@ constinit const char * d = f(false);    // error
 — *end example*]
 ### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
 The `inline` specifier shall be applied only to the declaration of a
-variable or function.
 A function declaration [[dcl.fct]], [[class.mfct]], [[class.friend]]
-with an `inline` specifier declares an *inline function*. The inline
-specifier indicates to the implementation that inline substitution of
-the function body at the point of call is to be preferred to the usual
-function call mechanism. An implementation is not required to perform
-this inline substitution at the point of call; however, even if this
-inline substitution is omitted, the other rules for inline functions
-specified in this subclause shall still be respected.
-[*Note 1*: The `inline` keyword has no effect on the linkage of a
 function. In certain cases, an inline function cannot use names with
 internal linkage; see  [[basic.link]]. — *end note*]
-A variable declaration with an `inline` specifier declares an
-*inline variable*.
-The `inline` specifier shall not appear on a block scope declaration or
-on the declaration of a function parameter. If the `inline` specifier is
-used in a friend function declaration, that declaration shall be a
-definition or the function shall have previously been declared inline.
 If a definition of a function or variable is reachable at the point of
 its first declaration as inline, the program is ill-formed. If a
 function or variable with external or module linkage is declared inline
 in one definition domain, an inline declaration of it shall be reachable
 from the end of every definition domain in which it is declared; no
 diagnostic is required.
-[*Note 2*: A call to an inline function or a use of an inline variable
 can be encountered before its definition becomes reachable in a
 translation unit. — *end note*]
-[*Note 3*: An inline function or variable with external or module
-linkage can be defined in multiple translation units [[basic.def.odr]],
-but is one entity with one address. A type or `static` variable defined
-in the body of such a function is therefore a single
-entity. — *end note*]
 If an inline function or variable that is attached to a named module is
 declared in a definition domain, it shall be defined in that domain.
 [*Note 4*: A constexpr function [[dcl.constexpr]] is implicitly inline.
 In the global module, a function defined within a class definition is
@@ -727,11 +739,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*:
@@ -779,27 +791,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
@@ -821,24 +833,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
 ```
@@ -859,12 +883,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`''                                    |
@@ -906,10 +932,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
@@ -922,77 +966,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*,
@@ -1024,17 +1068,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.
@@ -1051,10 +1098,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)`
@@ -1120,64 +1176,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*,
@@ -1241,10 +1309,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.
@@ -1252,11 +1335,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; }
@@ -1269,11 +1352,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
@@ -1314,11 +1397,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
@@ -1364,32 +1447,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
@@ -1397,11 +1479,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;
 ```
@@ -1417,11 +1499,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
@@ -1496,5 +1578,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*]

 appertains to the type determined by the preceding *decl-specifier*s
 [[dcl.meaning]]. The *attribute-specifier-seq* affects the type only for
 the declaration it appears in, not other declarations involving the same
 type.
+At most one of each of the *decl-specifier*s `friend`, `typedef`, or
+`inline` shall appear in a *decl-specifier-seq*. At most one of the
+`constexpr`, `consteval`, and `constinit` keywords shall appear in a
+*decl-specifier-seq*.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
 is no previous *defining-type-specifier* other than a *cv-qualifier* in
 the *decl-specifier-seq*. The sequence shall be self-consistent as
 object is const
 [[basic.type.qualifier]], [[dcl.type.cv]]. — *end note*]
 ### Function specifiers <a id="dcl.fct.spec">[[dcl.fct.spec]]</a>
+A *function-specifier* can be used only in a function declaration. At
+most one *explicit-specifier* and at most one `virtual` keyword shall
+appear in a *decl-specifier-seq*.
 ``` bnf
 function-specifier:
     virtual
     explicit-specifier
 — *end example*]
 ### The `typedef` specifier <a id="dcl.typedef">[[dcl.typedef]]</a>
+Declarations containing the *decl-specifier* `typedef` declare *type
+aliases*. The `typedef` specifier shall not be combined in a
+*decl-specifier-seq* with any other kind of specifier except a
+*defining-type-specifier*, and it shall not be used in the
+*decl-specifier-seq* of a *parameter-declaration* [[dcl.fct]] nor in the
+*decl-specifier-seq* of a *function-definition* [[dcl.fct.def]]. If a
+`typedef` specifier appears in a declaration without a *declarator*, the
+program is ill-formed.
 ``` bnf
 typedef-name:
     identifier
     simple-template-id
 ```
+A name declared with the `typedef` specifier becomes a *typedef-name*.
+The underlying entity of the type alias is the type associated with the
+*identifier* [[dcl.decl]] or *simple-template-id* [[temp.pre]]. A
+*typedef-name* does not introduce a new type the way a class declaration
+[[class.name]] or enum declaration [[dcl.enum]] does.
 [*Example 1*:
 After
 are all correct declarations; the type of `distance` is `int` and that
 of `metricp` is “pointer to `int`”.
 — *end example*]
+A type alias can also be declared by an *alias-declaration*. The
 *identifier* following the `using` keyword is not looked up; it becomes
+the *typedef-name* of a type alias and the optional
+*attribute-specifier-seq* following the *identifier* appertains to that
+type alias. Such a type alias has the same semantics as if it were
+introduced by the `typedef` specifier.
 [*Example 2*:
 ``` cpp
 using handler_t = void (*)(int);
 The *defining-type-specifier-seq* of the *defining-type-id* shall not
 define a class or enumeration if the *alias-declaration* is the
 *declaration* of a *template-declaration*.
 A *simple-template-id* is only a *typedef-name* if its *template-name*
+names an alias template or a type template template parameter.
 [*Note 1*: A *simple-template-id* that names a class template
 specialization is a *class-name* [[class.name]]. If a *typedef-name* is
 used to identify the subject of an *elaborated-type-specifier*
 [[dcl.type.elab]], a class definition [[class]], a constructor
 [[class.friend]].
 ### The `constexpr` and `consteval` specifiers <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
+variable or variable template, a structured binding declaration, or the
+declaration of a function or function template. The `consteval`
+specifier shall be applied only to the declaration of a function or
+function template. A function or static data member declared with the
+`constexpr` or `consteval` specifier on its first declaration is
 implicitly an inline function or variable [[dcl.inline]]. If any
 declaration of a function or function template has a `constexpr` or
 `consteval` specifier, then all its declarations shall contain the same
 specifier.
 — *end example*]
 A `constexpr` or `consteval` specifier used in the declaration of a
 function declares that function to be a *constexpr function*.
+[*Note 3*: A function declared with the `consteval` specifier is an
+immediate function [[expr.const]]. — *end note*]
 A destructor, an allocation function, or a deallocation function shall
 not be declared with the `consteval` specifier.
+A function is *constexpr-suitable* if it is not a coroutine
+[[dcl.fct.def.coroutine]].
 Except for instantiated constexpr functions, non-templated constexpr
 functions shall be constexpr-suitable.
 [*Example 2*:
 — *end example*]
 A `constexpr` specifier used in an object declaration declares the
 object as const. Such an object shall have literal type and shall be
+initialized. A `constexpr` variable shall be constant-initializable
 [[expr.const]]. A `constexpr` variable that is an object, as well as any
 temporary to which a `constexpr` reference is bound, shall have constant
 destruction.
 [*Example 4*:
 struct pixel {
   int x, y;
 };
 constexpr pixel ur = { 1294, 1024 };    // OK
 constexpr pixel origin;                 // error: initializer missing
+namespace N {
+  void f() {
+    int x;
+    constexpr int& ar = x;              // OK
+    static constexpr int& sr = x;       // error: x is not constexpr-representable
+                                        // at the point indicated below
+  }
+  // immediate scope here is that of N
+}
 ```
 — *end example*]
 ### The `constinit` specifier <a id="dcl.constinit">[[dcl.constinit]]</a>
 The `constinit` specifier shall be applied only to a declaration of a
+variable with static or thread storage duration or to a structured
+binding declaration [[dcl.struct.bind]].
+[*Note 1*: A structured binding declaration introduces a uniquely named
+variable, to which the `constinit` specifier applies. — *end note*]
+If the specifier is applied to any declaration of a variable, it shall
+be applied to the initializing declaration. No diagnostic is required if
+no `constinit` declaration is reachable at the point of the initializing
+declaration.
 If a variable declared with the `constinit` specifier has dynamic
 initialization [[basic.start.dynamic]], the program is ill-formed, even
 if the implementation would perform that initialization as a static
 initialization [[basic.start.static]].
+[*Note 2*: The `constinit` specifier ensures that the variable is
 initialized during static initialization. — *end note*]
 [*Example 1*:
 ``` cpp
 — *end example*]
 ### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
 The `inline` specifier shall be applied only to the declaration of a
+function or variable. The `inline` specifier shall not appear on a block
+scope declaration or on the declaration of a function parameter. If the
+`inline` specifier is used in a friend function declaration, that
+declaration shall be a definition or the function shall have previously
+been declared inline.
 A function declaration [[dcl.fct]], [[class.mfct]], [[class.friend]]
+with an `inline` specifier declares an *inline function*. A variable
+declaration with an `inline` specifier declares an *inline variable*.
+[*Note 1*: An inline function or variable with external or module
+linkage can be defined in multiple translation units [[basic.def.odr]],
+but is one entity with one address. A type or `static` variable defined
+in the body of such a function is therefore a single
+entity. — *end note*]
+[*Note 2*: The `inline` keyword has no effect on the linkage of a
 function. In certain cases, an inline function cannot use names with
 internal linkage; see  [[basic.link]]. — *end note*]
+The inline specifier indicates to the implementation that inline
+substitution of the function body at the point of call is to be
+preferred to the usual function call mechanism. An implementation is not
+required to perform this inline substitution at the point of call;
+however, even if this inline substitution is omitted, the other rules
+for inline functions specified in this subclause shall still be
+respected.
 If a definition of a function or variable is reachable at the point of
 its first declaration as inline, the program is ill-formed. If a
 function or variable with external or module linkage is declared inline
 in one definition domain, an inline declaration of it shall be reachable
 from the end of every definition domain in which it is declared; no
 diagnostic is required.
+[*Note 3*: A call to an inline function or a use of an inline variable
 can be encountered before its definition becomes reachable in a
 translation unit. — *end note*]
 If an inline function or variable that is attached to a named module is
 declared in a definition domain, it shall be defined in that domain.
 [*Note 4*: A constexpr function [[dcl.constexpr]] is implicitly inline.
 In the global module, a function defined within a class definition is
 [*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