Incorrectly accepts overload of (T&, int) vs. (T const&, U) #54347

[ecatmur]

Summary

clang correctly rejects as ambiguous:

template<class T> int f(T&, int); 1
template<class T, class U> int f(T const&, U); 2
int g(int const& i) { return f(i, 0); }
However if the order of template parameters in (2) is swapped:

template<class T> int f(T&, int); 1
template<class U, class T> int f(T const&, U); 2'
int g(int const& i) { return f(i, 0); }
clang incorrectly accepts, calling (1).

All versions tested up to current trunk incorrectly accept; 3.6 and older also incorrectly accept the first case.
gcc correctly rejects both cases since 4.5, incorrectly accepting in earlier versions.
icc 13 onwards correctly rejects.
MSVC correctly rejects (although it has other bugs in this area).

The problem appears to be that DeduceTemplateArgumentsByTypeMatch incorrectly believes that P and A are distinct; P is type-parameter-0-1 whereas A is type-parameter-0-0.

I believe this can be fixed simply by removing the hasSameUnqualifiedType check, since if the types are dissimilar the call would fail later anyway,

[ecatmur]

https://github.com/llvm/llvm-project/issues/54347

[ecatmur]

ping

clang/lib/Sema/SemaTemplateDeduction.cpp

     if (ARef)
       A = A->getPointeeType();
 
-    if (PRef && ARef && S.Context.hasSameUnqualifiedType(P, A)) {
+    if (PRef && ARef) {
       // C++11 [temp.deduct.partial]p9:
       //   If, for a given type, deduction succeeds in both directions (i.e.,
       //   the types are identical after the transformations above) and both

clang/test/SemaCXX/overload-call.cpp

     f(pmf);
   }
 }
+
+namespace PR54347 {
+  template<class T> void f1(T&, int); // expected-note {{candidate function}}
+  template<class U, class T> void f1(T const&, U); // expected-note {{candidate function}}
+  void g1(int const& i) { f1(i, 0); } // expected-error {{ambiguous}}
+
+  template<class T> void f2(T(&)[5], int); // expected-note {{candidate function}}
+  template<class U, class T> void f2(T const(&)[5], U); // expected-note {{candidate function}}
+  void g2(int const(& a)[5]) { f2(a, 0); } // expected-error {{ambiguous}}
+}