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

Files changed (1) hide show

tmp/tmpof86zni8/{from.md → to.md} +37 -31

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

@@ -1,7 +1,9 @@
 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
@@ -32,10 +34,17 @@ void bar() {
 }
 ```
 — *end example*]
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
 corresponding *template-parameter*.[^3]
 [*Example 2*:
@@ -49,17 +58,13 @@ void g() {
 }
 ```
 — *end example*]
-The name of a *template-argument* shall be accessible at the point where
-it is used as a *template-argument*.
-[*Note 1*: If the name of the *template-argument* is accessible at the
-point where it is used as a *template-argument*, there is no further
-access restriction in the resulting instantiation where the
-corresponding *template-parameter* name is used. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
@@ -67,13 +72,13 @@ template<class T> class X {
 };
 class Y {
 private:
   struct S { ... };
-  X<S> x;           // OK: S is accessible
                     // X<Y::S> has a static member of type Y::S
-                    // OK: even though Y::S is private
 };
 X<Y::S> y;          // error: S not accessible
 ```
@@ -106,14 +111,14 @@ brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
 ``` cpp
 template<class T = char> class String;
-String<>* p;                    // OK: String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
-Tuple<>* t;                     // OK: Elements is empty
 Tuple* u;                       // syntax error
 ```
 — *end example*]
@@ -126,26 +131,28 @@ that is a class template specialization may explicitly specify the
 ``` cpp
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
-  p->A<int>::~A();              // OK: destructor call
-  q->A<int>::~A<int>();         // OK: destructor call
 }
 ```
 — *end example*]
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
-When name lookup for the name in a *template-id* finds an overload set,
-both non-template functions in the overload set and function templates
-in the overload set for which the *template-argument*s do not match the
-*template-parameter*s are ignored. If none of the function templates
-have matching *template-parameter*s, the program is ill-formed.
 When a *simple-template-id* does not name a function, a default
 *template-argument* is implicitly instantiated [[temp.inst]] when the
 value of that default argument is needed.
@@ -190,12 +197,12 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 1*: A template type argument may be an incomplete type
-[[basic.types]]. — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
 If the type `T` of a *template-parameter* [[temp.param]] contains a
 placeholder type [[dcl.spec.auto]] or a placeholder for a deduced class
@@ -317,22 +324,21 @@ C<Y{X{1}.n}> c;                 // error: subobject of temporary object used to
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
 A *template-argument* for a template *template-parameter* shall be the
 name of a class template or an alias template, expressed as
-*id-expression*. When the *template-argument* names a class template,
-only primary class templates are considered when matching the template
-template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
-Any partial specializations [[temp.class.spec]] associated with the
-primary class template or primary variable template are considered when
-a specialization based on the template *template-parameter* is
-instantiated. If a specialization is not visible at the point of
-instantiation, and it would have been selected had it been visible, the
-program is ill-formed, no diagnostic required.
 [*Example 1*:
 ``` cpp
 template<class T> class A {     // primary template
@@ -402,12 +408,12 @@ template <class T1> struct A;
 template <class T1, class T2> struct B;
 template <int N> struct C;
 template <class T1, int N> struct D;
 template <class T1, class T2, int N = 17> struct E;
-eval<A<int>> eA;                // OK: matches partial specialization of eval
-eval<B<int, float>> eB;         // OK: matches partial specialization of eval
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```

 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
+### General <a id="temp.arg.general">[[temp.arg.general]]</a>
 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
 }
 ```
 — *end example*]
+The template argument list of a *template-head* is a template argument
+list in which the nᵗʰ template argument has the value of the nᵗʰ
+template parameter of the *template-head*. If the nᵗʰ template parameter
+is a template parameter pack [[temp.variadic]], the nᵗʰ template
+argument is a pack expansion whose pattern is the name of the template
+parameter pack.
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
 corresponding *template-parameter*.[^3]
 [*Example 2*:
 }
 ```
 — *end example*]
+[*Note 1*: Names used in a *template-argument* are subject to access
+control where they appear. Because a *template-parameter* is not a class
+member, no access control applies. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
 };
 class Y {
 private:
   struct S { ... };
+  X<S> x;           // OK, S is accessible
                     // X<Y::S> has a static member of type Y::S
+                    // OK, even though Y::S is private
 };
 X<Y::S> y;          // error: S not accessible
 ```
 [*Example 5*:
 ``` cpp
 template<class T = char> class String;
+String<>* p;                    // OK, String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
+Tuple<>* t;                     // OK, Elements is empty
 Tuple* u;                       // syntax error
 ```
 — *end example*]
 ``` cpp
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
+  p->A<int>::~A();              // OK, destructor call
+  q->A<int>::~A<int>();         // OK, destructor call
 }
 ```
 — *end example*]
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
+When name lookup for the component name of a *template-id* finds an
+overload set, both non-template functions in the overload set and
+function templates in the overload set for which the
+*template-argument*s do not match the *template-parameter*s are ignored.
+[*Note 2*: If none of the function templates have matching
+*template-parameter*s, the program is ill-formed. — *end note*]
 When a *simple-template-id* does not name a function, a default
 *template-argument* is implicitly instantiated [[temp.inst]] when the
 value of that default argument is needed.
 }
 ```
 — *end example*]
+[*Note 1*: A template type argument can be an incomplete type
+[[term.incomplete.type]]. — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
 If the type `T` of a *template-parameter* [[temp.param]] contains a
 placeholder type [[dcl.spec.auto]] or a placeholder for a deduced class
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
 A *template-argument* for a template *template-parameter* shall be the
 name of a class template or an alias template, expressed as
+*id-expression*. Only primary templates are considered when matching the
+template template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
+Any partial specializations [[temp.spec.partial]] associated with the
+primary template are considered when a specialization based on the
+template *template-parameter* is instantiated. If a specialization is
+not reachable from the point of instantiation, and it would have been
+selected had it been reachable, the program is ill-formed, no diagnostic
+required.
 [*Example 1*:
 ``` cpp
 template<class T> class A {     // primary template
 template <class T1, class T2> struct B;
 template <int N> struct C;
 template <class T1, int N> struct D;
 template <class T1, class T2, int N = 17> struct E;
+eval<A<int>> eA;                // OK, matches partial specialization of eval
+eval<B<int, float>> eB;         // OK, matches partial specialization of eval
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```

Diff to HTML by rtfpessoa