CWG2900 Deduction of non-type template arguments with placeholder types

Author: eisenwave

source/declarations.tex

@@ -2183,7 +2183,11 @@
 \opt{\grammarterm{type-constraint}} \keyword{auto} either with
 a new invented type template parameter \tcode{U} or,
 if the initialization is copy-list-initialization, with
-\tcode{std::initializer_list<U>}. Deduce a value for \tcode{U} using the rules
+\tcode{std::initializer_list<U>}.
+If $E$ is a value synthesized for a constant template parameter
+of type \tcode{decltype(auto)}\iref{temp.func.order},
+the declaration is ill-formed.
+Otherwise, deduce a value for \tcode{U} using the rules
 of template argument deduction from a function call\iref{temp.deduct.call},
 where \tcode{P} is a
 function template parameter type and

source/templates.tex

@@ -4372,11 +4372,9 @@
 variable template, or concept,
 respectively, and substitute it for each occurrence of that parameter
 in the function type of the template.
-\begin{note}
-The type replacing the placeholder
+The type replacing a placeholder
 in the type of the value synthesized for a constant template parameter
-is also a unique synthesized type.
-\end{note}
+is a unique synthesized type.
 
 \pnum
 %FIXME: What's a "synthesized template"? Do we mean the synthesized
@@ -9390,11 +9388,16 @@
 \end{note}
 
 \pnum
-If \tcode{P} has a form that contains \tcode{<i>}, and
-if the type of \tcode{i} differs from the type
+If \tcode{P} has a form that contains \tcode{<i>},
+deduction fails unless the type of \tcode{i} is the same as that
 of the corresponding template parameter
+\tcode{p} in the specialization (from \tcode{A})
 of the template named by the enclosing \grammarterm{simple-template-id} or
-\grammarterm{splice-specialization-specifier}, deduction fails.
+\grammarterm{splice-specialization-specifier};
+if the declared type of \tcode{i} contains a placeholder type,
+the corresponding template argument for the purposes of
+placeholder type deduction\iref{dcl.type.auto.deduct}
+is an \grammarterm{id-expression} for \tcode{p}.
 If \tcode{P} has a form that contains \tcode{[i]}, and if the type of
 \tcode{i} is not an integral type, deduction fails.
 \begin{footnote}
@@ -9414,15 +9417,54 @@
 template<short s> void f(A<s>);
 void k1() {
   A<1> a;
-  f(a);             // error: deduction fails for conversion from \tcode{int} to \tcode{short}
-  f<1>(a);          // OK
+  f(a);                 // error: deduction fails for conversion from \tcode{int} to \tcode{short}
+  f<1>(a);              // OK
 }
 
 template<const short cs> class B { };
 template<short s> void g(B<s>);
 void k2() {
   B<1> b;
-  g(b);             // OK, cv-qualifiers are ignored on template parameter types
+  g(b);                 // OK, cv-qualifiers are ignored on template parameter types
+}
+
+template<auto> struct C;
+template<long long x> void f(C<x> *);
+void g(C<0LL> *ap) {
+  f(ap);                // OK, deduces long long value from 0LL
+}
+
+template<int> struct D;
+template<auto x> void f(D<x> *);
+void g(D<0LL> *ap) {
+  f(ap);                // OK, deduces x as an int value
+}
+
+template<int &> struct E;
+template<auto x> void f(E<x> *);
+int v;
+void g(E<v> *bp) {
+  f(bp);                // error: type \tcode{int} of \tcode{x} does not match the \tcode{int &} type
+}                       // of the template parameter in the \tcode{E<v>} specialization of \tcode{E}
+
+template<const int &> struct F;
+template<decltype(auto) x> void f(F<x> *);
+int i;
+void g(F<i> *ap) {
+  f(ap);                // OK, deduces \tcode{x} as a constant template parameter of type \tcode{const int &}
+}
+
+template <decltype(auto) q> struct G;
+template <auto x> long *f(G<x> *);              // \#1
+template <decltype(auto) x> short *f(G<x> *);   // \#2
+
+const int j = 0;
+short *g(G<(j)> *ap) {  // OK, \tcode{q} has type \tcode{const int &}
+  return f(ap);         // OK, only \tcode{#2} matches
+}
+
+long *g(G<j> *ap) {     // OK, \tcode{q} has type \tcode{int}
+  return f(ap);         // OK, \#1 is more specialized
 }
 \end{codeblock}
 \end{example}