[temp.res] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpn0taz01d/{from.md → to.md} +260 -56

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

@@ -87,11 +87,11 @@ specialization [[temp.point]] but is not found by lookup for the
 specialization, the program is ill-formed, no diagnostic required.
 ``` bnf
 typename-specifier:
   typename nested-name-specifier identifier
-  typename nested-name-specifier 'templateₒₚₜ ' simple-template-id
 ```
 The component names of a *typename-specifier* are its *identifier* (if
 any) and those of its *nested-name-specifier* and *simple-template-id*
 (if any). A *typename-specifier* denotes the type or class template
@@ -122,48 +122,60 @@ void foo() {
 }
 ```
 — *end example*]
-A qualified or unqualified name is said to be in a *type-only context*
-if it is the terminal name of
-- a *typename-specifier*, *nested-name-specifier*,
-  *elaborated-type-specifier*, *class-or-decltype*, or
 - a *type-specifier* of a
   - *new-type-id*,
   - *defining-type-id*,
   - *conversion-type-id*,
   - *trailing-return-type*,
   - default argument of a *type-parameter*, or
   - *type-id* of a `static_cast`, `const_cast`, `reinterpret_cast`, or
     `dynamic_cast`, or
 - a *decl-specifier* of the *decl-specifier-seq* of a
-  - *simple-declaration* or a *function-definition* in namespace scope,
   - *member-declaration*,
-  - *parameter-declaration* in a *member-declaration*,[^10] unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *declarator* of a function or function
     template declaration whose *declarator-id* is qualified, unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *lambda-declarator* or
     *requirement-parameter-list*, unless that *parameter-declaration*
     appears in a default argument, or
-  - *parameter-declaration* of a (non-type) *template-parameter*.
 [*Example 5*:
 ``` cpp
 template<class T> T::R f();             // OK, return type of a function declaration at global scope
 template<class T> void f(T::R);         // ill-formed, no diagnostic required: attempt to declare
                                         // a void variable template
 template<class T> struct S {
   using Ptr = PtrTraits<T>::Ptr;        // OK, in a defining-type-id
   T::R f(T::P p) {                      // OK, class scope
     return static_cast<T::R>(p);        // OK, type-id of a static_cast
   }
   auto g() -> S<T*>::Ptr;               // OK, trailing-return-type
 };
 template<typename T> void f() {
   void (*pf)(T::X);                     // variable pf of type void* initialized with T::X
   void g(T::X);                         // error: T::X at block scope does not denote a type
                                         // (attempt to declare a void variable)
@@ -198,33 +210,45 @@ int main() {
 }
 ```
 — *end example*]
-The validity of a template may be checked prior to any instantiation.
 [*Note 3*: Knowing which names are type names allows the syntax of
 every template to be checked in this way. — *end note*]
-The program is ill-formed, no diagnostic required, if:
 - no valid specialization, ignoring *static_assert-declaration*s that
-  fail, can be generated for a template or a substatement of a constexpr
-  if statement [[stmt.if]] within a template and the template is not
   instantiated, or
 - any *constraint-expression* in the program, introduced or otherwise,
   has (in its normal form) an atomic constraint A where no satisfaction
   check of A could be well-formed and no satisfaction check of A is
   performed, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
-- a hypothetical instantiation of a template immediately following its
-  definition would be ill-formed due to a construct that does not depend
- on a template parameter, or
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
-  corresponding construct in any actual instantiation of the template.
 [*Note 4*:
 This can happen in situations including the following:
@@ -255,13 +279,10 @@ This can happen in situations including the following:
   it names an explicit specialization that was not declared when the
   template was defined.
 — *end note*]
-Otherwise, no diagnostic shall be issued for a template for which a
-valid specialization can be generated.
 [*Note 5*: If a template is instantiated, errors will be diagnosed
 according to the other rules in this document. Exactly when these errors
 are diagnosed is a quality of implementation issue. — *end note*]
 [*Example 7*:
@@ -298,12 +319,12 @@ considered definitions [[temp.decls]]. — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name [[class.pre]]. The injected-class-name can be used
 as a *template-name* or a *type-name*. When it is used with a
-*template-argument-list*, as a *template-argument* for a template
-*template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
 followed by the template argument list
 [[temp.decls.general]], [[temp.arg.general]] of the class template
@@ -387,26 +408,26 @@ template<class T> class X {
 };
 ```
 — *end example*]
-The name of a *template-parameter* shall not be bound to any following
-declaration whose locus is contained by the scope to which the
-template-parameter belongs.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
-  int T;                                // error: template-parameter hidden
   void f() {
-    char T;                             // error: template-parameter hidden
   }
   friend void T();                      // OK, no name bound
 };
-template<class X> class X;              // error: hidden by template-parameter
 ```
 — *end example*]
 Unqualified name lookup considers the template parameter scope of a
@@ -515,25 +536,25 @@ A name or *template-id* refers to the *current instantiation* if it is
   class template, the name of the class template followed by the
   template argument list of its *template-head* [[temp.arg]] enclosed in
   `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
-  or
 - in the definition of a class template partial specialization or a
   member of a class template partial specialization, the name of the
   class template followed by a template argument list equivalent to that
   of the partial specialization [[temp.spec.partial]] enclosed in `<>`
-  (or an equivalent template alias specialization).
 A template argument that is equivalent to a template parameter can be
 used in place of that template parameter in a reference to the current
-instantiation. For a template *type-parameter*, a template argument is
-equivalent to a template parameter if it denotes the same type. For a
-non-type template parameter, a template argument is equivalent to a
-template parameter if it is an *identifier* that names a variable that
-is equivalent to the template parameter. A variable is equivalent to a
-template parameter if
 - it has the same type as the template parameter (ignoring
   cv-qualification) and
 - its initializer consists of a single *identifier* that names the
   template parameter or, recursively, such a variable.
@@ -645,11 +666,11 @@ A qualified name [[basic.lookup.qual]] is dependent if
 - it is a *conversion-function-id* whose *conversion-type-id* is
   dependent, or
 - its lookup context is dependent and is not the current instantiation,
   or
 - its lookup context is the current instantiation and it is
-  `operator=`,[^11] or
 - its lookup context is the current instantiation and has at least one
   dependent base class, and qualified name lookup for the name finds
   nothing [[basic.lookup.qual]].
 [*Example 4*:
@@ -693,11 +714,44 @@ struct C : A, T {
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
 template int C<B>::g();         // OK, transformation to class member access syntax
-                                // does not occur in the template definition context; see~[class.mfct.non.static]
 ```
 — *end example*]
 A type is dependent if it is
@@ -711,16 +765,21 @@ A type is dependent if it is
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose parameters include one or more function
   parameter packs,
 - a function type whose exception specification is value-dependent,
 - denoted by a *simple-template-id* in which either the template name is
-  a template parameter or any of the template arguments is a dependent
- type or an expression that is type-dependent or value-dependent or is
- a pack expansion,[^12] or
 - denoted by `decltype(`*expression*`)`, where *expression* is
-  type-dependent [[temp.dep.expr]].
 [*Note 3*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
@@ -736,29 +795,57 @@ dependent [[temp.dep.type]].
 An *id-expression* is type-dependent if it is a *template-id* that is
 not a concept-id and is dependent; or if its terminal name is
 - associated by name lookup with one or more declarations declared with
   a dependent type,
-- associated by name lookup with a non-type *template-parameter*
- declared with a type that contains a placeholder type
-  [[dcl.spec.auto]],
 - associated by name lookup with a variable declared with a type that
   contains a placeholder type [[dcl.spec.auto]] where the initializer is
   type-dependent,
 - associated by name lookup with one or more declarations of member
   functions of a class that is the current instantiation declared with a
   return type that contains a placeholder type,
 - associated by name lookup with a structured binding declaration
   [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
   type-dependent,
 - associated by name lookup with an entity captured by copy
   [[expr.prim.lambda.capture]] in a *lambda-expression* that has an
   explicit object parameter whose type is dependent [[dcl.fct]],
 - the *identifier* `__func__` [[dcl.fct.def.general]], where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
-- a *conversion-function-id* that specifies a dependent type, or
 - dependent
 or if it names a dependent member of the current instantiation that is a
 static data member of type “array of unknown bound of `T`” for some `T`
 [[temp.static]]. Expressions of the following forms are type-dependent
@@ -793,10 +880,12 @@ typeid '(' expression ')'
 typeid '(' type-id ')'
 '::'ₒₚₜ delete cast-expression
 '::'ₒₚₜ delete '[' ']' cast-expression
 throw assignment-expressionₒₚₜ
 noexcept '(' expression ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
@@ -814,21 +903,30 @@ always dependent. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, an expression used in a context where a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
-An *id-expression* is value-dependent if:
-- it is a concept-id and any of its arguments are dependent,
 - it is type-dependent,
-- it is the name of a non-type template parameter,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it names a potentially-constant variable [[expr.const]] that is
@@ -842,58 +940,158 @@ dependent:
 sizeof unary-expression
 sizeof '(' type-id ')'
 typeid '(' expression ')'
 typeid '(' type-id ')'
 alignof '(' type-id ')'
-noexcept '(' expression ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
-*type-id* or *simple-type-specifier* is dependent or the *expression* or
-*cast-expression* is value-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
 reinterpret_cast '<' type-id '>' '(' expression ')'
 '(' type-id ')' cast-expression
 ```
 Expressions of the following form are value-dependent:
 ``` bnf
 sizeof '...' '(' identifier ')'
 fold-expression
 ```
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
 expression [[expr.const]] succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
-A non-type *template-argument* is dependent if its type is dependent or
 the constant expression it specifies is value-dependent.
-Furthermore, a non-type *template-argument* is dependent if the
-corresponding non-type *template-parameter* is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
-A template *template-parameter* is dependent if it names a
-*template-parameter* or its terminal name is dependent.
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
@@ -963,10 +1161,16 @@ instantiation within a translation unit. A specialization for any
 template may have points of instantiation in multiple translation units.
 If two different points of instantiation give a template specialization
 different meanings according to the one-definition rule
 [[basic.def.odr]], the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 If a dependent call [[temp.dep]] would be ill-formed or would find a
 better match had the lookup for its dependent name considered all the
 function declarations with external linkage introduced in the associated

 specialization, the program is ill-formed, no diagnostic required.
 ``` bnf
 typename-specifier:
   typename nested-name-specifier identifier
+  typename nested-name-specifier templateₒₚₜ simple-template-id
 ```
 The component names of a *typename-specifier* are its *identifier* (if
 any) and those of its *nested-name-specifier* and *simple-template-id*
 (if any). A *typename-specifier* denotes the type or class template
 }
 ```
 — *end example*]
+A *type-only context* is defined as follows: A qualified or unqualified
+name is said to be in a type-only context if it is the terminal name of
+- a *typename-specifier*, *type-requirement*, *nested-name-specifier*,
+  *elaborated-type-specifier*, *class-or-decltype*,
+  *using-enum-declarator*, or
+- a *simple-type-specifier* of a *friend-type-specifier*, or
 - a *type-specifier* of a
   - *new-type-id*,
   - *defining-type-id*,
   - *conversion-type-id*,
   - *trailing-return-type*,
   - default argument of a *type-parameter*, or
   - *type-id* of a `static_cast`, `const_cast`, `reinterpret_cast`, or
     `dynamic_cast`, or
 - a *decl-specifier* of the *decl-specifier-seq* of a
+  - *simple-declaration* or *function-definition* in namespace scope,
   - *member-declaration*,
+  - *parameter-declaration* in a *member-declaration*,[^9] unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *declarator* of a function or function
     template declaration whose *declarator-id* is qualified, unless that
     *parameter-declaration* appears in a default argument,
   - *parameter-declaration* in a *lambda-declarator* or
     *requirement-parameter-list*, unless that *parameter-declaration*
     appears in a default argument, or
+  - *parameter-declaration* of a *template-parameter* (which necessarily
+    declares a constant template parameter).
+A *splice-specifier* or *splice-specialization-specifier*
+[[basic.splice]] is said to be in a type-only context if a hypothetical
+qualified name appearing in the same position would be in a type-only
+context.
 [*Example 5*:
 ``` cpp
 template<class T> T::R f();             // OK, return type of a function declaration at global scope
 template<class T> void f(T::R);         // ill-formed, no diagnostic required: attempt to declare
                                         // a void variable template
+enum class Enum { A, B, C };
 template<class T> struct S {
   using Ptr = PtrTraits<T>::Ptr;        // OK, in a defining-type-id
+  using Alias = [:^^int:];              // OK, in a defining-type-id
   T::R f(T::P p) {                      // OK, class scope
     return static_cast<T::R>(p);        // OK, type-id of a static_cast
   }
   auto g() -> S<T*>::Ptr;               // OK, trailing-return-type
+  auto h() -> [:^^S:]<T*>;              // OK, trailing-return-type
+  using enum [:^^Enum:];                // OK, using-enum-declarator
 };
 template<typename T> void f() {
   void (*pf)(T::X);                     // variable pf of type void* initialized with T::X
   void g(T::X);                         // error: T::X at block scope does not denote a type
                                         // (attempt to declare a void variable)
 }
 ```
 — *end example*]
+The validity of a templated entity may be checked prior to any
+instantiation.
 [*Note 3*: Knowing which names are type names allows the syntax of
 every template to be checked in this way. — *end note*]
+The program is ill-formed, no diagnostic required, if
 - no valid specialization, ignoring *static_assert-declaration*s that
+  fail [[dcl.pre]], can be generated for a templated entity or a
+ substatement of a constexpr if statement [[stmt.if]] within a
+  templated entity and the innermost enclosing template is not
   instantiated, or
+- no valid specialization, ignoring *static_assert-declaration*s that
+  fail, can be generated for the *compound-statement* of an
+  *expansion-statement* and there is no instantiation of it, or
+- no valid specialization, ignoring *static_assert-declaration*s that
+  fail, can be generated for a default *template-argument* and the
+  default *template-argument* is not used in any instantiation, or
+- no specialization of an alias template [[temp.alias]] is valid and no
+  specialization of the alias template is named in the program, or
 - any *constraint-expression* in the program, introduced or otherwise,
   has (in its normal form) an atomic constraint A where no satisfaction
   check of A could be well-formed and no satisfaction check of A is
   performed, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
+- a hypothetical instantiation of a templated entity immediately
+ following its definition would be ill-formed due to a construct (other
+ than a *static_assert-declaration* that fails) that does not depend on
+  a template parameter, or
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
+  corresponding construct in any actual instantiation of the templated
+  entity.
 [*Note 4*:
 This can happen in situations including the following:
   it names an explicit specialization that was not declared when the
   template was defined.
 — *end note*]
 [*Note 5*: If a template is instantiated, errors will be diagnosed
 according to the other rules in this document. Exactly when these errors
 are diagnosed is a quality of implementation issue. — *end note*]
 [*Example 7*:
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
 injected-class-name [[class.pre]]. The injected-class-name can be used
 as a *template-name* or a *type-name*. When it is used with a
+*template-argument-list*, as a *template-argument* for a type template
+template parameter, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
 is a *template-name* that refers to the class template itself.
 Otherwise, it is a *type-name* equivalent to the *template-name*
 followed by the template argument list
 [[temp.decls.general]], [[temp.arg.general]] of the class template
 };
 ```
 — *end example*]
+The name of a template parameter shall not be bound to any following
+declaration whose locus is contained by the scope to which the template
+parameter belongs.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
+  int T;                                // error: template parameter hidden
   void f() {
+    char T;                             // error: template parameter hidden
   }
   friend void T();                      // OK, no name bound
 };
+template<class X> class X;              // error: hidden by template parameter
 ```
 — *end example*]
 Unqualified name lookup considers the template parameter scope of a
   class template, the name of the class template followed by the
   template argument list of its *template-head* [[temp.arg]] enclosed in
   `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
 - in the definition of a class template partial specialization or a
   member of a class template partial specialization, the name of the
   class template followed by a template argument list equivalent to that
   of the partial specialization [[temp.spec.partial]] enclosed in `<>`
+  (or an equivalent template alias specialization), or
+- in the definition of a templated function, the name of a local class
+  [[class.local]].
 A template argument that is equivalent to a template parameter can be
 used in place of that template parameter in a reference to the current
+instantiation. A template argument is equivalent to a type template
+parameter if it denotes the same type. A template argument is equivalent
+to a constant template parameter if it is an *identifier* that names a
+variable that is equivalent to the template parameter. A variable is
+equivalent to a template parameter if
 - it has the same type as the template parameter (ignoring
   cv-qualification) and
 - its initializer consists of a single *identifier* that names the
   template parameter or, recursively, such a variable.
 - it is a *conversion-function-id* whose *conversion-type-id* is
   dependent, or
 - its lookup context is dependent and is not the current instantiation,
   or
 - its lookup context is the current instantiation and it is
+  `operator=`,[^10] or
 - its lookup context is the current instantiation and has at least one
   dependent base class, and qualified name lookup for the name finds
   nothing [[basic.lookup.qual]].
 [*Example 4*:
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
 template int C<B>::g();         // OK, transformation to class member access syntax
+                                // does not occur in the template definition context; see~[expr.prim.id.general]
+```
+— *end example*]
+An initializer is dependent if any constituent expression
+[[intro.execution]] of the initializer is type-dependent. A placeholder
+type [[dcl.spec.auto.general]] is dependent if it designates a type
+deduced from a dependent initializer.
+A placeholder for a deduced class type [[dcl.type.class.deduct]] is
+dependent if
+- it has a dependent initializer, or
+- it refers to an alias template that is a member of the current
+  instantiation and whose *defining-type-id* is dependent after class
+  template argument deduction [[over.match.class.deduct]] and
+  substitution [[temp.alias]].
+[*Example 6*:
+``` cpp
+template<class T, class V>
+struct S { S(T); };
+template<class U>
+struct A {
+  template<class T> using X = S<T, U>;
+  template<class T> using Y = S<T, int>;
+  void f() {
+    new X(1);                   // dependent
+    new Y(1);                   // not dependent
+  }
+};
 ```
 — *end example*]
 A type is dependent if it is
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose parameters include one or more function
   parameter packs,
 - a function type whose exception specification is value-dependent,
+- denoted by a dependent placeholder type,
+- denoted by a dependent placeholder for a deduced class type,
 - denoted by a *simple-template-id* in which either the template name is
+  a template parameter or any of the template arguments is dependent
+ [[temp.dep.temp]],[^11]
+- a *pack-index-specifier*,
 - denoted by `decltype(`*expression*`)`, where *expression* is
+  type-dependent [[temp.dep.expr]], or
+- denoted by a *splice-type-specifier* in which either the
+  *splice-specifier* or *splice-specialization-specifier* is dependent
+  [[temp.dep.splice]].
 [*Note 3*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
 An *id-expression* is type-dependent if it is a *template-id* that is
 not a concept-id and is dependent; or if its terminal name is
 - associated by name lookup with one or more declarations declared with
   a dependent type,
+- associated by name lookup with a constant template parameter declared
+  with a type that contains a placeholder type [[dcl.spec.auto]],
 - associated by name lookup with a variable declared with a type that
   contains a placeholder type [[dcl.spec.auto]] where the initializer is
   type-dependent,
 - associated by name lookup with one or more declarations of member
   functions of a class that is the current instantiation declared with a
   return type that contains a placeholder type,
 - associated by name lookup with a structured binding declaration
   [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
   type-dependent,
+- associated by name lookup with a pack,
+  \[*Example 1*:
+  ``` cpp
+  struct C { };
+  void g(...);            // #1
+  template <typename T>
+  void f() {
+    C arr[1];
+    auto [...e] = arr;
+    g(e...);              // calls #2
+  }
+  void g(C);              // #2
+  int main() {
+    f<int>();
+  }
+  ```
+  — *end example*]
 - associated by name lookup with an entity captured by copy
   [[expr.prim.lambda.capture]] in a *lambda-expression* that has an
   explicit object parameter whose type is dependent [[dcl.fct]],
 - the *identifier* `__func__` [[dcl.fct.def.general]], where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
+- associated by name lookup with a result binding [[dcl.contract.res]]
+  of a function whose return type is dependent,
+- a *conversion-function-id* that specifies a dependent type,
+- a name N introduced by the *for-range-declaration* of an
+  *expansion-statement* S if the type specified for N contains a
+  placeholder type and either
+  - the *expansion-initializer* of S is type-dependent or
+  - S is not an iterating expansion statement, or
 - dependent
 or if it names a dependent member of the current instantiation that is a
 static data member of type “array of unknown bound of `T`” for some `T`
 [[temp.static]]. Expressions of the following forms are type-dependent
 typeid '(' type-id ')'
 '::'ₒₚₜ delete cast-expression
 '::'ₒₚₜ delete '[' ']' cast-expression
 throw assignment-expressionₒₚₜ
 noexcept '(' expression ')'
+requires-expression
+reflect-expression
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
+A *pack-index-expression* is type-dependent if its *id-expression* is
+type-dependent.
+A *splice-expression* is type-dependent if its *splice-specifier* or
+*splice-specialization-specifier* is dependent [[temp.dep.splice]].
 #### Value-dependent expressions <a id="temp.dep.constexpr">[[temp.dep.constexpr]]</a>
 Except as described below, an expression used in a context where a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
+An *id-expression* is value-dependent if
+- it is a concept-id and its *concept-name* is dependent or any of its
+  arguments are dependent [[temp.dep.temp]],
 - it is type-dependent,
+- it is the name of a constant template parameter,
+- it is a name introduced by the *for-range-declaration* of an
+  *expansion-statement* [[stmt.expand]],
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
 - it names a potentially-constant variable [[expr.const]] that is
 sizeof unary-expression
 sizeof '(' type-id ')'
 typeid '(' expression ')'
 typeid '(' type-id ')'
 alignof '(' type-id ')'
 ```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
+*type-id*, *simple-type-specifier*, or *typename-specifier* is dependent
+or the *expression* or *cast-expression* is value-dependent or any
+*expression* in the *expression-list* is value-dependent or any
+*assignment-expression* in the *braced-init-list* is value-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
+typename-specifier '(' expression-listₒₚₜ ')'
+simple-type-specifier braced-init-list
+typename-specifier braced-init-list
 static_cast '<' type-id '>' '(' expression ')'
 const_cast '<' type-id '>' '(' expression ')'
 reinterpret_cast '<' type-id '>' '(' expression ')'
+dynamic_cast '<' type-id '>' '(' expression ')'
 '(' type-id ')' cast-expression
 ```
 Expressions of the following form are value-dependent:
 ``` bnf
 sizeof '...' '(' identifier ')'
 fold-expression
 ```
+unless the *identifier* is a structured binding pack whose initializer
+is not dependent.
+A *noexcept-expression* [[expr.unary.noexcept]] is value-dependent if
+its *expression* involves a template parameter.
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
 expression [[expr.const]] succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
+A *reflect-expression* is value-dependent if
+- it is of the form `^^ reflection-name` and the *reflection-name*
+  - is a dependent qualified name,
+  - is a dependent *namespace-name*,
+  - is the name of a template parameter, or
+  - names a dependent member of the current instantiation
+    [[temp.dep.type]],
+- it is of the form `^^ type-id` and the *type-id* denotes a dependent
+  type, or
+- it is of the form `^^ id-expression` and the *id-expression* is
+  value-dependent.
+A *splice-expression* is value-dependent if its *splice-specifier* or
+*splice-specialization-specifier* is dependent [[temp.dep.splice]].
+#### Dependent splice specifiers <a id="temp.dep.splice">[[temp.dep.splice]]</a>
+A *splice-specifier* is dependent if its converted *constant-expression*
+is value-dependent. A *splice-specialization-specifier* is dependent if
+its *splice-specifier* is dependent or if any of its template arguments
+are dependent. A *splice-scope-specifier* is dependent if its
+*splice-specifier* or *splice-specialization-specifier* is dependent.
+[*Example 1*:
+``` cpp
+template<auto T, auto NS>
+void fn() {
+  using a = [:T:]<1>;                           // [:T:]<1> is dependent because [:T:] is dependent
+  static_assert([:NS:]::template TCls<1>::v == a::v);   // [:NS:] is dependent
+}
+namespace N {
+  template <auto V> struct TCls { static constexpr int v = V; };
+}
+int main() {
+  fn<^^N::TCls, ^^N>();
+}
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+template<template<class> class X>
+struct S {
+  [:^^X:]<int, float> m;
+};
+template<class> struct V1 {};
+template<class, class = int> struct V2 {};
+S<V1> s1;                       // error: V1<int, float> has too many template arguments
+S<V2> s2;                       // OK
+```
+— *end example*]
+#### Dependent namespaces <a id="temp.dep.namespace">[[temp.dep.namespace]]</a>
+A namespace alias is dependent if it is introduced by a
+*namespace-alias-definition* whose *qualified-namespace-specifier* (if
+any) is a dependent qualified name or whose *splice-specifier* (if any)
+is dependent. A *namespace-name* is dependent if it names a dependent
+namespace alias.
+[*Example 1*:
+``` cpp
+template<std::meta::info R>
+int fn() {
+  namespace Alias = [:R:];          // [:R:] is dependent
+  return typename Alias::T{};       // Alias is dependent
+}
+namespace NS {
+  using T = int;
+}
+int a = fn<^^NS>();
+```
+— *end example*]
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 A type *template-argument* is dependent if the type it specifies is
 dependent.
+A constant *template-argument* is dependent if its type is dependent or
 the constant expression it specifies is value-dependent.
+Furthermore, a constant *template-argument* is dependent if the
+corresponding constant template parameter is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
+A template argument is also dependent if it is a pack expansion.
+A template template parameter is dependent if it names a template
+parameter or its terminal name is dependent.
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
 template may have points of instantiation in multiple translation units.
 If two different points of instantiation give a template specialization
 different meanings according to the one-definition rule
 [[basic.def.odr]], the program is ill-formed, no diagnostic required.
+For the *compound-statement* of an *expansion-statement*
+[[stmt.expand]], the point of instantiation is the point of
+instantiation of its enclosing templated entity, if any. Otherwise, it
+immediately follows the namespace-scope declaration or definition that
+contains the expansion statement.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 If a dependent call [[temp.dep]] would be ill-formed or would find a
 better match had the lookup for its dependent name considered all the
 function declarations with external linkage introduced in the associated

Diff to HTML by rtfpessoa