clang incorrectly considers top-level cv-qualifiers when determining the parameter mapping for subsumption

[CaseyCarter]

Clang considers overload resolution for f(42) in this program to be ambiguous:

template <class> concept True = true;
template <class T> constexpr bool f(const T) { return false;} 
template <True T> constexpr bool f(T) { return true; } 
static_assert(f(42));

which I believe is (or at least should be - the wording around parameter mappings is a bit sparse) non-conforming. Top-level cv-qualifiers on function parameters in C++ should have no effect outside the body of the function definition. This behavior notably diverges from GCC and MSVC (https://godbolt.org/z/jhvnsf8nf).

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Casey Carter (CaseyCarter)

Clang considers overload resolution for `f(42)` in this program to be ambiguous: ```c++ template <class> concept True = true; template <class T> constexpr bool f(const T) { return false;} template <True T> constexpr bool f(T) { return true; } static_assert(f(42)); ``` which I believe is (or at least should be - the wording around parameter mappings is a bit sparse) non-conforming. Top-level cv-qualifiers on function parameters in C++ should have no effect outside the body of the function definition. This behavior notably diverges from GCC and MSVC (https://godbolt.org/z/jhvnsf8nf).

[llvmbot]

@llvm/issue-subscribers-bug

Author: Casey Carter (CaseyCarter)

Clang considers overload resolution for `f(42)` in this program to be ambiguous: ```c++ template <class> concept True = true; template <class T> constexpr bool f(const T) { return false;} template <True T> constexpr bool f(T) { return true; } static_assert(f(42)); ``` which I believe is (or at least should be - the wording around parameter mappings is a bit sparse) non-conforming. Top-level cv-qualifiers on function parameters in C++ should have no effect outside the body of the function definition. This behavior notably diverges from GCC and MSVC (https://godbolt.org/z/jhvnsf8nf).

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Casey Carter (CaseyCarter)

Clang considers overload resolution for `f(42)` in this program to be ambiguous: ```c++ template <class> concept True = true; template <class T> constexpr bool f(const T) { return false;} template <True T> constexpr bool f(T) { return true; } static_assert(f(42)); ``` which I believe is (or at least should be - the wording around parameter mappings is a bit sparse) non-conforming. Top-level cv-qualifiers on function parameters in C++ should have no effect outside the body of the function definition. This behavior notably diverges from GCC and MSVC (https://godbolt.org/z/jhvnsf8nf).

[zyn0217]

llvm-project/clang/lib/Sema/SemaTemplateDeduction.cpp

Lines 5602 to 5605 in b45de48

	for (unsigned i = 0; i < NumParams1; ++i)
	if (!Context.hasSameType(FD1->getParamDecl(i)->getType(),
	FD2->getParamDecl(i)->getType()))
	return nullptr;

Perhaps this should be Context.hasSameUnqualifiedType.

[CaseyCarter]

For posterity: CWG 1001 says that I'm wrong about this particular case, and that top-level const is significant when applied to a parameter of dependent type.

[zyn0217]

Thank you for following up. I'll reopen the issue and see if I can fix that later.

[zyn0217]

(Considering that CWG 1001 has been open for over ~15 years, I think we should probably not revert PR #81449 until that issue gets fully resolved.)

[ken-matsui]

Oops, sorry about this. My private fork accidentally closed this.