CWG2369 Ordering between constraints and substitution

Author: burblebee

source/templates.tex

@@ -7596,13 +7596,52 @@
 
 When all template arguments have been deduced or obtained from
 default template arguments, all uses of template parameters in
-the template parameter list of the template and the function type
+the template parameter list of the template
 are replaced with the corresponding deduced
 or default argument values. If the substitution results in an
 invalid type, as described above, type deduction fails.
 If the function template has associated constraints\iref{temp.constr.decl},
 those constraints are checked for satisfaction\iref{temp.constr.constr}.
 If the constraints are not satisfied, type deduction fails.
+In the context of a function call, if type deduction has not yet failed, then
+for those function parameters for which the function call has arguments,
+each function parameter with a type that was non-dependent
+before substitution of any explicitly-specified template arguments
+is checked against its corresponding argument;
+if the corresponding argument cannot be implicitly converted
+to the parameter type, type deduction fails.
+\begin{note}
+Overload resolution will check the other parameters, including
+parameters with dependent types in which
+no template parameters participate in template argument deduction and
+parameters that became non-dependent due to substitution of
+explicitly-specified template arguments.
+\end{note}
+If type deduction has not yet failed, then
+all uses of template parameters in the function type are
+replaced with the corresponding deduced or default argument values.
+If the substitution results in an invalid type, as described above,
+type deduction fails.
+\begin{example}
+\begin{codeblock}
+template <class T> struct Z {
+  typedef typename T::x xx;
+};
+template <class T> concept C = requires { typename T::A; };
+template <C T> typename Z<T>::xx f(void *, T);          // \#1
+template <class T> void f(int, T);                      // \#2
+struct A {} a;
+struct ZZ {
+  template <class T, class = typename Z<T>::xx> operator T *();
+  operator int();
+};
+int main() {
+  ZZ zz;
+  f(1, a);              // OK, deduction fails for \#1 because there is no conversion from \tcode{int} to \tcode{void*}
+  f(zz, 42);            // OK, deduction fails for \#1 because \tcode{C<int>} is not satisfied
+}
+\end{codeblock}
+\end{example}
 
 \pnum
 At certain points in the template argument deduction process it is necessary
@@ -8160,35 +8199,6 @@
 \end{codeblock}
 \end{example}
 
-\pnum
-If deduction succeeds for all parameters that contain
-\grammarterm{template-parameter}{s} that participate in template argument
-deduction, and all template arguments are explicitly specified, deduced,
-or obtained from default template arguments, remaining parameters are then
-compared with the corresponding arguments. For each remaining parameter
-\tcode{P} with a type that was non-dependent before substitution of any
-explicitly-specified template arguments, if the corresponding argument
-\tcode{A} cannot be implicitly converted to \tcode{P}, deduction fails.
-\begin{note}
-Parameters with dependent types in which no \grammarterm{template-parameter}{s}
-participate in template argument deduction, and parameters that became
-non-dependent due to substitution of explicitly-specified template arguments,
-will be checked during overload resolution.
-\end{note}
-\begin{example}
-\begin{codeblock}
-template <class T> struct Z {
-  typedef typename T::x xx;
-};
-template <class T> typename Z<T>::xx f(void *, T);      // \#1
-template <class T> void f(int, T);                      // \#2
-struct A {} a;
-int main() {
-  f(1, a);          // OK, deduction fails for \#1 because there is no conversion from \tcode{int} to \tcode{void*}
-}
-\end{codeblock}
-\end{example}
-
 \rSec3[temp.deduct.funcaddr]{Deducing template arguments taking the address of a function template}
 
 \pnum