On 9/25/26 3:21 AM, Waffl3x wrote:
On Thursday, September 24th, 2026 at 11:07 AM, Jason Merrill <[email protected]> wrote:On 9/23/26 10:12 AM, Eczbek wrote:On 2026-09-22 17:41:12, Jason Merrill wrote:On 9/22/26 8:19 AM, Eczbek wrote:On 2026-09-21 13:05:37, Jason Merrill wrote:On 6/10/26 4:06 PM, Eczbek wrote:On 6/10/26 15:39, Patrick Palka wrote:On Wed, 10 Jun 2026, Eczbek wrote:On 6/10/26 09:27, Patrick Palka wrote:On Tue, 9 Jun 2026, Eczbek wrote:On 6/9/26 10:08, Patrick Palka wrote:On Mon, 8 Jun 2026, Eczbek wrote:On 6/5/26 11:16, Patrick Palka wrote:On Thu, 4 Jun 2026, Eczbek wrote:On 6/2/26 16:30, Patrick Palka wrote:On Mon, 1 Jun 2026, Eczbek wrote:On 6/1/26 16:33, Jason Merrill wrote:This assumes a template with a single template parameter; it doesn't work for e.g. struct A { template<typename T, typename U> operator T U::*() { return 0; } }; int main() { (void) &A::operator int A::*; } to handle the general case you need to deduce the template arguments.Thanks, I did not consider multiple template parameters. Would this be similar to what TEMPLATE_ID_EXPR does below, or is there some existing helper that should be used? I'm not sure how to do this.There are a couple of entrypoints to deduction, all of which ultimately call the main workhorse unify. For simplicity I think we could get away with calling unify directly from resolve_nondeduced_context with tparms = DECL_TEMPLATE_PARMS of the conversion function template targs = empty TREE_VEC same length as DECL_TEMPLATE_PARMS parm = return type of the template arg = BASELINK_OPTYPE strict = UNIFY_ALLOW_NONE (I think?) If unify succeeds, then 'targs' will contain the deduced template arguments that we need to instantiate the conversion function template with. So for struct A { template<class T, class U> operator B<T*, U&>(); }; int main() { &A::operator B<int*, char&>; } we need to call unify with (where {} is shorthand for a TREE_VEC) tparms = {T, U} targs = {NULL, NULL} parm = B<T*, U&> arg = B<int*, char&> which should succeed and fill in targs with {int, char}. Instantiating the template with {int, char} yields the correct specialization operator B<int*, char&>.Thank you, I made something work! Bootstrapped/regtested again. Jason mentioned that what I wrote in the changelog should be in the main commit message, so what should I write in the changelog instead?I think Jason's point is that the main commit message generally shouldn't be empty, even if it just repeats what you wrote in the ChangeLog. Though generally the ChangeLog ought to describe how the code is changed, and the context/motivation of the change should be in the main commit message, so there shouldn't be too much overlap. Here I'd just write: (resolve_overloaded_unification): Call unify when resolving a conversion-function-id. (resolve_nondeduced_context): Likewise.-- >8 -- --- gcc/cp/pt.cc | 30 ++++++++++++++++++++++++-- gcc/testsuite/g++.dg/template/conv22.C | 28 ++++++++++++++++++++++++ 2 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/template/conv22.C diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 6992b5196fe..d914a1c817d 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -25193,6 +25193,7 @@ resolve_overloaded_unification (tree tparms, int good = 0; tree goodfn = NULL_TREE; bool addr_p; + tree baselink = NULL_TREE; if (TREE_CODE (arg) == ADDR_EXPR) { @@ -25212,7 +25213,22 @@ resolve_overloaded_unification (tree tparms, /* Strip baselink information. */ if (BASELINK_P (arg)) - arg = BASELINK_FUNCTIONS (arg); + { + baselink = arg; + arg = BASELINK_FUNCTIONS (arg); + } + + if (TREE_CODE (arg) == OVERLOAD + && IDENTIFIER_CONV_OP_P (OVL_NAME (arg))) + { + tree tmpl = OVL_FIRST (arg); + tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); + tree targs = make_tree_vec (DECL_NTPARMS (tmpl)); + tree parm = DECL_CONV_FN_TYPE (DECL_TEMPLATE_RESULT (tmpl)); + tree optype = BASELINK_OPTYPE (baselink); + if (!unify (tparms, targs, parm, optype, UNIFY_ALLOW_NONE, false)) + arg = lookup_template_function (tmpl, targs); + }This needs to be done in a loop over each conversion template in the overload set because the result of deduction can differ for each template: struct A { template<class T> operator T(); // #1 template<class T> operator B<T>(); // #2 }; int main() { &A::operator B<int>; // targs would be {B<int>} for #1 and {int} for #2 } And instead of calling lookup_template_function to form a template-id, I think we need to call instantiate_template to directly instantiate each template for which deduction succeeded. We could factor out all this into a helper tree resolve_conversion_function_id (tree fns, tree optype) that takes a conversion operator overload set FNS and target type OPTYPE and returns an overload set containing the instantiated functions that match the target type.Thanks, I have this: tree resolve_conversion_function_id (tree fns, tree optype) { tree overloads = NULL_TREE; for (lkp_iterator iter (fns); iter; ++iter) { tree tmpl = *iter; tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); tree targs = make_tree_vec (DECL_NTPARMS (tmpl)); tree parm = DECL_CONV_FN_TYPE (DECL_TEMPLATE_RESULT (tmpl)); if (unify (tparms, targs, parm, optype, UNIFY_ALLOW_NONE, false)) continue; tree fn = instantiate_template (tmpl, targs, tf_none); if (!constraints_satisfied_p (fn)) continue; overloads = lookup_add (fn, overloads); } return overloads; } But how can the most "specific" overload be selected from the returned set? Please advise.That's the partial ordering step of overload resolution, done by the the 'tourney' function, see e.g perform_overload_resolution. But I don't think we want to do do partial ordering here, we should just reject the code if there's more than one viable overload after this step. So the previous example struct A { template<class T> operator T(); // #1 template<class T> operator B<T>(); // #2 }; int main() { &A::operator B<int>; // targs would be {B<int>} for #1 and {int} for #2 } should be rejected despite #2 being more specialized than #1.That seems incomplete to me. Both Clang and MSVC appear to select the most specialized overload: https://godbolt.org/z/q5a755bcKGood catch. GCC behaves the same and selects the most specialized conversion function if we turn f into a non-template to sidestep template argument deduction: void f(B<int>(A::*)()); int main() { f(&A::operator B<int>); } So the problem is that deduction fails to deduce T=B<int> for the function template f. Once we can convince GCC of that then it should work by virtue of the non-template f case working. The analogous non-conversion-function testcase is: template<class> struct B {}; struct A { template<class T> void g(T); template<class T> void g(T) requires true; }; template<class T> void f(void(A::*)(T)); int main() { f(&A::g<int>); } which GCC does accept by deducing T=int for f, despite multiple function templates in the overload set. So the problem is specific to conversion functions. Using your resolve_conversion_function_id implementation, the following change to resolve_overloaded_unification seems to do the right thing without needing to implement additional "more specialized" logic: diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 891e89f1d763..3f079457b455 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -25336,8 +25336,12 @@ resolve_overloaded_unification (tree tparms, arg = TREE_OPERAND (arg, 1); /* Strip baselink information. */ + tree optype = NULL_TREE; if (BASELINK_P (arg)) + { + optype = BASELINK_OPTYPE (arg); arg = BASELINK_FUNCTIONS (arg); + } if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) { @@ -25401,6 +25405,9 @@ resolve_overloaded_unification (tree tparms, not just the function on its own. */ return false; else + { + if (optype) + arg = resolve_conversion_function_id (arg, optype); for (lkp_iterator iter (arg); iter; ++iter) { tree fn = *iter; @@ -25417,6 +25424,7 @@ resolve_overloaded_unification (tree tparms, ++good; } } + } /* [temp.deduct.type] A template-argument can be deduced from a pointer to function or pointer to member function argument if the set ofThanks, that seems to work! Here's what I have so far, and my tests. (void)&D::operator int D::*; currently fails because resolve_nondeduced_context only accepts single overloads. How should it also select the most specialized overload?I'm not sure it should. Clang doesn't accept that code either, right? In any case, let's ignore that case for now and treat it as a separate issue because we also don't accept the non-convfn version of that code: template<class> struct B {}; struct A { template<class T> void g(T); template<class T> void g(T) requires true; }; template<class T> void f(void(A::*)(T)); int main() { &A::g<int>; };Clang doesn't accept, but MSVC does.And EDG. And I think it's clear we should under https://eel.is/c++draft/over.over which does consider the case of no target type.I agree it is a good idea to ignore this for now. Is there an existing bug report?I think let's not give up on this so quickly, at least not without analyzing it. It seems that the key difference between this and auto x = &A::g<int>; is that in the declaration, we first go through resolve_nondeduced_context (twice, both times to no effect), then resolve_overloaded_unification to determine the type of x, then resolve_address_of_overloaded_function to resolve which actual function we want. Note that resolve_overloaded_unification is only interested in the type; once we have a type we don't care about the individual overloads. So if we have optype I think we should just unify on that and not bother with resolve_conversion_function_id.To clarify, does this mean we should directly call unify? If so, I'm not sure how to get all of the arguments for it here without looping over the overloads.I was thinking unify (tparms, targs, parm, optype, strict, explain_p)Sorry, I'm not sure how to do this properly. This is what I tried: if (BASELINK_P (arg) && unify (tparms, targs, parm, BASELINK_OPTYPE (arg), strict, explain_p)) return false; but this breaks all of the `deduce` tests.Ah, right, we need a function type, not just the optype. And now it occurs to me that the functions might differ in noexcept even if they match otherwise. So never mind, let's leave resolve_overloaded_unification as in your last patch.I told Eczbek to not worry about it for now and wait to see what you say, but I reckon we want to match our behavior described in p3606. struct S { template <typename T> requires std::copyable<T> explicit S(T op) noexcept; // #1 S(const S&) noexcept = default; // #2 }; static_assert(std::copyable<S>); Where we pick #2 without instantiating #1.
resolve_address_ already ignores templates after finding a matching non-template. But I don't think we can skip deduction when we don't have a target type...
What is unclear to me is what a perfect match would be for this, whether noexceptness needs to match as well.
...because there can't be a perfect match when there's no target type.
The standard also doesn't seem to specify ordering of cases where there is no target type or the target type is a placeholder type. The closest I could find was https://eel.is/c++draft/temp.deduct.partial#3.2 , which is probably good enough to show it would be in the spirit to do it in this case.
I think [over.over] covers this: * All non-template functions are added to the set (p2)* All deducible templates are added to the set -- in the case of no target type, this is just from optype or explicit template args (p3)
* Do partial ordering (p5) If there's only one function left, that's the result.
And then in resolve_nondeduced_context, if we have an optype we can pass that to resolve_address_of_overloaded_function, and again we don't need the new function.I'm guessing that would look something like this, but I can't figure out how to pass explicit_targs: if (BASELINK_P (expr)) expr = resolve_address_of_overloaded_function (BASELINK_OPTYPE (expr), BASELINK_FUNCTIONS (expr), complain, true, /* explicit_targs? */, BASELINK_ACCESS_BINFO (expr));explicit_targs would be NULL_TREE in this case...I'm also having trouble with this because resolve_address_of_overloaded_function is declared in class.cc but I'm in pt.cc. Please advise....but it seems it's better to call instantiate_type rather than resolve_ directly.This is what I tried: if (BASELINK_P (expr)) { baselink = expr; expr = instantiate_type (BASELINK_OPTYPE (expr), BASELINK_FUNCTIONS (expr), complain); } but this breaks other tests. `&A::operator int;` results in: error: cannot resolve overloaded function ‘operator T’ based on conversion to type ‘int’And here we would want to check whether if there are multiple results of resolve_conversion_function_id they have the same type, and if so pass that type to instantiate_type.There seems to be lots of cases where the type would be different where we still want to do this. Explicit object member functions throw another wrench into this.
We only prefer one on the basis of partial ordering, and since we're doing this on the basis of function signature I don't see how it could apply when the types are different. And I don't see the complication from xobj functions; the address of such a function has a defined type.
Jason
I'm not familiar with instantiate_type at all though so I'm not sure what the actual correct thing here is. It seems if we decide to worry about perfect match it gets rather complex. After pondering it for a bit, it might be a lot more out of reach than I initially thought.Another case to consider is selecting the overload based on the qualifiers of the target type: https://godbolt.org/z/aY7Gorrx6 I discussed this with Waffl3x and we believe that Clang is correct to select the template overload. My patch doesn't affect this.They are indeed correct. Normally instantiate_type/resolve_address_of_overloaded_function take care of that, but presumably they don't consider BASELINK_OPTYPE currently, so perhaps we need resolve_conversion_function_id there too. JasonAnd then to handle the non-conversion example above, we could change the existing loop to handle the case where multiple results have the same type, and use resolve_address_of_overloaded_function in that case as well. Or perhaps replace the existing loop with a call to do_auto_deduction. This could indeed be a follow-up patch, but I'd like to address it while we're thinking about it rather than drop it until some unknown time in the future. After these changes, the first resolve_nondeduced_context should fully resolve the expression, so later ones don't need to do anything. Though I also wonder about removing the two calls to resolve_nondeduced_context in the auto path, since they seem to be redundant. JasonBootstrapped/regtested again. Is the ChangeLog OK? -- >8 -- Taking the address of a conversion function template instantiation incorrectly errors. PR c++/122383 gcc/cp/ChangeLog: * pt.cc (resolve_conversion_function_id): Filter a conversion function overload set using unify. (resolve_overloaded_unification): Call resolve_conversion_function_id when resolving a conversion-function-id. (resolve_nondeduced_context): Likewise. gcc/testsuite/ChangeLog: * g++.dg/template/conv22.C: New test. --- gcc/cp/pt.cc | 121 +++++++++++++++++-------- gcc/testsuite/g++.dg/template/conv22.C | 69 ++++++++++++++ 2 files changed, 151 insertions(+), 39 deletions(-) create mode 100644 gcc/testsuite/g++.dg/template/conv22.C diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 6992b5196fe..912bb6b5185 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -25174,6 +25174,31 @@ type_unification_real (tree tparms, return unify_success (explain_p); } +/* Subroutine of resolve_overloaded_unification and + resolve_nondeduced_context. FNS is a conversion operator overload set and + OPTYPE is the target type. Returns an overload set containing the + instantiated functions that match the target type. */ + +tree +resolve_conversion_function_id (tree fns, tree optype) +{ + tree overloads = NULL_TREE; + for (lkp_iterator iter (fns); iter; ++iter) + { + tree tmpl = *iter; + tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl); + tree targs = make_tree_vec (DECL_NTPARMS (tmpl)); + tree parm = DECL_CONV_FN_TYPE (DECL_TEMPLATE_RESULT (tmpl)); + if (unify (tparms, targs, parm, optype, UNIFY_ALLOW_NONE, false)) + continue; + tree fn = instantiate_template (tmpl, targs, tf_none); + if (!constraints_satisfied_p (fn)) + continue; + overloads = lookup_add (fn, overloads); + } + return overloads; +} + /* Subroutine of type_unification_real. Args are like the variables at the call site. ARG is an overloaded function (or template-id); we try deducing template args from each of the overloads, and if @@ -25193,6 +25218,7 @@ resolve_overloaded_unification (tree tparms, int good = 0; tree goodfn = NULL_TREE; bool addr_p; + tree optype = NULL_TREE; if (TREE_CODE (arg) == ADDR_EXPR) { @@ -25212,7 +25238,10 @@ resolve_overloaded_unification (tree tparms, /* Strip baselink information. */ if (BASELINK_P (arg)) - arg = BASELINK_FUNCTIONS (arg); + { + optype = BASELINK_OPTYPE (arg); + arg = BASELINK_FUNCTIONS (arg); + } if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) { @@ -25276,22 +25305,26 @@ resolve_overloaded_unification (tree tparms, not just the function on its own. */ return false; else - for (lkp_iterator iter (arg); iter; ++iter) - { - tree fn = *iter; - if (flag_noexcept_type) - maybe_instantiate_noexcept (fn, tf_none); - if (TREE_CODE (fn) == FUNCTION_DECL && !constraints_satisfied_p (fn)) - continue; - tree elem = TREE_TYPE (fn); - if (try_one_overload (tparms, targs, tempargs, parm, elem, - strict, sub_strict, addr_p, explain_p) - && (!goodfn || !same_type_p (goodfn, elem))) - { - goodfn = elem; - ++good; - } - } + { + if (optype) + arg = resolve_conversion_function_id (arg, optype); + for (lkp_iterator iter (arg); iter; ++iter) + { + tree fn = *iter; + if (flag_noexcept_type) + maybe_instantiate_noexcept (fn, tf_none); + if (TREE_CODE (fn) == FUNCTION_DECL && !constraints_satisfied_p (fn)) + continue; + tree elem = TREE_TYPE (fn); + if (try_one_overload (tparms, targs, tempargs, parm, elem, + strict, sub_strict, addr_p, explain_p) + && (!goodfn || !same_type_p (goodfn, elem))) + { + goodfn = elem; + ++good; + } + } + } /* [temp.deduct.type] A template-argument can be deduced from a pointer to function or pointer to member function argument if the set of @@ -25335,7 +25368,7 @@ resolve_overloaded_unification (tree tparms, tree resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain) { - tree expr, offset, baselink; + tree expr, offset, baselink, optype; bool addr; if (!type_unknown_p (orig_expr)) @@ -25345,6 +25378,7 @@ resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain) addr = false; offset = NULL_TREE; baselink = NULL_TREE; + optype = NULL_TREE; if (TREE_CODE (expr) == ADDR_EXPR) { @@ -25359,14 +25393,14 @@ resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain) if (BASELINK_P (expr)) { baselink = expr; + optype = BASELINK_OPTYPE (expr); expr = BASELINK_FUNCTIONS (expr); } + int good = 0; + tree goodfn = NULL_TREE; if (TREE_CODE (expr) == TEMPLATE_ID_EXPR) { - int good = 0; - tree goodfn = NULL_TREE; - /* If we got some explicit template args, we need to plug them into the affected templates before we try to unify, in case the explicit args will completely resolve the templates in question. */ @@ -25403,28 +25437,37 @@ resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain) } } } - if (good == 1) - { - expr = goodfn; - if (baselink) - expr = build_baselink (BASELINK_BINFO (baselink), - BASELINK_ACCESS_BINFO (baselink), - expr, BASELINK_OPTYPE (baselink)); - if (offset) - { - tree base - = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset, 0))); - expr = build_offset_ref (base, expr, addr, complain); - } - if (addr) - expr = cp_build_addr_expr (expr, complain); - return expr; - } - else if (good == 0 && badargs && (complain & tf_error)) + if (good == 0 && badargs && (complain & tf_error)) /* There were no good options and at least one bad one, so let the user know what the problem is. */ instantiate_template (badfn, badargs, complain); } + else if (optype) + { + expr = resolve_conversion_function_id (expr, optype); + if (OVL_SINGLE_P (expr)) + { + goodfn = OVL_FIRST (expr); + good = 1; + } + } + if (good == 1) + { + expr = goodfn; + if (baselink) + expr = build_baselink (BASELINK_BINFO (baselink), + BASELINK_ACCESS_BINFO (baselink), + expr, BASELINK_OPTYPE (baselink)); + if (offset) + { + tree base + = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset, 0))); + expr = build_offset_ref (base, expr, addr, complain); + } + if (addr) + expr = cp_build_addr_expr (expr, complain); + return expr; + } return orig_expr; } diff --git a/gcc/testsuite/g++.dg/template/conv22.C b/gcc/testsuite/g++.dg/template/conv22.C new file mode 100644 index 00000000000..7cc85abc8c3 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/conv22.C @@ -0,0 +1,69 @@ +// PR c++/122383 +// { dg-do compile { target c++20 } } + +struct A { + template<typename T> + operator T() { + return T(); + } +}; + +struct B { + operator int() { + return 0; + } + + template<typename T> + operator T() { + static_assert(false); + } +}; + +struct C { + template<typename T> + operator T() { + return T(); + } + + template<typename U> + operator U() requires(false) { + return U(); + } +}; + +struct D { + template<typename T> + operator T() { + static_assert(false); + } + + template<typename T, typename U> + operator T U::*() { + return 0; + } +}; + +template<typename R, typename C> +void deduce(R(C::*)()) {} + +template<typename R, typename C1, typename C2> +void deduce2(R C1::*(C2::*)()) {} + +void test() { + (void)&A::operator int; + auto a = &A::operator int; + deduce(&A::operator int); + + (void)&B::operator int; + auto b = &B::operator int; + deduce(&B::operator int); + + (void)&C::operator int; + auto c = &C::operator int; + deduce(&C::operator int); + + // (void)&D::operator int D::*; // TODO + auto d = &D::operator int D::*; + deduce(&D::operator int D::*); + deduce2(&D::operator int D::*); +} base-commit: b1987874feead5e98f1ea005bd1ce5ff515eda7a
