How does the template argument deduction perform for function template parameter when it is a class template with default argument

Question

template<typename T, typename U = T>
struct Test{};

template<typename T>
void func(Test<T>){  //#1
}

int main(){
  func(Test<int>{});  //#2
}

Consider the above code, At the point of invocation of function template func, the type of argument is Test<int,int>, When call the function template, template argument deduction will perform.

The rule of template argument deduction for function call is :
temp.deduct#call-1

Template argument deduction is done by comparing each function template parameter type (call it P) that contains template-parameters that participate in template argument deduction with the type of the corresponding argument of the call (call it A) as described below.

I'm pretty sure the type of A is Test<int,int>, however I'm not sure what the type of P here is. Is it Test<T> or Test<T,T>, According to the rule, It seems to the type of P here is Test<T>, then deduction process is performed to determine the value of T that participate in template argument deduction. Then according to these rules described as the following:

temp.deduct#call-4

In general, the deduction process attempts to find template argument values that will make the deduced A identical to A (after the type A is transformed as described above).

temp.deduct#5

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 are replaced with the corresponding deduced or default argument values.

Because the class template Test has a default argument, hence the deduced T is substituted into default argument. That means the deduced A is Test<int,int> and it is identical to Argument type Test<int,int>.

However, It's just my understanding. I'm not sure what type the P here is. If change the type of function argument to Test<int,double>, the outcome will report:

candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'double')

The outcome looks like as if the P is Test<T,T> and the fist value of T is conflicting with the second value of T.

So, My question is:

Whether the P here is Test<T> or Test<T,T>? and why?

Answer 1

not a language lawyer answer

There is no type Test<T> is actually a "shorthand" for Test<T, T>.

Just like with default function arguments if you have int foo(int a, int b = 24) the type of the function is int (int, int) and any call like foo(11) is actually foo(11, 24).