node.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <algorithm>
#include <cinttypes>
#include <iterator>
#include <map>
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <hilti/ast/doc-string.h>
#include <hilti/ast/forward.h>
#include <hilti/ast/id.h>
#include <hilti/ast/meta.h>
#include <hilti/ast/node-range.h>
#include <hilti/ast/node-tag.h>
#include <hilti/ast/scope.h>
#include <hilti/ast/visitor-dispatcher.h>
 
#define __HILTI_NODE_COMMON_final(NS, CLASS)                                                                           \
    ::hilti::Node* _clone(::hilti::ASTContext* ctx) const final { return ctx->make<CLASS>(*this); }
 
#define __HILTI_NODE_COMMON_override(NS, CLASS)
 
#define __HILTI_NODE_COMMON(NS, CLASS, override_)                                                                      \
    friend class ::NS::builder::NodeBuilder;                                                                           \
    friend class hilti::ASTContext;                                                                                    \
    friend class hilti::Node;                                                                                          \
    std::string _typename() const override { return hilti::util::typename_(*this); }                                   \
    __HILTI_NODE_COMMON_##override_(NS, CLASS)
 
#define __HILTI_NODE_0(NS, CLASS, override_)                                                                           \
    __HILTI_NODE_COMMON(NS, CLASS, override_)                                                                          \
                                                                                                                       \
    static constexpr uint16_t NodeLevel = 1;                                                                           \
    static constexpr ::hilti::node::Tag NodeTag = ::hilti::node::tag::CLASS;                                           \
    static constexpr ::hilti::node::Tags NodeTags = {::hilti::node::tag::Node, ::hilti::node::tag::CLASS};
 
#define HILTI_NODE_0(CLASS, override_)                                                                                 \
    __HILTI_NODE_0(hilti, CLASS, override_)                                                                            \
                                                                                                                       \
    void dispatch(::hilti::visitor::Dispatcher& v) override_ {                                                         \
        v(static_cast<::hilti::Node*>(this));                                                                          \
        v(this);                                                                                                       \
    }
 
#define __HILTI_NODE_1(NS, CLASS, BASE, override_)                                                                     \
    __HILTI_NODE_COMMON(NS, CLASS, override_)                                                                          \
                                                                                                                       \
    static constexpr uint16_t NodeLevel = 2;                                                                           \
    static constexpr ::hilti::node::Tag NodeTag = ::hilti::node::tag::CLASS;                                           \
    static constexpr ::hilti::node::Tags NodeTags = {::hilti::node::tag::Node, ::hilti::node::tag::BASE,               \
                                                     ::hilti::node::tag::CLASS};
 
#define HILTI_NODE_1(CLASS, BASE, override_)                                                                           \
    __HILTI_NODE_1(hilti, CLASS, BASE, override_)                                                                      \
                                                                                                                       \
    void dispatch(::hilti::visitor::Dispatcher& v) override_ {                                                         \
        v(static_cast<::hilti::Node*>(this));                                                                          \
        v(static_cast<BASE*>(this));                                                                                   \
        v(this);                                                                                                       \
    }
 
#define __HILTI_NODE_2(NS, CLASS, BASE1, BASE2, override_)                                                             \
    __HILTI_NODE_COMMON(NS, CLASS, override_)                                                                          \
                                                                                                                       \
    static constexpr uint16_t NodeLevel = 3;                                                                           \
    static constexpr ::hilti::node::Tag NodeTag = ::hilti::node::tag::CLASS;                                           \
    static constexpr ::hilti::node::Tags NodeTags = {::hilti::node::tag::Node, ::hilti::node::tag::BASE2,              \
                                                     ::hilti::node::tag::BASE1, ::hilti::node::tag::CLASS};
 
#define HILTI_NODE_2(CLASS, BASE1, BASE2, override_)                                                                   \
    __HILTI_NODE_2(hilti, CLASS, BASE1, BASE2, override_)                                                              \
                                                                                                                       \
    void dispatch(::hilti::visitor::Dispatcher& v) override_ {                                                         \
        v(static_cast<::hilti::Node*>(this));                                                                          \
        v(static_cast<BASE1*>(this));                                                                                  \
        v(static_cast<BASE2*>(this));                                                                                  \
        v(this);                                                                                                       \
    }
 
namespace hilti {
namespace builder {
class NodeBuilder;
}
 
namespace node {
 
namespace detail {
Node* deepcopy(ASTContext* ctx, Node* n, bool force);
} // namespace detail
 
template<typename T>
T* deepcopy(ASTContext* ctx, T* n, bool force = false) {
    if ( ! n )
        return nullptr;
 
    return detail::deepcopy(ctx, n, force)->template as<T>();
}
 
using PropertyValue = std::variant<bool, const char*, double, int, int64_t, unsigned int, uint64_t, std::string, ID,
                                   std::optional<uint64_t>>;
 
inline std::string to_string(const PropertyValue& v) {
    struct Visitor {
        auto operator()(bool s) { return std::string(s ? "true" : "false"); }
        auto operator()(const char* s) { return util::escapeUTF8(s); }
        auto operator()(double d) { return util::fmt("%.6f", d); }
        auto operator()(int i) { return util::fmt("%d", i); }
        auto operator()(int64_t i) { return util::fmt("%" PRId64, i); }
        auto operator()(const std::string& s) { return util::escapeUTF8(s); }
        auto operator()(const ID& id) { return id.str(); }
        auto operator()(const std::optional<uint64_t>& u) { return u ? util::fmt("%" PRIu64, *u) : "<not set>"; }
        auto operator()(unsigned int u) { return util::fmt("%u", u); }
        auto operator()(uint64_t u) { return util::fmt("%" PRIu64, u); }
    };
 
    return std::visit(Visitor(), v);
};
 
enum class ErrorPriority {
    High = 3,   
    Normal = 2, 
    Low = 1,    
    NoError = 0 
};
 
inline bool operator<(ErrorPriority x, ErrorPriority y) {
    return static_cast<std::underlying_type_t<ErrorPriority>>(x) <
           static_cast<std::underlying_type_t<ErrorPriority>>(y);
}
 
struct Error {
    std::string message;                            
    Location location;                              
    std::vector<std::string> context;               
    ErrorPriority priority = ErrorPriority::Normal; 
    // Comparison considers message & location, so that we can unique based
    // on those two.
    bool operator<(const Error& other) const {
        return std::tie(message, location) < std::tie(other.message, other.location);
    }
};
 
using Properties = std::map<std::string, node::PropertyValue>;
 
template<typename T>
class RetainedPtr {
public:
    RetainedPtr() = default;
    RetainedPtr(T* n) : _node(n) { retain(); }
    RetainedPtr(const RetainedPtr& other) : _node(other._node) { retain(); }
    RetainedPtr(RetainedPtr&& other) noexcept : _node(other._node) {
        other._node = nullptr;
        // reuse the other's retain
    }
 
    ~RetainedPtr() { release(); }
 
    RetainedPtr& operator=(const RetainedPtr& other) {
        if ( this == &other )
            return *this;
 
        release();
        _node = other._node;
        retain();
        return *this;
    }
 
    RetainedPtr& operator=(RetainedPtr&& other) noexcept {
        if ( this == &other )
            return *this;
 
        release();
        _node = other._node;
        other._node = nullptr;
        // reuse the other's retain
        return *this;
    }
 
    void reset() {
        release();
        _node = nullptr;
    }
 
    T* operator->() const { return _node; }
    T& operator*() const { return *_node; }
    explicit operator bool() const { return _node != nullptr; }
    operator T*() const { return _node; }
 
    T* get() const { return _node; }
 
private:
    void retain() {
        if ( _node )
            _node->retain();
    }
 
    void release() {
        if ( _node ) {
            _node->release();
            _node = nullptr;
        }
    }
 
    T* _node = nullptr;
};
 
} // namespace node
 
class Node {
public:
    virtual ~Node();
 
    node::Tag nodeTag() const {
        // Get the last non-zero tag. The last element(s) may be unset
        for ( auto it = _node_tags.rbegin(); it != _node_tags.rend(); it++ ) {
            if ( *it != 0 )
                return *it;
        }
 
        return 0;
    }
 
    bool hasParent() const { return _parent; }
 
    Node* parent(int i = 1) const {
        if ( i == 0 )
            return nullptr;
 
        Node* p = _parent;
        for ( ; p && i > 1; i-- )
            p = p->_parent;
 
        return p;
    }
 
    template<typename T>
    T* parent() const {
        if ( ! _parent )
            return nullptr;
        else if ( _parent->isA_<T>() )
            return static_cast<T*>(_parent);
        else
            return _parent->parent<T>();
    }
 
    auto pathLength() const {
        size_t i = 0;
        for ( auto n = parent(); n; i++, n = n->parent() )
            ;
 
        return i;
    }
 
 
    const auto& meta() const { return *_meta; }
 
    const auto& location() const { return _meta->location(); }
 
    void setMeta(Meta m) { _meta = Meta::get(std::move(m)); }
 
    auto scope() const { return _scope.get(); }
 
    auto getOrCreateScope() {
        if ( ! _scope )
            _scope = std::make_unique<Scope>();
 
        return _scope.get();
    }
 
    void clearScope() { _scope.reset(); }
 
    Result<std::pair<Declaration*, ID>> lookupID(const ID& id, const std::string_view& what) const;
 
    virtual bool inheritScope() const { return true; }
 
    std::string typename_() const { return _typename(); }
 
    uintptr_t identity() const { return reinterpret_cast<uintptr_t>(this); }
 
    const auto& children() const { return _children; }
 
    template<typename T>
    T* child(unsigned int i) const {
        if ( i >= _children.size() )
            return nullptr;
 
        return _children[i] ? _children[i]->as<T>() : nullptr;
    }
 
    template<typename T>
    T* childTryAs(unsigned int i) const {
        if ( i >= _children.size() )
            return nullptr;
 
        return _children[i] ? _children[i]->tryAs<T>() : nullptr;
    }
 
    Node* child(unsigned int i) const {
        if ( i >= _children.size() )
            return nullptr;
 
        return _children[i];
    }
 
    template<typename T>
    auto children(int begin, std::optional<int> end) const {
        end = _normalizeEndIndex(begin, end);
        if ( end )
            return hilti::node::Range<T>(_children.begin() + begin, _children.begin() + *end);
        else
            return hilti::node::Range<T>();
    }
 
    template<typename T>
    auto children(int begin, std::optional<int> end) {
        end = _normalizeEndIndex(begin, end);
        if ( end )
            return hilti::node::Range<T>(_children.begin() + begin, _children.begin() + *end);
        else
            return hilti::node::Range<T>();
    }
 
    template<typename T>
    node::Set<T> childrenOfType() const {
        typename hilti::node::Set<T> n;
        for ( auto c = _children.begin(); c != _children.end(); c = std::next(c) ) {
            if ( ! *c )
                continue;
 
            if ( auto t = (*c)->tryAs<T>() )
                n.push_back(t);
        }
 
        return n;
    }
 
    Node* sibling(Node* n) const {
        auto i = std::find(_children.begin(), _children.end(), n);
        if ( i == _children.end() )
            return nullptr;
 
        while ( true ) {
            if ( ++i == _children.end() )
                return nullptr;
 
            if ( *i )
                return *i;
        }
    }
 
    void addChild(ASTContext* ctx, Node* n) {
        if ( ! n ) {
            _children.emplace_back(nullptr);
            return;
        }
 
        n = _newChild(ctx, n);
 
        if ( ! n->location() && _meta->location() )
            n->_meta = _meta;
 
        _children.emplace_back(n);
        n->_parent = this;
        n->retain();
    }
 
    void addChildren(ASTContext* ctx, const Nodes& children) {
        for ( auto&& n : children )
            addChild(ctx, n);
    }
 
    void removeChild(Node* n) {
        if ( ! n )
            return;
 
        if ( auto i = std::find(_children.begin(), _children.end(), n); i != _children.end() ) {
            (*i)->_parent = nullptr;
            (*i)->release();
            _children.erase(i);
        }
    }
 
    void removeChildren(int begin, std::optional<int> end) {
        end = _normalizeEndIndex(begin, end);
        if ( ! end )
            return;
 
        auto end_ = _children.begin() + *end;
        for ( auto i = _children.begin() + begin; i < end_; i++ ) {
            if ( *i ) {
                (*i)->_parent = nullptr;
                (*i)->release();
            }
        }
 
        _children.erase(_children.begin() + begin, end_);
    }
 
    void setChild(ASTContext* ctx, size_t idx, Node* n) {
        if ( auto old = _children[idx] ) {
            old->_parent = nullptr;
            old->release();
        }
 
        if ( ! n ) {
            _children[idx] = nullptr;
            return;
        }
 
        n = _newChild(ctx, n);
        n->_parent = this;
        n->retain();
 
        if ( ! n->location() && _meta->location() )
            n->_meta = _meta;
 
        _children[idx] = n;
    }
 
    void replaceChildren(ASTContext* ctx, const Nodes& children);
 
    void replaceChild(ASTContext* ctx, Node* old, Node* new_);
 
    template<typename T>
    bool isA() const {
#ifndef NDEBUG
        _checkCast<T>(false);
#endif
        return (T::NodeLevel < _node_tags.size() && T::NodeTag == _node_tags[T::NodeLevel]);
    }
 
    template<typename T>
    bool isA_() const {
        return (T::NodeLevel < _node_tags.size() && T::NodeTag == _node_tags[T::NodeLevel]);
    }
 
    template<typename T>
    T* as() const {
#ifndef NDEBUG
        _checkCast<T>(true);
#endif
        return static_cast<const T*>(this);
    }
 
    template<typename T>
    T* as() {
#ifndef NDEBUG
        _checkCast<T>(true);
#endif
        return static_cast<T*>(this);
    }
 
    template<typename T>
    const T* tryAs() const {
#ifndef NDEBUG
        _checkCast<T>(false);
#endif
 
        if ( isA<T>() )
            return static_cast<const T*>(this);
        else
            return nullptr;
    }
 
    template<typename T>
    T* tryAs() {
#ifndef NDEBUG
        _checkCast<T>(false);
#endif
        if ( isA<T>() )
            return static_cast<T*>(this);
        else
            return nullptr;
    }
 
    template<typename T>
    T* tryAs_() {
        if ( isA_<T>() )
            return static_cast<T*>(this);
        else
            return nullptr;
    }
 
    void print(std::ostream& out, bool compact, bool user_visible) const;
 
    std::string print() const;
 
    std::string printRaw() const;
 
    operator std::string() const { return print(); }
 
    std::string dump() const;
 
    std::string renderSelf(bool include_location = true) const;
 
    void addError(std::string msg, std::vector<std::string> context = {}) {
        addError(std::move(msg), location(), std::move(context));
    }
 
    void addError(std::string msg, node::ErrorPriority priority, std::vector<std::string> context = {}) {
        addError(std::move(msg), location(), priority, std::move(context));
    }
 
    void addError(std::string msg, const Location& l, std::vector<std::string> context = {}) {
        addError(std::move(msg), location(), node::ErrorPriority::Normal, std::move(context));
    }
 
    void addError(std::string msg, Location l, node::ErrorPriority priority, std::vector<std::string> context = {}) {
        node::Error error;
        error.message = std::move(msg);
        error.location = std::move(l);
        error.context = std::move(context);
        error.priority = priority;
 
        if ( ! _errors )
            _errors = std::make_unique<std::vector<node::Error>>();
 
        _errors->emplace_back(std::move(error));
    }
 
    bool hasErrors() const { return _errors && ! _errors->empty(); }
 
    const auto& errors() const {
        static std::vector<node::Error> no_errors;
        return _errors ? *_errors : no_errors;
    }
 
    void clearErrors() { _errors.reset(); }
 
    void clearChildren();
 
    void retain() {
        assert(_ref_count != -1); // dtor sets ref count to -1
        ++_ref_count;
    }
 
    void release() {
        assert(_ref_count != -1); // dtor sets ref count to -1
        assert(_ref_count > 0);
        --_ref_count;
    }
 
    bool isRetained() const { return _ref_count > 0; }
 
    virtual node::Properties properties() const { return {}; }
 
    virtual void dispatch(visitor::Dispatcher& v) = 0;
 
    virtual std::string_view branchTag() const { return ""; }
 
    Node& operator=(const Node& other) = delete;
    Node& operator=(Node&& other) noexcept = delete;
 
    static constexpr uint16_t NodeLevel = 0; // distance from `Node` in the inheritance hierarchy
    static constexpr ::hilti::node::Tag NodeTag = ::hilti::node::tag::Node;     // this class' node tag
    static constexpr ::hilti::node::Tags NodeTags = {::hilti::node::tag::Node}; // this class' inheritance path
 
protected:
    Node(ASTContext* ctx, node::Tags node_tags, Nodes children, Meta meta)
        : _node_tags(node_tags), _meta(Meta::get(std::move(meta))) {
        assert(! _node_tags.empty());
        _children.reserve(children.size());
        for ( auto&& c : children ) {
            if ( c ) {
                c = _newChild(ctx, c);
                assert(! c->_parent);
                c->_parent = this;
                c->retain();
            }
 
            _children.push_back(c);
        }
    }
 
    Node(ASTContext* ctx, node::Tags node_tags, Meta meta) : _node_tags(node_tags), _meta(Meta::get(std::move(meta))) {
        assert(! _node_tags.empty());
    }
 
    Node(Node&& other) = default;
 
    Node(const Node& other) : _node_tags(other._node_tags) {
        _meta = other._meta;
        _parent = nullptr;
 
        // Don't copy children. We can't copy the pointers because that would
        // produce messed up parent pointers. And we can't deep copy here
        // because we don't have the context. That's all ok because this isn't
        // public anyways; to run this one needs to go through Node's cloning
        // functions.
    }
 
    virtual std::string _typename() const { return util::typename_(*this); }
 
    virtual Node* _clone(ASTContext* ctx) const = 0; // shallow copy
 
    virtual std::string _dump() const { return ""; }
 
private:
    friend Node* node::detail::deepcopy(ASTContext* ctx, Node* n, bool force);
 
    // Prepares a node for being added as a child, deep-copying it if it
    // already has a parent.
    static Node* _newChild(ASTContext* ctx, Node* child);
 
    // Do Python-style array indexing with negative indices.
    std::optional<int> _normalizeEndIndex(int begin, std::optional<int> end) const {
        if ( end && *end < 0 )
            end = static_cast<int>(_children.size()) + *end;
 
        if ( ! end )
            end = _children.size();
 
        if ( end > begin )
            return end;
        else {
            // Some versions of GCC diagnose a maybe uninitialized variable
            // here. Since we just return an unset optional, this should not be
            // possible. (pragmas copied from intrusive-ptr.h, where there's a
            // similar issue.)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wunknown-warning-option"
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
            return {};
#pragma GCC diagnostic pop
        }
    }
 
#ifndef NDEBUG
    // Checks casts for common mistakes.
    //
    // @param enforce_success if true, we'll abort if the cast fails due to a type mismatch
    template<typename T>
    void _checkCast(bool enforce_success) const {
        // Ensure that our RTTI information yields the same `isA<>` result as
        // the C++ type system.
        auto ours = (T::NodeLevel < _node_tags.size() && T::NodeTag == _node_tags[T::NodeLevel]);
        auto theirs = (dynamic_cast<const T*>(this) != nullptr);
 
        if ( ours != theirs ) {
            std::cerr << util::fmt("internal error: Node::_checkCast() RTTI mismatch\n")
                      << util::fmt("isA<T=%s>(%s) -> %s but dynamic_cast() says %s\n", typeid(T).name(), _typename(),
                                   ours ? "true" : "false", theirs ? "true" : "false")
                      << util::fmt("T::type_level=%" PRIu16 " T::node_tags={%s} this->types={%s}\n", T::NodeLevel,
                                   node::to_string(T::NodeTags), node::to_string(_node_tags));
            abort();
        }
 
        if ( enforce_success && ! ours ) {
            std::cerr << util::fmt("internal error: unexpected type, want %s but have %s\n", util::typename_<T>(),
                                   _typename());
            abort();
        }
 
        // Debugging helper: If `this` is a `QualifiedType`, it's virtually
        // always wrong to try casting it into a class derived from
        // `UnqualifiedType`. Most likely that's meant to instead cast
        // `this->type()`. We abort here to make debugging such problems
        // easier.
        if ( std::is_base_of_v<UnqualifiedType, T> && ! std::is_same_v<UnqualifiedType, T> )
            _checkCastBackend();
    }
#endif
 
    // Helper for _checkCast() to spot unexpected casts from `QualifiedType`.
    void _checkCastBackend() const;
 
    const node::Tags _node_tags; // inheritance path for the node
    int64_t _ref_count = 0;  // number of pins currently held on the node; -1 is a special value set by the dtor to mark
                             // an already destroyed node (for debugging)
    Node* _parent = nullptr; // parent node inside the AST, or null if not yet added to an AST
    Nodes _children;         // set of child nodes
    const Meta* _meta;       // meta information associated with the node; returned and managed by Meta::get()
 
    std::unique_ptr<Scope> _scope = nullptr; // scope associated with the node, or null if non (i.e., scope is empty)
    std::unique_ptr<std::vector<node::Error>> _errors; // errors associated with the node, or null if none
};
 
namespace node {
 
class WithUniqueID {
public:
    ID uniqueID() const { return _id; }
 
    node::Properties properties() const { return {{"unique_id", _id}}; }
 
    WithUniqueID() = delete;
    WithUniqueID(const WithUniqueID& other) = default;
    WithUniqueID(WithUniqueID&& other) noexcept = default;
    ~WithUniqueID() = default;
 
    WithUniqueID& operator=(const WithUniqueID& other) = default;
    WithUniqueID& operator=(WithUniqueID&& other) noexcept = default;
 
protected:
    WithUniqueID(const char* prefix) : _id(util::fmt("%s_%" PRIu64, prefix, _id_counter++)) {}
 
private:
    ID _id;
 
    inline static uint64_t _id_counter = 0;
};
 
class WithDocString {
public:
    const std::optional<DocString>& documentation() const { return _doc; }
 
    void clearDocumentation() { _doc.reset(); }
 
    void setDocumentation(DocString doc) {
        if ( doc )
            _doc = std::move(doc);
        else
            _doc.reset();
    }
 
private:
    std::optional<DocString> _doc;
};
 
class CycleDetector {
public:
    void recordSeen(const Node* n) { _seen.insert(n); }
    bool haveSeen(const Node* n) const { return _seen.find(n) != _seen.end(); }
    void clear() { _seen.clear(); }
 
private:
    std::unordered_set<const Node*> _seen;
};
 
template<typename T>
Nodes flatten(std::vector<T> t) {
    Nodes v;
    v.reserve(t.size());
    for ( auto it = std::make_move_iterator(t.begin()); it != std::make_move_iterator(t.end()); ++it )
        v.emplace_back(*it);
 
    return v;
}
 
template<typename T>
Nodes flatten(hilti::node::Range<T> t) {
    Nodes v;
    v.reserve(t.size());
    for ( const auto& i : t )
        v.emplace_back(std::move(i));
 
    return v;
}
 
template<typename T = Node*>
inline Nodes flatten(Node* n) {
    return {n};
}
 
template<typename T>
inline Nodes flatten(T* n) {
    return {std::move(n)};
}
 
template<typename T = std::nullptr_t>
inline Nodes flatten(std::nullptr_t) {
    return {nullptr};
}
 
inline Nodes flatten() { return Nodes(); }
 
template<typename T, typename... Ts, std::enable_if_t<(0 != sizeof...(Ts))>* = nullptr>
Nodes flatten(T t, Ts... ts) {
    return util::concat(std::move(flatten(std::move(t))), flatten(std::move(ts)...));
}
 
template<typename X, typename F>
auto filter(const hilti::node::Range<X>& x, F f) {
    hilti::node::Set<X> y;
    for ( const auto& i : x ) {
        if ( f(i) )
            y.push_back(i);
    }
 
    return y;
}
 
template<typename X, typename F>
auto filter(const hilti::node::Set<X>& x, F f) {
    hilti::node::Set<X> y;
    for ( const auto& i : x ) {
        if ( f(i) )
            y.push_back(i);
    }
 
    return y;
}
 
template<typename X, typename F>
auto transform(const hilti::node::Range<X>& x, F f) {
    using Y = std::invoke_result_t<F, X*>;
    std::vector<Y> y;
    y.reserve(x.size());
    for ( const auto& i : x )
        y.push_back(f(i));
 
    return y;
}
 
template<typename X, typename F>
auto transform(const hilti::node::Set<X>& x, F f) {
    using Y = std::invoke_result_t<F, X*>;
    std::vector<Y> y;
    y.reserve(x.size());
    for ( const auto& i : x )
        y.push_back(f(i));
 
    return y;
}
 
} // namespace node
 
inline std::ostream& operator<<(std::ostream& out, const Node& n) {
    n.print(out, true, true);
    return out;
}
 
} // namespace hilti
 
inline hilti::node::Properties operator+(hilti::node::Properties p1, hilti::node::Properties p2) {
    p1.merge(std::move(p2));
    return p1;
}