declaration.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <string>
#include <utility>
 
#include <hilti/ast/ast-context.h>
#include <hilti/ast/forward.h>
#include <hilti/ast/id.h>
#include <hilti/ast/node.h>
 
namespace hilti {
 
namespace declaration {
 
enum class Linkage {
    Export,  
    Init,    
    PreInit, 
    Private, 
    Public,  
    Struct,  
};
 
namespace detail {
constexpr util::enum_::Value<Linkage> Linkages[] = {
    {.value = Linkage::Export, .name = "exported"},
    {.value = Linkage::Init, .name = "init"},
    {.value = Linkage::PreInit, .name = "preinit"},
    {.value = Linkage::Private, .name = "private"},
    {.value = Linkage::Public, .name = "public"},
    {.value = Linkage::Struct, .name = "struct"},
};
} // namespace detail
 
constexpr auto to_string(Linkage f) { return util::enum_::to_string(f, detail::Linkages); }
 
namespace linkage {
constexpr auto from_string(std::string_view s) { return util::enum_::from_string<Linkage>(s, detail::Linkages); }
} // namespace linkage
} // namespace declaration
 
class Declaration : public Node, public node::WithDocString {
public:
    ~Declaration() override;
 
    const auto& id() const { return _id; }
 
    auto linkage() const { return _linkage; }
 
    auto isPublic() const {
        return _linkage == declaration::Linkage::Public || _linkage == declaration::Linkage::Export;
    }
 
    const auto& fullyQualifiedID() const { return _fqid; }
 
    const auto& canonicalID() const { return _canonical_id; }
 
    auto declarationIndex() const { return _declaration_index; }
 
    void setID(const ID& id) {
        _id = id;
        _fqid = {}, _canonical_id = {};
    }
 
    void setLinkage(declaration::Linkage linkage) { _linkage = linkage; }
 
    void setFullyQualifiedID(ID id) { _fqid = std::move(id); }
 
    void setCanonicalID(ID id) { _canonical_id = std::move(id); }
 
    virtual std::string_view displayName() const = 0;
 
    node::Properties properties() const override {
        auto p = node::Properties{{"id", _id},
                                  {"linkage", declaration::to_string(_linkage)},
                                  {"declaration", to_string(_declaration_index)},
                                  {"fqid", _fqid},
                                  {"canonical-id", _canonical_id}};
 
        return Node::properties() + std::move(p);
    }
 
    Declaration(const Declaration& other) : Node(other), node::WithDocString(other) {
        _id = other._id;
        _linkage = other._linkage;
        // Do not copy computed state, we'll want to recompute that eventually.
    }
 
    Declaration(Declaration&& other) = default;
 
    Declaration& operator=(const Declaration& other) = delete;
    Declaration& operator=(Declaration&& other) = delete;
 
protected:
    friend class ASTContext;
 
    Declaration(ASTContext* ctx,
                node::Tags node_tags,
                Nodes children,
                ID id,
                declaration::Linkage linkage,
                Meta meta = {})
        : Node(ctx, node_tags, std::move(children), std::move(meta)), _id(std::move(id)), _linkage(linkage) {}
 
    // For the AST context to set the declaration index.
    void setDeclarationIndex(ast::DeclarationIndex index) {
        assert(index);
        _declaration_index = index;
    }
 
    std::string _dump() const override;
 
    HILTI_NODE_0(Declaration, override);
 
private:
    ID _id;
    declaration::Linkage _linkage;
 
    ast::DeclarationIndex _declaration_index; // index registered by the context
    ID _fqid;                                 // computed during AST processing
    ID _canonical_id;                         // computed during AST processing
};
 
} // namespace hilti