assert.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <utility>
 
#include <hilti/ast/expression.h>
#include <hilti/ast/statement.h>
#include <hilti/ast/type.h>
 
namespace hilti::statement {
 
namespace assert {
struct Exception {};
} // namespace assert
 
class Assert : public Statement {
public:
    auto expression() const { return child<::hilti::Expression>(0); }
    auto exception() const { return child<UnqualifiedType>(1); }
    auto message() const { return child<::hilti::Expression>(2); }
    bool expectException() const { return _expect_exception; }
 
    node::Properties properties() const final {
        auto p = node::Properties{{"expect_exception", _expect_exception}};
        return Statement::properties() + std::move(p);
    }
 
    void setExpression(ASTContext* ctx, hilti::Expression* c) { setChild(ctx, 0, c); }
 
    static auto create(ASTContext* ctx, hilti::Expression* expr, hilti::Expression* msg = nullptr, Meta meta = {}) {
        return ctx->make<Assert>(ctx, {expr, nullptr, msg}, false, std::move(meta));
    }
 
    static auto create(ASTContext* ctx, assert::Exception /*unused*/, hilti::Expression* expr, UnqualifiedType* excpt,
                       hilti::Expression* msg = nullptr, Meta meta = {}) {
        return ctx->make<Assert>(ctx, {expr, excpt, msg}, true, std::move(meta));
    }
 
protected:
    Assert(ASTContext* ctx, Nodes children, bool expect_exception, Meta meta)
        : Statement(ctx, NodeTags, std::move(children), std::move(meta)), _expect_exception(expect_exception) {}
 
    HILTI_NODE_1(statement::Assert, Statement, final);
 
private:
    bool _expect_exception;
};
 
} // namespace hilti::statement