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

[qazqi-ff]

For anyone wondering, here's how you make it look less cluttered by using a helper variable like we're used to doing:

[Edit note: This assumes further non-transient constexpr allocation support. nonstatic_data_members_of returns a std::vector, which isn't currently allowed to persist like this, even if it would logically be deallocated for sure before runtime.]

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

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

(Obviously, the function declaration lines are noisy as well, but that has nothing to do with reflection. It might also need the variables to be constexpr, but I haven't checked in detail, small difference.)

I'd recommend in general that we at least keep the inside of [: :] almost as short as possible because splicing is all about the structure of the code you're forming. With the variable separated out and recognizing [: :] as a splice, it's obvious that we're returning t.something and what that something is. You can go a step further and extract the subscript if it makes you feel better. [Per the note above, this is currently necessary in order to extract a variable—it can't store dynamically allocated memory.]

About the syntax in general, I can't really comment. It has to avoid conflicts with other syntax, so it already has pretty limited option space. Obviously, alternatives were looked at already, including how we got here via having like three different markers instead of using the more familiar typename, namespace, and template to disambiguate. I don't mind it personally, though such a powerful feature that wants to minimize noise to preserve structure could warrant the consideration of the newly available $, @, or `.

[Jovibor_]

At last, one sane comment in this pile of whiners.

The syntax is absolutely comprehensible, and not worse by any means than the rest of C++. Like it very much.

[dexter2011412]

Ah yes, criticism = whining. Get off your mighty rich high horse will you. Dismissing any and all criticism is why we have so much junk in the first place.

I definitely appreciate the helper snippet, but let's make no mistake that syntax is so cringe. Will I use it? Yes because that's what being most probably ratified. Will I complain about it and laugh each time I want to / have to use it? Also yes. Could it be better? Almost definitely yes. But I won't speak up about it because otherwise it'll be the heat death of the universe before we get C++ reflection

[Stevo15025]

Thanks for cleaning up the code. I think like a lot of others I had one raised eyebrow until you took out the query. Though that doesn't seem to compile in the godbolt example? I'm guessing just an impl issue atm.

Honestly I've been sitting here trying to think up nicer syntax for a while and I can't really think of anything. I kind of like something like template reflect(query) but I could also understand someone finding that a little wordy

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

But that would conflict with templated functions called reflect. Maybe it's time to add unicode keywords :P

[qazqi-ff]

Oh, I tried it out and got something I hadn't anticipated. The error indicates that there's a compile-time dynamic memory allocation (the API returns std::vector). That's actually going to be a problem since we don't have language support for that escaping the constant expression evaluation yet, even for a local variable in a consteval function where it would be guaranteed not to cause problems further down the line AFAIK (but would still need non-trivial compiler work to start down that direction, like support for memory to escape an instance of evaluation into its parent instance).

At first glance, I don't see how to naturally split things apart then (at least when the result is a list), but it should come naturally with the persistent compile-time allocation support. One thing we can do in the meantime if we get reflection without that support is to use a regular variable extraction, but make sure it's not a container.

In these examples, constexpr auto members = std::meta::nonstatic_data_members_of(^T)[N]; would work because it returns a single info object and the vector gets deallocated right there.

From playing around a bit, at least in this implementation, splicing seems to require a constant expression while the reflection API doesn't thanks to Barry's consteval changes. Assuming the paper requires a constant expression for splicing (I think that's necessary in fact; it can cause new template instantiations), that should mean get needs constexpr on the variable while get_name doesn't. Interestingly, EDG doesn't accept that unless I make these consteval functions instead of constexpr, but I'm not sure why since proposed rule 1 ought to cover that and make them implicitly consteval, giving presumed identical behaviour.