[temp.dep] - C++17 → C++20

Files changed (1) hide show

tmp/tmpb7upcrej/{from.md → to.md} +137 -66

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

@@ -3,31 +3,38 @@
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
-names. An expressions may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
-when evaluated as a constant expression ([[expr.const]]) may depend on
-a template parameter) as described in this subclause. In an expression
-of the form:
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
-- any of the expressions in the *expression-list* is a pack expansion (
-  [[temp.variadic]]),
 - any of the expressions or *braced-init-list*s in the *expression-list*
-  is type-dependent ([[temp.dep.expr]]), or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
-operator also denotes a dependent name. Such names are unbound and are
-looked up at the point of the template instantiation ([[temp.point]])
-in both the context of the template definition and the context of the
-point of instantiation.
 [*Example 1*:
 ``` cpp
 template<class T> struct X : B<T> {
@@ -37,17 +44,17 @@ template<class T> struct X : B<T> {
     pb->j++;
   }
 };
 ```
-the base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
 In the definition of a class or class template, the scope of a dependent
-base class ([[temp.dep.type]]) is not examined during unqualified name
 lookup either at the point of definition of the class template or member
 or during an instantiation of the class template or member.
 [*Example 2*:
@@ -97,41 +104,50 @@ not affect the binding of names in `Y<A>`.
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
-  of a class template, the injected-class-name (Clause  [[class]]) of
- the class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
   template argument list of the primary template (as described below)
   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 partial specialization or a member of a partial
   specialization, the name of the class template followed by the
   template argument list of the partial specialization enclosed in `<>`
-  (or an equivalent template alias specialization). If the *n*th
- template parameter is a parameter pack, the *n*th template argument is
- a pack expansion ([[temp.variadic]]) whose pattern is the name of the
-  parameter pack.
 The template argument list of a primary template is a template argument
-list in which the *n*th template argument has the value of the *n*th
-template parameter of the class template. If the *n*th template
-parameter is a template parameter pack ([[temp.variadic]]), the *n*th
-template argument is a pack expansion ([[temp.variadic]]) whose pattern
-is the name of the template parameter pack.
-A template argument that is equivalent to a template parameter (i.e.,
-has the same constant value or the same type as the template parameter)
-can be used in place of that template parameter in a reference to the
-current instantiation. In the case of a non-type template argument, the
-argument must have been given the value of the template parameter and
-not an expression in which the template parameter appears as a
-subexpression.
 [*Example 1*:
 ``` cpp
 template <class T> class A {
@@ -156,22 +172,26 @@ template <class T1, class T2, int I> struct B {
   B<T2, T1, I>* b2;             // not the current instantiation
   typedef T1 my_T1;
   static const int my_I = I;
   static const int my_I2 = I+0;
   static const int my_I3 = my_I;
   B<my_T1, T2, my_I>* b3;       // refers to the current instantiation
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
 };
 ```
 — *end example*]
 A *dependent base class* is a base class that is a dependent type and is
 not the current instantiation.
-[*Note 1*:
 A base class can be the current instantiation in the case of a nested
 class naming an enclosing class as a base.
 [*Example 2*:
@@ -196,26 +216,26 @@ template<class T> struct A<T>::B::C : A<T> {
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 2*: This can only occur when looking up a
   name in a scope enclosed by the definition of a class
   template. — *end note*]
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 3*: If no such member is found, and the
   current instantiation has any dependent base classes, then the
   *qualified-id* is a member of an unknown specialization; see
   below. — *end note*]
 - An *id-expression* denoting the member in a class member access
-  expression ([[expr.ref]]) for which the type of the object expression
- is the current instantiation, and the *id-expression*, when looked
- up ([[basic.lookup.classref]]), refers to at least one member of a
- class that is the current instantiation or a non-dependent base class
-  thereof. \[*Note 4*: If no such member is found, and the current
   instantiation has any dependent base classes, then the *id-expression*
   is a member of an unknown specialization; see below. — *end note*]
 [*Example 3*:
@@ -247,18 +267,18 @@ A name is a *member of an unknown specialization* if it is
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
   find any member of a class that is the current instantiation or a
   non-dependent base class thereof.
 - An *id-expression* denoting the member in a class member access
-  expression ([[expr.ref]]) in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
     name lookup of the *id-expression* does not find a member of a class
     that is the current instantiation or a non-dependent base class
     thereof; or
-  - the type of the object expression is dependent and is not the
- current instantiation.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
 member of an unknown specialization, the program is ill-formed even if
 the template containing the *qualified-id* is not instantiated; no
@@ -325,20 +345,20 @@ A type is dependent if it is
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose exception specification is value-dependent,
-- 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 \[*Note 5*: This includes an injected-class-name (Clause
-  [[class]]) of a class template used without a
   *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
-  type-dependent ([[temp.dep.expr]]).
-[*Note 6*: 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*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
@@ -347,49 +367,77 @@ Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
 `this`
 is type-dependent if the class type of the enclosing member function is
-dependent ([[temp.dep.type]]).
-An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - an *identifier* associated by name lookup with a non-type
   *template-parameter* declared with a type that contains a placeholder
-  type ([[dcl.spec.auto]]),
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
   with a return type that contains a placeholder type,
 - an *identifier* associated by name lookup with a structured binding
-  declaration ([[dcl.struct.bind]]) whose *brace-or-equal-initializer*
- is type-dependent,
-- 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 *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
 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 only if the type specified by the *type-id*,
-*simple-type-specifier* or *new-type-id* is dependent, even if any
-subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
-A class member access expression ([[expr.ref]]) is type-dependent if
-the expression refers to a member of the current instantiation and the
-type of the referenced member is dependent, or the class member access
 expression refers to a member of an unknown specialization.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to a
@@ -409,37 +457,60 @@ 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 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 is a constant with literal type and is initialized with an
-  expression that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
 [*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:
 Expressions of the following form are value-dependent:
 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>

 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
+names. An expression may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
+when evaluated as a constant expression [[expr.const]] may depend on a
+template parameter) as described in this subclause.
+In an expression of the form:
+``` bnf
+postfix-expression '(' expression-listₒₚₜ ')'
+```
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
+- any of the expressions in the *expression-list* is a pack expansion
+  [[temp.variadic]],
 - any of the expressions or *braced-init-list*s in the *expression-list*
+  is type-dependent [[temp.dep.expr]], or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
+operator also denotes a dependent name.
+[*Note 1*: Such names are unbound and are looked up at the point of the
+template instantiation [[temp.point]] in both the context of the
+template definition and the context of the point of instantiation
+[[temp.dep.candidate]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<class T> struct X : B<T> {
     pb->j++;
   }
 };
 ```
+The base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
 In the definition of a class or class template, the scope of a dependent
+base class [[temp.dep.type]] is not examined during unqualified name
 lookup either at the point of definition of the class template or member
 or during an instantiation of the class template or member.
 [*Example 2*:
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
+  of a class template, the injected-class-name [[class.pre]] of the
+  class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
   template argument list of the primary template (as described below)
   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 partial specialization or a member of a partial
   specialization, the name of the class template followed by the
   template argument list of the partial specialization enclosed in `<>`
+  (or an equivalent template alias specialization). If the nᵗʰ template
+  parameter is a template parameter pack, the nᵗʰ template argument is a
+  pack expansion [[temp.variadic]] whose pattern is the name of the
+ template parameter pack.
 The template argument list of a primary template is a template argument
+list in which the nᵗʰ template argument has the value of the nᵗʰ
+template parameter of the class template. If the nᵗʰ template parameter
+is a template parameter pack [[temp.variadic]], the nᵗʰ template
+argument is a pack expansion [[temp.variadic]] whose pattern is the name
+of the template parameter pack.
+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.
+[*Note 1*: Using a parenthesized variable name breaks the
+equivalence. — *end note*]
 [*Example 1*:
 ``` cpp
 template <class T> class A {
   B<T2, T1, I>* b2;             // not the current instantiation
   typedef T1 my_T1;
   static const int my_I = I;
   static const int my_I2 = I+0;
   static const int my_I3 = my_I;
+  static const long my_I4 = I;
+  static const int my_I5 = (I);
   B<my_T1, T2, my_I>* b3;       // refers to the current instantiation
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
+  B<my_T1, T2, my_I4>* b6;      // not the current instantiation
+  B<my_T1, T2, my_I5>* b7;      // not the current instantiation
 };
 ```
 — *end example*]
 A *dependent base class* is a base class that is a dependent type and is
 not the current instantiation.
+[*Note 2*:
 A base class can be the current instantiation in the case of a nested
 class naming an enclosing class as a base.
 [*Example 2*:
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 3*: This can only occur when looking up a
   name in a scope enclosed by the definition of a class
   template. — *end note*]
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 4*: If no such member is found, and the
   current instantiation has any dependent base classes, then the
   *qualified-id* is a member of an unknown specialization; see
   below. — *end note*]
 - An *id-expression* denoting the member in a class member access
+  expression [[expr.ref]] for which the type of the object expression is
+  the current instantiation, and the *id-expression*, when looked up
+  [[basic.lookup.classref]], refers to at least one member of a class
+  that is the current instantiation or a non-dependent base class
+  thereof. \[*Note 5*: If no such member is found, and the current
   instantiation has any dependent base classes, then the *id-expression*
   is a member of an unknown specialization; see below. — *end note*]
 [*Example 3*:
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
   find any member of a class that is the current instantiation or a
   non-dependent base class thereof.
 - An *id-expression* denoting the member in a class member access
+  expression [[expr.ref]] in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
     name lookup of the *id-expression* does not find a member of a class
     that is the current instantiation or a non-dependent base class
     thereof; or
+  - the type of the object expression is not the current instantiation
+ and the object expression is type-dependent.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
 member of an unknown specialization, the program is ill-formed even if
 the template containing the *qualified-id* is not instantiated; no
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - 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 \[*Note 6*: This includes an injected-class-name
+  [[class.pre]] of a class template used without a
   *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
+  type-dependent [[temp.dep.expr]].
+[*Note 7*: 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*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 subexpression is type-dependent.
 `this`
 is type-dependent if the class type of the enclosing member function is
+dependent [[temp.dep.type]].
+An *id-expression* is type-dependent if it is not a concept-id and it
+contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - an *identifier* associated by name lookup with a non-type
   *template-parameter* declared with a type that contains a placeholder
+  type [[dcl.spec.auto]],
+- an *identifier* 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,
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
   with a return type that contains a placeholder type,
 - an *identifier* associated by name lookup with a structured binding
+  declaration [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
+  type-dependent,
+- 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 *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
 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
+only if the type specified by the *type-id*, *simple-type-specifier* or
+*new-type-id* is dependent, even if any subexpression is type-dependent:
+``` bnf
+simple-type-specifier '(' expression-listₒₚₜ ')'
+'::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
+'::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
+dynamic_cast '<' type-id '>' '(' expression ')'
+static_cast '<' type-id '>' '(' expression ')'
+const_cast '<' type-id '>' '(' expression ')'
+reinterpret_cast '<' type-id '>' '(' expression ')'
+'(' type-id ')' cast-expression
+```
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
+``` bnf
+literal
+sizeof unary-expression
+sizeof '(' type-id ')'
+sizeof '...' '(' identifier ')'
+alignof '(' type-id ')'
+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*]
+A class member access expression [[expr.ref]] is type-dependent if the
+expression refers to a member of the current instantiation and the type
+of the referenced member is dependent, or the class member access
 expression refers to a member of an unknown specialization.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to 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
+ initialized with an expression that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
+``` bnf
+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>

Diff to HTML by rtfpessoa