attribute.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <algorithm>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
#include <hilti/ast/expression.h>
#include <hilti/ast/forward.h>
#include <hilti/ast/node.h>
#include <hilti/base/util.h>
 
namespace hilti {
 
namespace attribute {
 
class Kind {
public:
    explicit Kind(std::string name) : _name(std::move(name)) { _register(); }
 
    Kind() = delete;
    Kind(const Kind& other) = default;
    Kind(Kind&& other) = default;
 
    ~Kind() = default; // not unregistering here, so that attribute remains known
 
    operator std::string() const { return _name; }
 
    Kind& operator=(const Kind& other) = default;
    Kind& operator=(Kind&& other) = default;
 
    bool operator==(const Kind& other) const { return _name == other._name; }
    bool operator!=(const Kind& other) const { return ! operator==(other); }
 
    // Returns a corresponding attribute kind iff the string matches to one of
    // the known attributes created so far. Otherwise throws an `out_of_range`
    // exception.
    static Kind fromString(const std::string_view& s) {
        if ( _known_attributes && _known_attributes->contains(std::string(s)) )
            return Kind(std::string(s));
        else
            throw std::out_of_range("unknown attribute kind: " + std::string(s));
    }
 
private:
    void _register();
 
    std::string _name = "<unset attribute>";
    static std::set<std::string>* _known_attributes;
};
 
inline bool isOneOf(const Kind& kind, std::initializer_list<Kind> kinds) {
    return std::ranges::find(kinds, kind) != kinds.end();
}
 
inline auto to_string(const Kind& kind) { return std::string(kind); }
 
inline std::ostream& operator<<(std::ostream& out, const Kind& x) {
    out << to_string(x);
    return out;
}
 
namespace kind {
inline auto from_string(const std::string_view& s) { return Kind::fromString(s); }
 
// In the following, we predefine all attributes that are part of the HILTI language.
 
const Kind AlwaysEmit("&always-emit");
const Kind Anchor("&anchor");
const Kind Anonymous("&anonymous");
const Kind Convert("&convert");
const Kind Cxxname("&cxxname");
const Kind CxxAnyAsPtr("&cxx-any-as-ptr");
const Kind Debug("&debug");
const Kind Default("&default");
const Kind HavePrototype("&have_prototype");
const Kind Internal("&internal");
const Kind NeededByFeature("&needed-by-feature");
const Kind NoEmit("&no-emit");
const Kind Nosub("&nosub");
const Kind OnHeap("&on-heap");
const Kind Optional("&optional");
const Kind Priority("&priority");
const Kind Public("&public");
const Kind RequiresTypeFeature("&requires-type-feature");
const Kind Static("&static");
 
} // namespace kind
} // namespace attribute
 
class Attribute : public Node {
public:
    const auto& kind() const { return _kind; }
 
    auto hasValue() const { return child(0) != nullptr; }
 
    Node* value() const { return child(0); }
 
    Result<Expression*> valueAsExpression() const;
 
    Result<std::string> valueAsString() const;
 
    Result<int64_t> valueAsInteger() const;
 
    Result<bool> coerceValueTo(Builder* builder, QualifiedType* dst);
 
    node::Properties properties() const final {
        auto p = node::Properties{{"tag", to_string(kind())}};
        return Node::properties() + std::move(p);
    }
 
    static auto create(ASTContext* ctx, const attribute::Kind& kind, Expression* v, const Meta& m = Meta()) {
        return ctx->make<Attribute>(ctx, {v}, kind, m);
    }
 
    static auto create(ASTContext* ctx, const attribute::Kind& kind, const Meta& m = Meta()) {
        return create(ctx, kind, nullptr, m);
    }
 
protected:
    Attribute(ASTContext* ctx, Nodes children, attribute::Kind kind, Meta m = Meta())
        : Node(ctx, NodeTags, std::move(children), std::move(m)), _kind(std::move(kind)) {}
 
    std::string _dump() const override;
 
    HILTI_NODE_0(Attribute, final);
 
private:
    attribute::Kind _kind;
};
 
class AttributeSet : public Node {
public:
    auto attributes() const { return children<Attribute>(0, {}); }
 
    Attribute* find(const attribute::Kind& kind) const;
 
    hilti::node::Set<Attribute> findAll(const attribute::Kind& kind) const;
 
    void add(ASTContext* ctx, Attribute* a) {
        addChild(ctx, a);
        // Combine this location with the attribute's location so this spans the range
        setMeta(meta().mergeLocation(a->location()));
    }
 
    void remove(const attribute::Kind& kind);
 
    operator bool() const { return ! attributes().empty(); }
 
    static auto create(ASTContext* ctx, const Attributes& attrs = {}, Meta m = Meta()) {
        return ctx->make<AttributeSet>(ctx, attrs, std::move(m));
    }
 
protected:
    explicit AttributeSet(ASTContext* ctx, Nodes children, Meta m = Meta())
        : Node(ctx, NodeTags, std::move(children), std::move(m)) {}
 
    AttributeSet(ASTContext* ctx, Meta m = Meta()) : Node(ctx, {node::tag::AttributeSet}, {}, std::move(m)) {}
 
    std::string _dump() const override;
 
    HILTI_NODE_0(AttributeSet, final);
};
 
} // namespace hilti
 
namespace std {
template<>
struct hash<hilti::attribute::Kind> {
    size_t operator()(const hilti::attribute::Kind& x) const { return std::hash<std::string>()(x); }
};
} // namespace std