However, the bigger issue with that code is that it can easily stop working with a simple refactor. Consider:

    void foo(std::unique_ptr<int> ptr) {}
    void bar(std::unique_ptr<int>&& ptr) {}

    int main()
    {
        std::unique_ptr<int> p1{new int{1}};
        std::unique_ptr<int> p2{new int{2}};

        foo(std::move(p1));
        assert(p1 == nullptr);

        bar(std::move(p2));
        assert(p2 != nullptr);
     }

[0]: overload (5) https://en.cppreference.com/w/cpp/memory/unique_ptr/unique_p...

This means calling operator bool on your unique_ptr ought to be fine, because the unique_ptr still has a valid state (you don't know what that state is, it's unspecified, but it's guaranteed to not be radioactive on mere contact. It has to be a valid unspecified state.)

In other words, I guess you shouldn't oughta do that generally, but I was fine with it being used there, and it did its job.