Regression in formatting a type through a pointer using specialization

[rburchell]

It seems that after the fix for #2717 (8f8a1a0), it seems it is no longer possible to specialize formatter for a given pointer type:

error: static_assert failed due to requirement 'formattable_pointer' "Formatting of non-void pointers is disallowed."

Reproduced on godbolt here: https://godbolt.org/z/h3cWYYev8.

Though I notice that even just reverting that commit isn't quite enough, as the specialization doesn't seem to get used anymore. It certainly used to work in fmt 8.1.1 - I'm not quite sure when that broke.

Is this intentional? It seems like a pretty inconvenient behaviour change.

[vitaut]

Formatting of non-void pointers is intentionally disallowed. If you want to format a pointer cast it to void* or use fmt::ptr. Otherwise define a formatter for the type itself and dereference when formatting. Some earlier versions didn't diagnose this properly.

[rburchell]

@vitaut Can I ask why? It seems very unfriendly to shunt all the work of trying to safely dereference onto the individual fmt uses, rather than leaving it in one place (in the specialization).

Here's an example, which used to work just fine:

class MyClass
{
public:
    int thing = 42;
};

namespace fmt {

template <>
struct formatter<MyClass*>
{
    constexpr auto parse(format_parse_context& ctx)
    {
        return ctx.begin();
    }

    template <typename FormatContext>
    auto format(const MyClass* const value, FormatContext& ctx)
    {
        if (value) {
            return format_to(ctx.out(), "MyClass(this: {}, thing={})", (void*)value, value->thing);
        } else {
            return format_to(ctx.out(), "MyClass(this: nullptr)");
        }
    }
};

}

Test code (dbg is just my own light-weight wrapper to print using fmt, it's not really relevant):

    MyClass* m1 = nullptr;
    MyClass* m2 = new MyClass;
    dbg("test! {}", m1);
    dbg("test! {}", m2);

(Past) output:

test! MyClass(this: 0x0)
test! MyClass(this: 0x602000002630, thing=42)

If we do it your way, and dereference:

    dbg("test! {}", *m1);

... this will now immediately crash. It's easily fixed in this contrived case, sure, but imagine you're printing a tree node where you have multiple pointers to try output, that's going to get awkward pretty fast.

I suppose a benefit is that with a specialization on the pointer, you can't (easily?) use fmt without a pointer, but it was always trivial to get one:

MyClass m3;
dbg("test! {}", m3); // this won't compile
dbg("test! {}", &m3); // but this will

[vitaut]

It was an early design decision based on the fact that pointer formatting has a separate semantics from value formatting but unfortunately there was a regression in enforcing it. Basically the same reasoning as discussed in https://accu.org/journals/overload/17/89/wilson_1539/. You can achieve similar behavior via an adapter type which is the usual extension mechanism in {fmt}. So the recommended solution is to define a formatter specialization for MyClass and an adapter for MyClass* or generic set of classes which will give usage similar to the following:

MyClass m3;
dbg("test! {}", m3);
dbg("test! {}", ptr(&m3));