ast-context.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <hilti/rt/types/integer.h>
 
#include <hilti/ast/declarations/module-uid.h>
#include <hilti/ast/forward.h>
#include <hilti/ast/node.h>
#include <hilti/base/logger.h>
#include <hilti/base/uniquer.h>
 
namespace hilti {
 
class ASTContext;
class Context;
class Driver;
struct Plugin;
 
namespace type {
struct Wildcard;
}
 
namespace detail::cfg {
class Cache;
}
 
Result<declaration::Module*> parseSource(Builder* builder, std::istream& in, const std::string& filename);
 
namespace ast {
 
namespace detail {
 
class DependencyTracker;
 
template<char Prefix>
class ContextIndex {
public:
    explicit ContextIndex(size_t index = 0) : _value(index) {}
 
    auto value() const { return _value; }
 
    auto str() const { return _value > 0 ? std::string(1, Prefix) + rt::to_string(_value) : std::string("-"); }
 
    explicit operator bool() const { return *this != None; }
 
    bool operator==(const ContextIndex& other) const { return _value == other._value; }
    bool operator!=(const ContextIndex& other) const { return _value != other._value; }
 
    ContextIndex(const ContextIndex& other) = default;
    ContextIndex(ContextIndex&& other) noexcept = default;
    ContextIndex& operator=(const ContextIndex& other) = default;
    ContextIndex& operator=(ContextIndex&& other) noexcept = default;
 
    static const ContextIndex None; 
private:
    rt::integer::safe<uint32_t> _value = 0; // safe integer to catch any uint32_t overflows
};
 
template<char Prefix>
inline std::string to_string(const hilti::ast::detail::ContextIndex<Prefix>& index) {
    return index.str();
}
 
template<char Prefix>
inline const ContextIndex<Prefix> ContextIndex<Prefix>::None{0};
 
template<char Prefix>
inline std::ostream& operator<<(std::ostream& out, const hilti::ast::detail::ContextIndex<Prefix>& index) {
    return out << index.str();
}
 
// Helper to sort declaration pointers by their canonical IDs.
struct DeclarationPtrCmp {
    bool operator()(const Declaration* a, const Declaration* b) const;
};
 
} // namespace detail
 
using DeclarationIndex = detail::ContextIndex<'D'>;
 
using TypeIndex = detail::ContextIndex<'T'>;
 
} // namespace ast
 
class ASTContext : public std::enable_shared_from_this<ASTContext> {
public:
    // Set of declarations ordered by their canonical IDs.
    using DeclarationSet = std::set<Declaration*, ast::detail::DeclarationPtrCmp>;
 
    ASTContext(Context* context);
 
    ~ASTContext();
 
    auto* compilerContext() const { return _context; }
 
    auto root() const { return _root.get(); }
 
    Result<declaration::module::UID> parseSource(Builder* builder,
                                                 const hilti::rt::filesystem::path& path,
                                                 std::optional<hilti::rt::filesystem::path> process_extension = {});
 
    Result<declaration::module::UID> importModule(Builder* builder,
                                                  const ID& id,
                                                  const ID& scope,
                                                  const hilti::rt::filesystem::path& parse_extension,
                                                  const std::optional<hilti::rt::filesystem::path>& process_extension,
                                                  std::vector<hilti::rt::filesystem::path> search_dirs);
 
    declaration::Module* newModule(Builder* builder, ID id, const hilti::rt::filesystem::path& process_extension);
 
    declaration::Module* module(const declaration::module::UID& uid) const {
        if ( auto m = _modules_by_uid.find(uid); m != _modules_by_uid.end() )
            return m->second;
        else
            return nullptr;
    }
 
    Result<Nothing> processAST(Builder* builder, Driver* driver);
 
    Driver* driver() const { return _driver; }
 
    std::set<declaration::module::UID> dependencies(const declaration::module::UID& uid, bool recursive = false) const;
 
    const DeclarationSet& dependentDeclarations(Declaration* n);
 
    void updateModuleUID(const declaration::module::UID& old_uid, const declaration::module::UID& new_uid);
 
    ast::DeclarationIndex register_(Declaration* decl);
 
    Declaration* lookup(ast::DeclarationIndex index); // must exists, otherwise internal error -> result is not null
 
    void replace(Declaration* old, Declaration* new_);
 
    ast::TypeIndex register_(UnqualifiedType* type);
 
    UnqualifiedType* lookup(ast::TypeIndex index);
 
    void replace(UnqualifiedType* old, UnqualifiedType* new_);
 
    ID uniqueCanononicalID(const ID& id) { return _canon_id_uniquer.get(id, false); }
 
    void dump(const hilti::logging::DebugStream& stream, const std::string& prefix) const;
 
    void dump(std::ostream& out, bool include_state) const;
 
    template<typename T, typename... Args>
    T* make(Args&&... args) {
        auto t = new T(std::forward<Args>(args)...);
        _nodes.emplace_back(std::unique_ptr<Node>(t));
        return t;
    }
 
    template<typename T, typename... Args>
    T* make(ASTContext* ctx, std::initializer_list<Node*> children, Args&&... args) {
        assert(ctx == this);
        auto t = new T(ctx, children, std::forward<Args>(args)...);
        _nodes.emplace_back(std::unique_ptr<Node>(t));
        return t;
    }
 
    template<typename T, typename... Args>
    T* make(ASTContext* ctx, type::Wildcard&& wildcard, std::initializer_list<Node*> children, Args&&... args) {
        assert(ctx == this);
        auto t = new T(ctx, std::forward<type::Wildcard>(wildcard), children, std::forward<Args>(args)...);
        _nodes.emplace_back(std::unique_ptr<Node>(t));
        return t;
    }
 
    void clearErrors(Node* node = nullptr);
 
    void clearScopes(Node* node = nullptr);
 
    Result<Nothing> collectErrors();
 
#ifndef NDEBUG
    void checkAST(bool finished = true) const;
#endif
 
    void garbageCollect();
 
    void clear();
 
    static constexpr unsigned int MaxASTIterationRounds = 100;
 
private:
    // The following methods implement the corresponding phases of AST processing.
 
    Result<declaration::module::UID> _parseSource(Builder* builder,
                                                  const hilti::rt::filesystem::path& path,
                                                  const ID& scope,
                                                  std::optional<hilti::rt::filesystem::path> process_extension = {});
    Result<Nothing> _init(Builder* builder, const Plugin& plugin);
    Result<Nothing> _buildScopes(Builder* builder, const Plugin& plugin);
    Result<Nothing> _resolve(Builder* builder, const Plugin& plugin);
    Result<Nothing> _resolveUnresolvedNodes(bool* modified, Builder* builder, const Plugin& plugin);
    Result<Nothing> _resolveRoot(bool* modified, Builder* builder, const Plugin& plugin);
    Result<Nothing> _validate(Builder* builder, const Plugin& plugin, bool pre_resolver);
    Result<Nothing> _transform(Builder* builder, const Plugin& plugin);
    Result<Nothing> _optimize(Builder* builder, detail::cfg::Cache* cfg_cache);
    Result<Nothing> _computeDependencies();
 
    // Adds a module to the AST. The module must not be part of any AST yet
    // (including the current one).
    declaration::module::UID _addModuleToAST(declaration::Module* module);
 
    // Dumps the AST to disk during AST processing, for debugging..
    void _saveIterationAST(const Plugin& plugin, const std::string& prefix, unsigned int round = 0);
 
    // Dumps the AST to disk during AST processing, for debugging..
    void _saveIterationAST(const Plugin& plugin, const std::string& prefix, const std::string& tag);
 
    // Dumps the AST to a debugging stream.
    void _dumpAST(const hilti::logging::DebugStream& stream,
                  const Plugin& plugin,
                  const std::string& prefix,
                  std::optional<unsigned int> round);
 
    // Dumps the AST to a debugging stream.
    void _dumpAST(std::ostream& stream,
                  const Plugin& plugin,
                  const std::string& prefix,
                  std::optional<unsigned int> round);
 
    // Dumps the accumulated state tables of the context to a debugging stream.
    void _dumpState(const logging::DebugStream& stream) const;
 
    // Dumps the accumulated state tables of the context to an output stream.
    void _dumpState(std::ostream& out) const;
 
    // Dump statistics about the AST to a debugging stream.
    void _dumpStats(const logging::DebugStream& stream, std::string_view tag);
 
    // Dumps the accumulated state tables of the context to a debugging stream.
    void _dumpDeclarations(const logging::DebugStream& stream, const Plugin& plugin);
 
    Context* _context = nullptr;               // compiler context
    std::vector<std::unique_ptr<Node>> _nodes; // all nodes allocated through the context; used by garbage collection
 
    node::RetainedPtr<ASTRoot> _root = nullptr; // root node of the AST
    bool _resolved = false;                     // true if `processAST()` has finished successfully
    Driver* _driver = nullptr;                  // pointer to compiler drive during `processAST()`, null outside of that
    util::Uniquer<ID> _canon_id_uniquer;        // Produces unique canonified IDs
    std::unique_ptr<ast::detail::DependencyTracker> _dependency_tracker; // records dependencies between declarations
 
    unsigned int _total_rounds = 0; // total number of rounds of AST processing
 
    std::unordered_map<declaration::module::UID, node::RetainedPtr<declaration::Module>>
        _modules_by_uid; // all known modules indexed by UID
 
    std::unordered_map<std::string, declaration::Module*>
        _modules_by_path; // all known modules indexed by path (retained by _by_uid)
    std::map<std::pair<ID, ID>, declaration::Module*>
        _modules_by_id_and_scope; // all known modules indexed by their ID and search scope (retained by _by_uid)
 
    std::vector<node::RetainedPtr<Declaration>>
        _declarations_by_index; // all registered declarations; vector position corresponds to their index
    std::vector<node::RetainedPtr<UnqualifiedType>>
        _types_by_index; // all registered types; vector position corresponds to their index
};
 
class ASTRoot : public Node {
public:
    static auto create(ASTContext* ctx) { return ctx->make<ASTRoot>(ctx); }
 
protected:
    ASTRoot(ASTContext* ctx) : Node(ctx, NodeTags, {}, Meta(Location("<root>"))) {}
 
    std::string _dump() const final;
 
    HILTI_NODE_0(ASTRoot, final);
};
 
} // namespace hilti
 
namespace std {
template<char Prefix>
struct hash<hilti::ast::detail::ContextIndex<Prefix>> {
    size_t operator()(hilti::ast::detail::ContextIndex<Prefix> x) const { return x.value().Ref(); }
};
} // namespace std