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

Files changed (1) hide show

tmp/tmpmffq9es8/{from.md → to.md} +180 -53

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

@@ -12,14 +12,14 @@ template<class T> void sort(Array<T>&);
 ```
 — *end example*]
 A function template can be overloaded with other function templates and
-with non-template functions ([[dcl.fct]]). A non-template function is
-not related to a function template (i.e., it is never considered to be a
 specialization), even if it has the same name and type as a potentially
-generated function template specialization.[^5]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
@@ -45,16 +45,16 @@ void h(int* p) {
 ```
 — *end example*]
 Such specializations are distinct functions and do not violate the
-one-definition rule ([[basic.def.odr]]).
-The signature of a function template is defined in Clause
-[[intro.defs]]. The names of the template parameters are significant
-only for establishing the relationship between the template parameters
-and the rest of the signature.
 [*Note 1*:
 Two distinct function templates may have identical function return types
 and function parameter lists, even if overload resolution alone cannot
@@ -92,120 +92,186 @@ template parameters, but it is possible for an expression to reference a
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 *equivalent* if two function definitions containing the expressions
-would satisfy the one-definition rule ([[basic.def.odr]]), except that
-the tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 another token that names the same template parameter in the other
-expression. For determining whether two dependent names ([[temp.dep]])
-are equivalent, only the name itself is considered, not the result of
-name lookup in the context of the template. If multiple declarations of
-the same function template differ in the result of this name lookup, the
-result for the first declaration is used.
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <int K, int L> void f(A<K+L>);         // same as #1
 template <class T> decltype(g(T())) h();
 int g(int);
-template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup
-  { return g(T()); }                            // ...although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
                                                 // was not in scope at the first declaration of h()
 ```
 — *end example*]
-Two expressions involving template parameters that are not equivalent
-are *functionally equivalent* if, for any given set of template
-arguments, the evaluation of the expression results in the same value.
 Two function templates are *equivalent* if they are declared in the same
-scope, have the same name, have identical template parameter lists, and
-have return types and parameter lists that are equivalent using the
-rules described above to compare expressions involving template
-parameters. Two function templates are *functionally equivalent* if they
-are equivalent except that one or more expressions that involve template
-parameters in the return types and parameter lists are functionally
-equivalent using the rules described above to compare expressions
-involving template parameters. If a program contains declarations of
-function templates that are functionally equivalent but not equivalent,
-the program is ill-formed, no diagnostic required.
-[*Note 3*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
 equivalent and would cause a program to be ill-formed:
 ``` cpp
-// Guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+10>);
-// Guaranteed to be different
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+11>);
-// Ill-formed, no diagnostic required
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+1+2+3+4>);
 ```
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
 If a function template is overloaded, the use of a function template
-specialization might be ambiguous because template argument deduction (
-[[temp.deduct]]) may associate the function template specialization with
 more than one function template declaration. *Partial ordering* of
 overloaded function template declarations is used in the following
 contexts to select the function template to which a function template
 specialization refers:
 - during overload resolution for a call to a function template
-  specialization ([[over.match.best]]);
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
   specialization is selected to match a placement operator new (
   [[basic.stc.dynamic.deallocation]], [[expr.new]]);
-- when a friend function declaration ([[temp.friend]]), an explicit
-  instantiation ([[temp.explicit]]) or an explicit specialization (
-  [[temp.expl.spec]]) refers to a function template specialization.
 Partial ordering selects which of two function templates is more
 specialized than the other by transforming each template in turn (see
 next paragraph) and performing template argument deduction using the
 function type. The deduction process determines whether one of the
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
 To produce the transformed template, for each type, non-type, or
-template template parameter (including template parameter packs (
-[[temp.variadic]]) thereof) synthesize a unique type, value, or class
 template respectively and substitute it for each occurrence of that
 parameter in the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
 synthesized for a non-type template parameter is also a unique
 synthesized type. — *end note*]
-If only one of the function templates *M* is a non-static member of some
-class *A*, *M* is considered to have a new first parameter inserted in
-its function parameter list. Given cv as the cv-qualifiers of *M* (if
-any), the new parameter is of type “rvalue reference to cv *A*” if the
-optional *ref-qualifier* of *M* is `&&` or if *M* has no *ref-qualifier*
-and the first parameter of the other template has rvalue reference type.
-Otherwise, the new parameter is of type “lvalue reference to cv *A*”.
 [*Note 2*: This allows a non-static member to be ordered with respect
 to a non-member function and for the results to be equivalent to the
 ordering of two equivalent non-members. — *end note*]
@@ -223,11 +289,11 @@ template<class T, class R> int operator*(T&, R&);   // #2
 // template<class R> int operator*(B<A>&, R&);\quad\quad\quad// #1a
 int main() {
   A a;
   B<A> b;
-  b * a;                                            // calls #1a
 }
 ```
 — *end example*]
@@ -264,12 +330,12 @@ void m() {
 — *end example*]
 [*Note 3*:
-Since partial ordering in a call context considers only parameters for
-which there are explicit call arguments, some parameters are ignored
 (namely, function parameter packs, parameters with default arguments,
 and ellipsis parameters).
 [*Example 3*:
@@ -316,14 +382,75 @@ template<class T, class... U> void f(T, U...);          // #1
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
-  f(&i);                                                // error: ambiguous
   g(&i);                                                // OK: calls #3
 }
 ```
 — *end example*]
 — *end note*]

 ```
 — *end example*]
 A function template can be overloaded with other function templates and
+with non-template functions [[dcl.fct]]. A non-template function is not
+related to a function template (i.e., it is never considered to be a
 specialization), even if it has the same name and type as a potentially
+generated function template specialization.[^9]
 #### Function template overloading <a id="temp.over.link">[[temp.over.link]]</a>
 It is possible to overload function templates so that two different
 function template specializations have the same type.
 ```
 — *end example*]
 Such specializations are distinct functions and do not violate the
+one-definition rule [[basic.def.odr]].
+The signature of a function template is defined in [[intro.defs]]. The
+names of the template parameters are significant only for establishing
+the relationship between the template parameters and the rest of the
+signature.
 [*Note 1*:
 Two distinct function templates may have identical function return types
 and function parameter lists, even if overload resolution alone cannot
 type parameter. For example, a template type parameter can be used in
 the `sizeof` operator. — *end note*]
 Two expressions involving template parameters are considered
 *equivalent* if two function definitions containing the expressions
+would satisfy the one-definition rule [[basic.def.odr]], except that the
+tokens used to name the template parameters may differ as long as a
 token used to name a template parameter in one expression is replaced by
 another token that names the same template parameter in the other
+expression. Two unevaluated operands that do not involve template
+parameters are considered equivalent if two function definitions
+containing the expressions would satisfy the one-definition rule, except
+that the tokens used to name types and declarations may differ as long
+as they name the same entities, and the tokens used to form concept-ids
+may differ as long as the two *template-id*s are the same [[temp.type]].
+[*Note 3*: For instance, `A<42>` and `A<40+2>` name the same
+type. — *end note*]
+Two *lambda-expression*s are never considered equivalent.
+[*Note 4*: The intent is to avoid *lambda-expression*s appearing in the
+signature of a function template with external linkage. — *end note*]
+For determining whether two dependent names [[temp.dep]] are equivalent,
+only the name itself is considered, not the result of name lookup in the
+context of the template. If multiple declarations of the same function
+template differ in the result of this name lookup, the result for the
+first declaration is used.
 [*Example 3*:
 ``` cpp
 template <int I, int J> void f(A<I+J>);         // #1
 template <int K, int L> void f(A<K+L>);         // same as #1
 template <class T> decltype(g(T())) h();
 int g(int);
+template <class T> decltype(g(T())) h()         // redeclaration of h() uses the earlier lookup…
+  { return g(T()); }                            // …{} although the lookup here does find g(int)
 int i = h<int>();                               // template argument substitution fails; g(int)
                                                 // was not in scope at the first declaration of h()
+// ill-formed, no diagnostic required: the two expressions are functionally equivalent but not equivalent
+template <int N> void foo(const char (*s)[([]{}, N)]);
+template <int N> void foo(const char (*s)[([]{}, N)]);
+// two different declarations because the non-dependent portions are not considered equivalent
+template <class T> void spam(decltype([]{}) (*s)[sizeof(T)]);
+template <class T> void spam(decltype([]{}) (*s)[sizeof(T)]);
 ```
 — *end example*]
+Two potentially-evaluated expressions involving template parameters that
+are not equivalent are *functionally equivalent* if, for any given set
+of template arguments, the evaluation of the expression results in the
+same value. Two unevaluated operands that are not equivalent are
+functionally equivalent if, for any given set of template arguments, the
+expressions perform the same operations in the same order with the same
+entities.
+[*Note 5*: For instance, one could have redundant
+parentheses. — *end note*]
+Two *template-head*s are *equivalent* if their
+*template-parameter-list*s have the same length, corresponding
+*template-parameter*s are equivalent and are both declared with
+*type-constraint*s that are equivalent if either *template-parameter* is
+declared with a *type-constraint*, and if either *template-head* has a
+*requires-clause*, they both have *requires-clause*s and the
+corresponding *constraint-expression*s are equivalent. Two
+*template-parameter*s are *equivalent* under the following conditions:
+- they declare template parameters of the same kind,
+- if either declares a template parameter pack, they both do,
+- if they declare non-type template parameters, they have equivalent
+  types ignoring the use of *type-constraint*s for placeholder types,
+  and
+- if they declare template template parameters, their template
+  parameters are equivalent.
+When determining whether types or *type-constraint*s are equivalent, the
+rules above are used to compare expressions involving template
+parameters. Two *template-head*s are *functionally equivalent* if they
+accept and are satisfied by [[temp.constr.constr]] the same set of
+template argument lists.
 Two function templates are *equivalent* if they are declared in the same
+scope, have the same name, have equivalent *template-head*s, and have
+return types, parameter lists, and trailing *requires-clause*s (if any)
+that are equivalent using the rules described above to compare
+expressions involving template parameters. Two function templates are
+*functionally equivalent* if they are declared in the same scope, have
+the same name, accept and are satisfied by the same set of template
+argument lists, and have return types and parameter lists that are
+functionally equivalent using the rules described above to compare
+expressions involving template parameters. If the validity or meaning of
+the program depends on whether two constructs are equivalent, and they
+are functionally equivalent but not equivalent, the program is
+ill-formed, no diagnostic required.
+[*Note 6*:
 This rule guarantees that equivalent declarations will be linked with
 one another, while not requiring implementations to use heroic efforts
 to guarantee that functionally equivalent declarations will be treated
 as distinct. For example, the last two declarations are functionally
 equivalent and would cause a program to be ill-formed:
 ``` cpp
+// guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+10>);
+// guaranteed to be different
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+11>);
+// ill-formed, no diagnostic required
 template <int I> void f(A<I>, A<I+10>);
 template <int I> void f(A<I>, A<I+1+2+3+4>);
 ```
 — *end note*]
 #### Partial ordering of function templates <a id="temp.func.order">[[temp.func.order]]</a>
 If a function template is overloaded, the use of a function template
+specialization might be ambiguous because template argument deduction
+[[temp.deduct]] may associate the function template specialization with
 more than one function template declaration. *Partial ordering* of
 overloaded function template declarations is used in the following
 contexts to select the function template to which a function template
 specialization refers:
 - during overload resolution for a call to a function template
+  specialization [[over.match.best]];
 - when the address of a function template specialization is taken;
 - when a placement operator delete that is a function template
   specialization is selected to match a placement operator new (
   [[basic.stc.dynamic.deallocation]], [[expr.new]]);
+- when a friend function declaration [[temp.friend]], an explicit
+  instantiation [[temp.explicit]] or an explicit specialization
+  [[temp.expl.spec]] refers to a function template specialization.
 Partial ordering selects which of two function templates is more
 specialized than the other by transforming each template in turn (see
 next paragraph) and performing template argument deduction using the
 function type. The deduction process determines whether one of the
 templates is more specialized than the other. If so, the more
 specialized template is the one chosen by the partial ordering process.
+If both deductions succeed, the partial ordering selects the more
+constrained template (if one exists) as determined below.
 To produce the transformed template, for each type, non-type, or
+template template parameter (including template parameter packs
+[[temp.variadic]] thereof) synthesize a unique type, value, or class
 template respectively and substitute it for each occurrence of that
 parameter in the function type of the template.
 [*Note 1*: The type replacing the placeholder in the type of the value
 synthesized for a non-type template parameter is also a unique
 synthesized type. — *end note*]
+Each function template M that is a member function is considered to have
+a new first parameter of type X(M), described below, inserted in its
+function parameter list. If exactly one of the function templates was
+considered by overload resolution via a rewritten candidate
+[[over.match.oper]] with a reversed order of parameters, then the order
+of the function parameters in its transformed template is reversed. For
+a function template M with cv-qualifiers cv that is a member of a class
+A:
+- The type X(M) is “rvalue reference to cv A” if the optional
+  *ref-qualifier* of M is `&&` or if M has no *ref-qualifier* and the
+  positionally-corresponding parameter of the other transformed template
+  has rvalue reference type; if this determination depends recursively
+  upon whether X(M) is an rvalue reference type, it is not considered to
+  have rvalue reference type.
+- Otherwise, X(M) is “lvalue reference to cv A”.
 [*Note 2*: This allows a non-static member to be ordered with respect
 to a non-member function and for the results to be equivalent to the
 ordering of two equivalent non-members. — *end note*]
 // template<class R> int operator*(B<A>&, R&);\quad\quad\quad// #1a
 int main() {
   A a;
   B<A> b;
+  b * a;                                            // calls #1
 }
 ```
 — *end example*]
 — *end example*]
 [*Note 3*:
+Since, in a call context, such type deduction considers only parameters
+for which there are explicit call arguments, some parameters are ignored
 (namely, function parameter packs, parameters with default arguments,
 and ellipsis parameters).
 [*Example 3*:
 template<class T            > void f(T);                // #2
 template<class T, class... U> void g(T*, U...);         // #3
 template<class T            > void g(T);                // #4
 void h(int i) {
+  f(&i);                                                // OK: calls #2
   g(&i);                                                // OK: calls #3
 }
 ```
 — *end example*]
 — *end note*]
+If deduction against the other template succeeds for both transformed
+templates, constraints can be considered as follows:
+- If their *template-parameter-list*s (possibly including
+  *template-parameter*s invented for an abbreviated function template
+  [[dcl.fct]]) or function parameter lists differ in length, neither
+  template is more specialized than the other.
+- Otherwise:
+  - If exactly one of the templates was considered by overload
+    resolution via a rewritten candidate with reversed order of
+    parameters:
+    - If, for either template, some of the template parameters are not
+      deducible from their function parameters, neither template is more
+      specialized than the other.
+    - If there is either no reordering or more than one reordering of
+      the associated *template-parameter-list* such that
+      - the corresponding *template-parameter*s of the
+        *template-parameter-list*s are equivalent and
+      - the function parameters that positionally correspond between the
+        two templates are of the same type,
+      neither template is more specialized than the other.
+  - Otherwise, if the corresponding *template-parameter*s of the
+    *template-parameter-list*s are not equivalent [[temp.over.link]] or
+    if the function parameters that positionally correspond between the
+    two templates are not of the same type, neither template is more
+    specialized than the other.
+- Otherwise, if the context in which the partial ordering is done is
+  that of a call to a conversion function and the return types of the
+  templates are not the same, then neither template is more specialized
+  than the other.
+- Otherwise, if one template is more constrained than the other
+  [[temp.constr.order]], the more constrained template is more
+  specialized than the other.
+- Otherwise, neither template is more specialized than the other.
+[*Example 6*:
+``` cpp
+template <typename> constexpr bool True = true;
+template <typename T> concept C = True<T>;
+void f(C auto &, auto &) = delete;
+template <C Q> void f(Q &, C auto &);
+void g(struct A *ap, struct B *bp) {
+  f(*ap, *bp);                  // OK: Can use different methods to produce template parameters
+}
+template <typename T, typename U> struct X {};
+template <typename T, C U, typename V> bool operator==(X<T, U>, V) = delete;
+template <C T, C U, C V>               bool operator==(T, X<U, V>);
+void h() {
+  X<void *, int>{} == 0;        // OK: Correspondence of [T, U, V] and [U, V, T]
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa