как генерировать ошибку компиляции при вызове виртуального метода

#include <iostream>
#include <memory>
#include <stack>
 
struct Json {
private:
    using handler_t = std::unique_ptr<struct CommandHandler>;
    std::stack<handler_t> cmd_handlers;
    handler_t &get_current(){
        return cmd_handlers.top();
    }
    void pop_current() {
        cmd_handlers.pop();
    }
    std::ostream & out;
public:
    explicit Json(std::ostream & o) : out(o) {}
 
    void output(std::string_view str){
        out << str;
    }
 
    void set_current(std::unique_ptr<struct CommandHandler> new_handler){
        if (cmd_handlers.empty())
            throw std::logic_error("JSON allows only one top-level value");
        cmd_handlers.push(std::move(new_handler));
    }
 
    Json &Number(int64_t);
    Json &String(std::string_view);
    Json &Boolean(bool);
    Json &Null();
    Json &Key(std::string_view);
    Json &BeginArray();
    Json &EndArray();
    Json &BeginObject();
    Json &EndObject();
};
 
#define ERROR_MESSAGE {throw std::logic_error("Invalid continuation"); }
 
struct CommandHandler {
public:
    virtual void Number(Json *, int64_t) ERROR_MESSAGE;
    virtual void String(Json *, std::string_view) ERROR_MESSAGE;
    virtual void Boolean(Json *, bool) ERROR_MESSAGE;
    virtual void Null(Json *) ERROR_MESSAGE;
    virtual void Key(Json *, std::string_view) ERROR_MESSAGE;
    virtual void BeginArray(Json *) ERROR_MESSAGE;
    virtual void EndArray(Json *) ERROR_MESSAGE;
    virtual void BeginObject(Json *) ERROR_MESSAGE;
    virtual void EndObject(Json *) ERROR_MESSAGE;
};
 
Json &Json::Number(int64_t num) {
    get_current()->Number(this, num);
    return *this;
}
 
Json &Json::String(std::string_view str) {
    get_current()->String(this, str);
    return *this;
}
 
Json &Json::Boolean(bool b) {
    get_current()->Boolean(this, b);
    return *this;
}
 
Json &Json::Null() {
    get_current()->Null(this);
    return *this;
}
 
Json &Json::Key(std::string_view str) {
    get_current()->Key(this, str);
    return *this;
}
 
Json &Json::EndArray() {
    get_current()->EndArray(this);
    pop_current();
    return *this;
}
 
Json &Json::EndObject() {
    get_current()->EndObject(this);
    pop_current();
    return *this;
}
 
struct StringHandler : public CommandHandler {
//...
};
 
struct ArrayHandler : public CommandHandler {
//...
};
 
Json &Json::BeginArray() {
    set_current(std::make_unique<ArrayHandler>());
    get_current()->BeginArray(this);
    return *this;
}
 
struct ObjectHandler : public CommandHandler {
//...
};
 
Json &Json::BeginObject() {
    set_current(std::make_unique<ObjectHandler>());
    get_current()->BeginObject(this);
    return *this;
}
 
struct KeyHandler : public CommandHandler {
//...
};

#include <iostream>
 
class AbstractBase
{
public:
    void method();
};
 
class Derived: public AbstractBase
{
public:
    void method()= delete;
};
 
class Derived2: public AbstractBase
{
public:
    void method(){ std::cout << "Derived2::method\n";}
};
 
int main()
{
    Derived der;
   // der.method(); // error: use of deleted function ‘void Derived::method()
    Derived2 der2;
    der2.method();
}