I ran into another issue while devising tests for redeclarations of xobj member functions as static member functions and vice versa. I am pretty sure by the literal wording of the standard, this is well formed.
template<typename T> concept Constrain = true; struct S { void f(this auto, Constrain auto) {}; static void f(Constrain auto) {}; void g(this auto const&, Constrain auto) {}; static void g(Constrain auto) {}; void h(this auto&&, Constrain auto) {}; static void h(Constrain auto) {}; }; And also, struct S{ void f(this auto) {}; static void f() {}; void g(this auto const&) {}; static void g() {}; void h(this auto&&) {}; static void h() {}; }; I wrote these tests expecting them to be ill-formed, and found what I thought was a bug when they were not diagnosed as redecelarations. However, given how the code for resolving overloads and determining redeclarations looks, I believe this is actually well formed on a technicality. I can't find the passages in the standard that specify this so I can't be sure. Anyway, the template parameter list differs because of the deduced object parameter. Now here is the question, you are required to ignore the object parameter when determining if these are redeclarations or not, but what about the template parameters associated with the object parameter? Am I just missing the passage that specifies this or is this an actual defect in the standard? The annoying thing is, even if this was brought up, I think the only solution is to ratify these examples as well formed. struct S { template<typename T> void f(this T, T) {} template<typename T> static void f(T) {} }; Like what about this? If we ignore the template parameters associated with the explicit object parameter, then the template parameter lists don't match. struct S { template<template<typename> typename Templ, typename T> void f(this Templ<T>, T) {} template<typename T> void f(T) {} }; However, after writing them out and thinking about it a little, maybe it really is just that simple. If after eliminating the template parameters the explicit object parameter depends on the template parameter lists are the same, then it's a redeclaration. Maybe this works? Am I overthinking this? Is there actually something specifying this properly already? Hopefully that's the case but at the very least I managed to write out this e-mail fairly quick for once so I didn't waste too much time on this even if it does turn out to be nothing. The majority of my time here was spent on the test case, which needed to be written anyway. Alex