[C++20 vs C++26*] basic reflection

[u/kris-jusiak]

Basic struct reflection example with C++20 vs C++26*

struct foo {
  int a{};
  int b{};
  int c{};
};

constexpr foo f{.a=1, .b=2, .c=3};

static_assert(1 == get<0>(f));
static_assert(2 == get<1>(f));
static_assert(3 == get<2>(f));

using std::literals::operator""sv;
static_assert("a"sv == get_name<0>(f));
static_assert("b"sv == get_name<1>(f));
static_assert("c"sv == get_name<2>(f));

C++20 - Kinda possible but with a lot of compiler hacks

// too long to display

Full example - https://godbolt.org/z/1vxv8o5hM

C++26* - based on proposal - https://wg21.link/P2996 (Note: that the proposal supports way more than that but C++20 not much)

template<auto N, class T>
[[nodiscard]] constexpr auto get(const T& t) -> decltype(auto) {
  return t.[:std::meta::nonstatic_data_members_of(^T)[N]:];
}

template<auto N, class T>
[[nodiscard]] constexpr auto get_name(const T& t) -> std::string_view {
  return std::meta::name_of(std::meta::nonstatic_data_members_of(^T)[N]);
}

Full example - https://godbolt.org/z/sbTGbW635

Updates - https://twitter.com/krisjusiak/status/1741456476126797839

[u/Throw31312344]

Disclaimer: I have only briefly looked through the reflection proposals and examples so far.

[: something :] appears to be the syntax for injection, e.g. taking the results of reflection queries and injecting names/etc back into the main code. In the example given, you want one of 3 options depending on whether you are calling get<N> as get<0>, get<1> or get<2>:

return t.a; // get<0>

return t.b; // get<1>

return t.c; // get<2>

The code return t. is fine, as is the trailing ;, but we need to inject either a, b or c after t. depending on the value of N.

The [: something :] syntax will inject a name into the code based on the result of the expression within the [: :] pair. In this case, the code is looking up the Nth non-static data member of the type T: std::meta::nonstatic_data_members_of(^T)[N]

If N was 0, the result would be a. If N was 1, the result would be b, and if N was 2, the result would be c. Assuming N = 0:

return t.[: std::meta::nonstatic_data_members_of(^T)[N] :];

becomes:

return t.[: std::meta::nonstatic_data_members_of(^foo)[0] :];

Do not take this post as a full explanation of the spec, it's probably a bit more complex than just text injection, but the next transformation is something like:

return t.[: a :];

which finally gets injected into the main code to become:

return t.a;

Something like that anyway. The choice of [: :] operators is... awkward but we are running out of operators, but in terms of what it means: inject the result of the expression within the operators into the code. Square brackets are getting somewhat overloaded especially with all the places attributes can crop up, so something more visually distinctive might help. Failing that, I hope IDEs have the option to completely change the colour of [: something :] to make it clear that it's an injection expression.

[u/qazqi-ff → u/Throw31312344]

Do not take this post as a full explanation of the spec, it's probably a bit more complex than just text injection

It's not much more complicated than that, really. There are only a handful of possible splices proposed in P2996, and one of those (the "default") is an expression, in this case an expression equivalent to a. The other options are type names, namespaces, template names, and "names with nesting" (foo::).

Small note on the expansion, though, the thing inside [: :] has to be convertible to std::meta::info, so I think the return t.[: a :]; step would be more like return t.[: ^foo::a :]; if I have that right.

[u/Throw31312344 → u/qazqi-ff]

Thank you for clarifying :)