[Clang] question about template argument deduction

[rherilier]

Hello,

While writing some code for the libsigc++ project, I faced a case with template code which needed to use #if/else/endif to make it build with gcc, clang and msvc.

I sadly fail to write a testcase without having libsigc++ as a dependency:

/**
 * to build:
 * * g++ -std=c++17 main.cpp `pkg-config sigc++-3.0 --cflags --libs`
 * * clang++ -std=c++17 main.cpp `pkg-config sigc++-3.0 --cflags --libs`
 */
#include <sigc++/sigc++.h>
#include <cstdio>

template<typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
inline sigc::connection
connect1(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj2::*fun)(T_arg...))
{
  printf("connect1<..., T_obj, T_obj2, T_arg...>\n");
  return signal.connect(sigc::mem_fun<T_return, T_obj, T_obj2, T_arg...>(obj, fun));
}

template<typename T_return, typename T_obj, typename... T_arg>
inline sigc::connection
connect2(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj::*fun)(T_arg...))
{
  printf("connect2<..., T_obj, T_arg...>\n");
  return signal.connect(sigc::mem_fun<T_return, T_obj, T_obj, T_arg...>(obj, fun));
}

struct foo
{
  void fun(int i) { printf("foo::fun(int %d)\n", i); }
  void fun(double d) { printf("foo::fun(double %f)\n", d); }
};

int main()
{
  sigc::signal<void(int)> s;
  foo f;

  connect1(s, f, &foo::fun); // build on gcc and msvc but not clang
  connect2(s, f, &foo::fun); // build on gcc and clang but not msvc

  s.emit(42);

  return 0;
}

and the error log is:

main.cpp:36:3: error: no matching function for call to 'connect1'
  connect1(s, f, &foo::fun); // build on gcc and msvc but not clang
  ^~~~~~~~
main.cpp:11:1: note: candidate template ignored: couldn't infer template argument 'T_obj2'
connect1(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj2::*fun)(T_arg...))
^
1 error generated.

Used GCC's versions are 13.3.0 and 14.2.0 while clang's versions are 16.0.6, 17.0.6, 18.1.8, and 19.1.0.

As gcc and msvc success to compile connect1(s, &foo::fun), could it be a limit in clang's template arguments deduction algorithm?

Thanks in advance

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (rherilier)

Hello,

While writing some code for the libsigc++ project, I faced a case with template code which needed to use #if/else/endif to make it build with gcc, clang and msvc.

I sadly fail to write a testcase without having libsigc++ as a dependency:

/**
 * to build:
 * * g++ -std=c++17 main.cpp `pkg-config sigc++-3.0 --cflags --libs`
 * * clang++ -std=c++17 main.cpp `pkg-config sigc++-3.0 --cflags --libs`
 */
#include <sigc++/sigc++.h>
#include <cstdio>

template<typename T_return, typename T_obj, typename T_obj2, typename... T_arg>
inline sigc::connection
connect1(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj2::*fun)(T_arg...))
{
  printf("connect1<..., T_obj, T_obj2, T_arg...>\n");
  return signal.connect(sigc::mem_fun<T_return, T_obj, T_obj2, T_arg...>(obj, fun));
}

template<typename T_return, typename T_obj, typename... T_arg>
inline sigc::connection
connect2(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj::*fun)(T_arg...))
{
  printf("connect2<..., T_obj, T_arg...>\n");
  return signal.connect(sigc::mem_fun<T_return, T_obj, T_obj, T_arg...>(obj, fun));
}

struct foo
{
  void fun(int i) { printf("foo::fun(int %d)\n", i); }
  void fun(double d) { printf("foo::fun(double %f)\n", d); }
};

int main()
{
  sigc::signal<void(int)> s;
  foo f;

  connect1(s, f, &foo::fun); // build on gcc and msvc but not clang
  connect2(s, f, &foo::fun); // build on gcc and clang but not msvc

  s.emit(42);

  return 0;
}

and the error log is:

main.cpp:36:3: error: no matching function for call to 'connect1'
  connect1(s, f, &foo::fun); // build on gcc and msvc but not clang
  ^~~~~~~~
main.cpp:11:1: note: candidate template ignored: couldn't infer template argument 'T_obj2'
connect1(sigc::signal<T_return(T_arg...)>& signal, T_obj& obj, T_return (T_obj2::*fun)(T_arg...))
^
1 error generated.

Used GCC's versions are 13.3.0 and 14.2.0 while clang's versions are 16.0.6, 17.0.6, 18.1.8, and 19.1.0.

As gcc and msvc success to compile connect1(s, &foo::fun), could it be a limit in clang's template arguments deduction algorithm?

Thanks in advance

[keinflue]

Clang is correct, see [temp.deduct.call]/6.2.

&foo::fun is an overload set that needs to be resolved. This is done by first performing trial template argument deduction for each candidate against T_return (T_obj2::*fun)(T_arg...) / T_return (T_obj::*fun)(T_arg...). This succeeds for both candidates. Therefore the parameter is considered a non-deduced context.

Because T_obj2 doesn't appear in any other parameter, you then have nothing to deduce T_obj2 from, failing the main template argument deduction. In the case of T_return, T_obj and T_arg..., these all appear in other parameters from which they can be deduced and with their deduced arguments substituted only one candidate for &foo::fun matches the signature T_return (T_obj::*fun)(T_arg...).

[keinflue]

The deduction for connect2 seems to work fine in MSVC as well btw. See https://godbolt.org/z/edTo54hEG.

[rherilier]

Clang is correct, see [temp.deduct.call]/6.2.

Sorry, I didn't intend to be offensive.

The comments about MSVC can be ignored: the build failure with MSVC comes from elsewhere (even if it implies those functions).

But your answer does not really help me...

&foo::fun is an overload set that needs to be resolved. This is done by first performing trial template argument deduction for each candidate against T_return (T_obj2::*fun)(T_arg...) / T_return (T_obj::*fun)(T_arg...). This succeeds for both candidates. Therefore the parameter is considered a non-deduced context.

If the deduction is only done at the parameter level, I would agree. But at the templates' instantiation level, T_return and T_args... can be deduced from sigc::signal<T_return(T_arg...)>, leaving only one possible candidate for T_return (T_obj2::*fun)(T_arg...) or T_return (T_obj::*fun)(T_arg...).

Because T_obj2 doesn't appear in any other parameter, you then have nothing to deduce T_obj2 from, failing the main template argument deduction.

So, if I understand correctly, you're writing that T_obj2 can not be deduced from &foo::fun because there is no other occurrence of T_obj2 to confirm that foo is its lone possible value?

Thank you in advance

[keinflue]

Sorry, I didn't intend to be offensive.

And I had no intention of sounding offended or anything like that. Sorry if it came across that way. I was just stating my conclusion regarding the standard-conformance up-front in as few words as possible. I am also just an interested user of LLVM/Clang that happened to read your question and I try to help out answering questions where it is possible (which I hope is ok). I am not a contributor to the project.

But at the templates' instantiation level, T_return and T_args... can be deduced from sigc::signal<T_return(T_arg...)>, leaving only one possible candidate for T_return (T_obj2::*fun)(T_arg...) or T_return (T_obj::*fun)(T_arg...).

That's true, but according to the language rules in the ISO C++ standard deduction is always done individually for every parameter/argument pair. Even if it was possible to look at multiple of them in correlation to figure out a working set of template arguments, that's not how the standard specifies it.

So, if I understand correctly, you're writing that T_obj2 can not be deduced from &foo::fun because there is no other occurrence of T_obj2 to confirm that foo is its lone possible value?

The standard says that, because we cannot decide which foo you mean by only looking at the &foo::fun argument/parameter pair, we give up on making any deductions from that pair at all. And then there is no remaining argument/parameter pair which can tell us anything about T_obj2, causing the deduction failure.

[rherilier]

And I had no ... contributor to the project.

OK, I thought that I had stepped on a landmine.

So, that's the spec that define how the deduction must work... I'm quite curious about the initial reason but I don't plan to dig in the pre-98 era. By the way, C++26 does not seem to soften that constraint (and I don't think it would change in the medium/long term).

It seems that the lone solution I have is to reorder the template parameters as <T_obj2, T_obj, T_return, T_arg...>, and to write connect1<foo>(...) to make clang accept it but it kill the magic of template functions.

Thanks for the explanation and your time.