name.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <memory>
#include <string>
#include <utility>
 
#include <hilti/ast/ast-context.h>
#include <hilti/ast/declaration.h>
#include <hilti/ast/expression.h>
#include <hilti/ast/id.h>
#include <hilti/ast/type.h>
 
namespace hilti::expression {
 
class Name : public Expression {
public:
    const auto& id() const { return _id; }
 
    const auto& fullyQualifiedID() const { return _fqid; }
 
    Declaration* resolvedDeclaration() {
        if ( ! _resolved_declaration_index )
            return nullptr;
 
        return context()->lookup(_resolved_declaration_index);
    }
 
    auto resolvedDeclarationIndex() const { return _resolved_declaration_index; }
 
    QualifiedType* type() const final;
 
    void setResolvedDeclarationIndex(ASTContext* ctx, ast::DeclarationIndex index);
 
    void clearResolvedDeclarationIndex(ASTContext* ctx) {
        if ( ! _resolved_declaration_index )
            return;
 
        _resolved_declaration_index = ast::DeclarationIndex::None;
 
        clearChildren();
        addChild(ctx, QualifiedType::createAuto(ctx, meta()));
    }
 
    void setID(ID id) { _id = std::move(id); }
 
    void setFullyQualifiedID(ID id) { _fqid = std::move(id); }
 
    node::Properties properties() const final;
 
    static auto create(ASTContext* ctx, const hilti::ID& id, const Meta& meta = {}) {
        return ctx->make<Name>(ctx, {QualifiedType::createAuto(ctx, meta)}, id, meta);
    }
 
protected:
    Name(ASTContext* ctx, Nodes children, hilti::ID id, Meta meta)
        : Expression(ctx, NodeTags, std::move(children), std::move(meta)), _id(std::move(id)), _context(ctx) {}
 
    ASTContext* context() const { return _context; }
 
    HILTI_NODE_1(expression::Name, Expression, final);
 
private:
    hilti::ID _id;
    hilti::ID _fqid;
    ast::DeclarationIndex _resolved_declaration_index;
 
    ASTContext* _context;
};
 
} // namespace hilti::expression