Can you perfectly forward expressions in C++23?

In C++23, it became easier to perfectly forward prvalues thanks to auto() or auto{}. With this new tool, is it now possible to form a FORWARD(e) expression for an expression e with the following requirements?

1. FORWARD(e) has the same type as e, disregarding reference qualifiers
2. if decltype(e) is an lvalue/rvalue reference, then FORWARD(e) is an lvalue/xvalue respectively
3. otherwise, FORWARD(e) has the same value category as e
4. no additional copying or moving may take place

We can do imperfect forwarding with std::forward already:

#define FORWARD(...) ::std::forward<decltype(__VA_ARGS__)>(__VA_ARGS__)

This preserves the type and converts references appropriately.
However, a prvalue will be turned into an xvalue, because std::forward returns an rvalue reference (i.e. FORWARD(e) is an xvalue after conversions).

As a consequence:

T x = T();          // copy elision because x is initialized to prvalue
T x = FORWARD(T()); // calls move constructor

Is it possible to do true perfect forwarding in C++, including preservation of prvalues?

You basically want FORWARD(e) to be e, except if e happens to name an rvalue reference variable, in which case you want move(e).

You can simply cast to the type of decltype((e)) (which if e is a prvalue, will be elided), except when e is an rvalue reference variable, since decltype((e)) will be an lvalue reference.

#include <type_traits>

template<typename IdType, typename ExprType>
using perfect_forward_cast = std::conditional_t<std::is_rvalue_reference_v<IdType>,
    IdType,
    ExprType
>;

#define FORWARD(...) ::perfect_forward_cast<decltype( __VA_ARGS__ ), decltype(( __VA_ARGS__ ))>( __VA_ARGS__ )

https://godbolt.org/z/WYehMxzPb

No.

Given E, we can now do auto(E), but that is always a prvalue. lvalues and xvalues are materialized into a prvalue.

We can also do static_cast<decltype(E)&&>(E) ^†, but that is always a glvalue. prvalues get materialized into an xvalue.

P0849, the proposal that gave us auto(E), had also originally proposed decltype(auto)(E). Such syntax would mean that:

• if E could be a prvalue, then decltype(auto)(E) would "perfect-forward" E, but would be kind of pointless since here E is already doing the right thing.
• if E could not be a prvalue (as in, E is the name of a function parameter that is a forwarding reference), then decltype(auto)(E) means the same thing as static_cast<decltype(E)&&>(E).

The latter would provide a way of doing forwarding without either the macro FWD(arg) or the C-style (Arg&&) arg cast that people tend to write. However, decltype(auto)(name) is both longer and also more cryptic than both of these other approaches, so it was dropped from the proposal.

Once you get to a function parameter, you no longer have a prvalue - there's no way to deduce the difference between an xvalue and a prvalue - so there's no real use I can think of to perfect forwarding that also handles prvalues, since you can just use the expression.

^†The correct way to implement forwarding is:

#define FORWARD(e) static_cast<decltype(e)&&>(e)

not

#define FORWARD(e) std::forward<decltype(e)>(e)

These mean the same thing, but the former avoids instantiating std::forward and some internal type traits there, so is faster to compile.

Yes, it is possible, and it doesn't require C++23.
If we can detect the value category of an expression in a macro, we can choose to return this expression from an IILE.
This will be subject to mandatory copy initialization, and preserve the prvalue category:

namespace detail {

enum class value_category {
    lvalue,
    xvalue,
    prvalue
};

template <typename T>
constexpr auto category_of(std::remove_reference_t<T>& t)
    -> std::integral_constant<value_category, value_category::lvalue>;

template <typename T>
constexpr auto category_of(std::remove_reference_t<T>&& t)
    -> std::integral_constant<value_category, (std::is_reference_v<T> ? value_category::xvalue : value_category::prvalue)>;

} // namespace detail

These helper functions are extremely similar to std::forward in that they can accept lvalues, xvalues, and prvalues.
Instead of returning an rvalue reference of xvalues and prvalues, we instead use these to detect what the value category is.

Now that we have a way of detecting it, we can define the actual FORWARD macro:

#define FORWARD(...) [&]() -> decltype(auto) { \
    constexpr auto c = decltype(::detail::category_of<decltype(__VA_ARGS__)>(__VA_ARGS__))::value; \
    if constexpr (c == ::detail::value_category::prvalue) { \
        return (__VA_ARGS__); \
    } \
    else { \
        return static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__); \
    } \
}()

Thanks to if constexpr and a deduced decltype(auto) return type, our IILE can sometimes return references and sometimes values, depending on the detected category.

This preserves types and value categories perfectly. See Compiler Explorer for a live demo.