C++20 source_location to replace macro to multi-parameter variadic template

Question

Can this be made to display the line number of the actual call site, like the macro does ?

#include <iostream>
#include <type_traits>
#include <source_location>
#include <cassert>
using namespace std;

namespace myLib{

template<typename Enumt, typename... Ts> // alert bad calls, throw
constexpr void setValsF(const unsigned line, Ts const&... args){
  cout << "line #"<<line<<": illegal call to setVals()\n";
  assert(is_enum_v<Enumt>);
}

template<class... Enumt, class = common_type_t<Enumt...> > 
requires conjunction_v<is_enum<Enumt>...>
constexpr void setValsF(const unsigned line, Enumt&... vals){
  cout << "line #"<<line<<": legal call to setVals()\n";
}
 
}// myLib

int main(){

  enum enumVals : short { a = 0, b, c, count };
  
  // #define setVals(...) myLib::setValsF<enumVals>(__LINE__ __VA_OPT__(,__VA_ARGS__))
  constexpr auto setVals = [](auto&&... args) {  
    myLib::setValsF<enumVals>(source_location::current().line(), args...); };
  
  setVals(a,b); // legal
  setVals(b,"text"); // illegal
}

run

.. keeping a nice simple API ( setVals(a,b) ), that is.

It would work :

• with a defaulted argument to the function template, but for the parameter pack. Couldn't figure a deduction guide in the presence of more than one template parameter.
• or if current() was the default constructor to source_location !

I resorted to runtime handling of bad calls (to certain APIs) as a courtesy to my library users, as my very specific insult is wayyy nicer than the indecipherable blob the compiler vomits.

Answer 1

Expanding on my comment, as requested by the OP.

Piotr Skotnicki's accepted answer to How to use source_location in a variadic template function? introduces an helper class and a deduction guide:

template <typename... Ts>
struct debug
{    
   debug( Ts&&... ts
        , const std::source_location& loc = >std::source_location::current());
};

// The deduction guide forces the deduction of the pack, "separating"
// it from the default parameter.
template <typename... Ts>
debug(Ts&&...) -> debug<Ts...>;

int main()
{
   debug(5, 'A', 3.14f, "foo");
}

Here, though, something else needs to be passed. My proposal is to inject the requirements as a template parameter before the pack.

#include <concepts>
#include <iostream>
#include <source_location>

template <typename R, typename... Ts>
struct debug
{    
  debug( R&& req      // <- A requirement that the pack ts must fulfill.
       , Ts&&... ts
       , std::source_location const& loc = std::source_location::current() )
  {
    std::cout << "line #" << loc.line() << ": "
              << ( req(ts...) ? "valid call\n" : "invalid call\n" );
  }
};

// We don't need to differentiate the first parameter of the pack, here.
template <typename... Args>
debug(Args&&...) -> debug<Args...>;

int main()
{
  enum enumVals : short { a = 0, b, c, count };
  
  // Since C++20 we can have templated lambdas. Here I don't need named parameters,
  // but I need named types to use std::same_as in the fold expression.
  constexpr auto all_enums = []<typename... Ts>(Ts&&...) {
    return ( ... and std::same_as<std::remove_cvref_t<Ts>, enumVals> );
  };

  debug(all_enums, a, b);   // -> line #31: valid call
  debug(all_enums, b, 1);   // -> line #32: invalid call
}

This is not as terse as setVals(a,b), in OP's code, but seems to work¹ as intended.

---

^{1) Note that this works with gcc and clang(trunk) (as noted by Ted Lyngmo), but not with clang15: https://godbolt.org/z/zxxMTs4Kj}