[temp.names] - C++20 → C++23

Files changed (1) hide show

tmp/tmpjcz5ufbi/{from.md → to.md} +61 -71

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

@@ -31,41 +31,60 @@ template-argument:
   constant-expression
   type-id
   id-expression
 ```
-[*Note 1*: The name lookup rules [[basic.lookup]] are used to associate
-the use of a name with a template declaration; that is, to identify a
-name as a *template-name*. — *end note*]
-For a *template-name* to be explicitly qualified by the template
-arguments, the name must be considered to refer to a template.
-[*Note 2*: Whether a name actually refers to a template cannot be known
-in some cases until after argument dependent lookup is done
-[[basic.lookup.argdep]]. — *end note*]
-A name is considered to refer to a template if name lookup finds a
-*template-name* or an overload set that contains a function template. A
-name is also considered to refer to a template if it is an
-*unqualified-id* followed by a `<` and name lookup either finds one or
-more functions or finds nothing.
-When a name is considered to be a *template-name*, and it is followed by
-a `<`, the `<` is always taken as the delimiter of a
-*template-argument-list* and never as the less-than operator. When
-parsing a *template-argument-list*, the first non-nested `>`[^2] is
-taken as the ending delimiter rather than a greater-than operator.
-Similarly, the first non-nested `>{>}` is treated as two consecutive but
 distinct `>` tokens, the first of which is taken as the end of the
 *template-argument-list* and completes the *template-id*.
-[*Note 3*: The second `>` token produced by this replacement rule may
-terminate an enclosing *template-id* construct or it may be part of a
 different construct (e.g., a cast). — *end note*]
-[*Example 1*:
 ``` cpp
 template<int i> class X { ... };
 X< 1>2 > x1;                            // syntax error
@@ -77,53 +96,25 @@ Y<X<6>>1>> x4;                          // syntax error
 Y<X<(6>>1)>> x5;                        // OK
 ```
 — *end example*]
-The keyword `template` is said to appear at the top level in a
-*qualified-id* if it appears outside of a *template-argument-list* or
-*decltype-specifier*. In a *qualified-id* of a *declarator-id* or in a
-*qualified-id* formed by a *class-head-name* [[class.pre]] or
-*enum-head-name* [[dcl.enum]], the keyword `template` shall not appear
-at the top level. In a *qualified-id* used as the name in a
-*typename-specifier* [[temp.res]], *elaborated-type-specifier*
-[[dcl.type.elab]], *using-declaration* [[namespace.udecl]], or
-*class-or-decltype* [[class.derived]], an optional keyword `template`
-appearing at the top level is ignored. In these contexts, a `<` token is
-always assumed to introduce a *template-argument-list*. In all other
-contexts, when naming a template specialization of a member of an
-unknown specialization [[temp.dep.type]], the member template name shall
-be prefixed by the keyword `template`.
-[*Example 2*:
-``` cpp
-struct X {
-  template<std::size_t> X* alloc();
-  template<std::size_t> static X* adjust();
-};
-template<class T> void f(T* p) {
-  T* p1 = p->alloc<200>();              // error: < means less than
-  T* p2 = p->template alloc<200>();     // OK: < starts template argument list
-  T::adjust<100>();                     // error: < means less than
-  T::template adjust<100>();            // OK: < starts template argument list
-}
-```
-— *end example*]
-A name prefixed by the keyword `template` shall be a *template-id* or
-the name shall refer to a class template or an alias template.
-[*Note 4*: The keyword `template` may not be applied to non-template
 members of class templates. — *end note*]
-[*Note 5*: As is the case with the `typename` prefix, the `template`
-prefix is allowed in cases where it is not strictly necessary; i.e.,
-when the *nested-name-specifier* or the expression on the left of the
-`->` or `.` is not dependent on a *template-parameter*, or the use does
-not appear in the scope of a template. — *end note*]
 [*Example 3*:
 ``` cpp
 template <class T> struct A {
@@ -131,19 +122,19 @@ template <class T> struct A {
   template <class U> void f(U);
 };
 template <class T> void f(T t) {
   A<T> a;
-  a.template f<>(t);                    // OK: calls template
   a.template f(t);                      // error: not a template-id
 }
 template <class T> struct B {
   template <class T2> struct C { };
 };
-// OK: T::template C names a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
 D<B<int> > db;
 ```
 — *end example*]
@@ -180,13 +171,12 @@ using T5 = X<S>;                // OK
 — *end example*]
 When the *template-name* of a *simple-template-id* names a constrained
 non-function template or a constrained template *template-parameter*,
-but not a member template that is a member of an unknown specialization
-[[temp.res]], and all *template-argument*s in the *simple-template-id*
-are non-dependent [[temp.dep.temp]], the associated constraints
 [[temp.constr.decl]] of the constrained template shall be satisfied
 [[temp.constr.constr]].
 [*Example 5*:
@@ -227,11 +217,11 @@ A *concept-id* is a *simple-template-id* where the *template-name* is a
 name a template specialization. A concept-id evaluates to `true` if the
 concept’s normalized *constraint-expression* [[temp.constr.decl]] is
 satisfied [[temp.constr.constr]] by the specified template arguments and
 `false` otherwise.
-[*Note 6*: Since a *constraint-expression* is an unevaluated operand, a
 concept-id appearing in a *constraint-expression* is not evaluated
 except as necessary to determine whether the normalized constraints are
 satisfied. — *end note*]
 [*Example 6*:

   constant-expression
   type-id
   id-expression
 ```
+The component name of a *simple-template-id*, *template-id*, or
+*template-name* is the first name in it.
+A `<` is interpreted as the delimiter of a *template-argument-list* if
+it follows a name that is not a *conversion-function-id* and
+- that follows the keyword `template` or a `~` after a
+ *nested-name-specifier* or in a class member access expression, or
+- for which name lookup finds the injected-class-name of a class
+  template or finds any declaration of a template, or
+- that is an unqualified name for which name lookup either finds one or
+  more functions or finds nothing, or
+- that is a terminal name in a *using-declarator* [[namespace.udecl]],
+  in a *declarator-id* [[dcl.meaning]], or in a type-only context other
+  than a *nested-name-specifier* [[temp.res]].
+[*Note 1*: If the name is an *identifier*, it is then interpreted as a
+*template-name*. The keyword `template` is used to indicate that a
+dependent qualified name [[temp.dep.type]] denotes a template where an
+expression might appear. — *end note*]
+[*Example 1*:
+``` cpp
+struct X {
+  template<std::size_t> X* alloc();
+  template<std::size_t> static X* adjust();
+};
+template<class T> void f(T* p) {
+  T* p1 = p->alloc<200>();              // error: < means less than
+  T* p2 = p->template alloc<200>();     // OK, < starts template argument list
+  T::adjust<100>();                     // error: < means less than
+  T::template adjust<100>();            // OK, < starts template argument list
+}
+```
+— *end example*]
+When parsing a *template-argument-list*, the first non-nested `>`[^2]
+is taken as the ending delimiter rather than a greater-than operator.
+Similarly, the first non-nested `>>` is treated as two consecutive but
 distinct `>` tokens, the first of which is taken as the end of the
 *template-argument-list* and completes the *template-id*.
+[*Note 2*: The second `>` token produced by this replacement rule can
+terminate an enclosing *template-id* construct or it can be part of a
 different construct (e.g., a cast). — *end note*]
+[*Example 2*:
 ``` cpp
 template<int i> class X { ... };
 X< 1>2 > x1;                            // syntax error
 Y<X<(6>>1)>> x5;                        // OK
 ```
 — *end example*]
+The keyword `template` shall not appear immediately after a declarative
+*nested-name-specifier* [[expr.prim.id.qual]].
+A name prefixed by the keyword `template` shall be followed by a
+template argument list or refer to a class template or an alias
+template. The latter case is deprecated [[depr.template.template]]. The
+keyword `template` shall not appear immediately before a `~` token (as
+to name a destructor).
+[*Note 3*: The keyword `template` cannot be applied to non-template
 members of class templates. — *end note*]
+[*Note 4*: As is the case with the `typename` prefix, the `template`
+prefix is allowed even when lookup for the name would already find a
+template. — *end note*]
 [*Example 3*:
 ``` cpp
 template <class T> struct A {
   template <class U> void f(U);
 };
 template <class T> void f(T t) {
   A<T> a;
+  a.template f<>(t);                    // OK, calls template
   a.template f(t);                      // error: not a template-id
 }
 template <class T> struct B {
   template <class T2> struct C { };
 };
+// deprecated: T::C is assumed to name a class template:
 template <class T, template <class X> class TT = T::template C> struct D { };
 D<B<int> > db;
 ```
 — *end example*]
 — *end example*]
 When the *template-name* of a *simple-template-id* names a constrained
 non-function template or a constrained template *template-parameter*,
+and all *template-argument*s in the *simple-template-id* are
+non-dependent [[temp.dep.temp]], the associated constraints
 [[temp.constr.decl]] of the constrained template shall be satisfied
 [[temp.constr.constr]].
 [*Example 5*:
 name a template specialization. A concept-id evaluates to `true` if the
 concept’s normalized *constraint-expression* [[temp.constr.decl]] is
 satisfied [[temp.constr.constr]] by the specified template arguments and
 `false` otherwise.
+[*Note 5*: Since a *constraint-expression* is an unevaluated operand, a
 concept-id appearing in a *constraint-expression* is not evaluated
 except as necessary to determine whether the normalized constraints are
 satisfied. — *end note*]
 [*Example 6*:

Diff to HTML by rtfpessoa