plugin.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <algorithm>
#include <iostream>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include <hilti/rt/3rdparty/ArticleEnumClass-v2/EnumClass.h>
 
#include <hilti/ast/ctor.h>
#include <hilti/ast/node.h>
#include <hilti/ast/type.h>
#include <hilti/base/logger.h>
#include <hilti/base/result.h>
#include <hilti/base/util.h>
#include <hilti/compiler/coercer.h>
#include <hilti/compiler/context.h>
 
namespace hilti {
 
class ASTContext;
class Context;
class Unit;
 
namespace type_unifier {
class Unifier;
}
 
struct Plugin {
    template<typename Result, typename... Args>
    using Hook = Result (*)(Args...);
 
    std::string component;
 
    int order = 0;
 
    hilti::rt::filesystem::path extension;
 
    std::vector<hilti::rt::filesystem::path> cxx_includes;
 
    Hook<std::vector<hilti::rt::filesystem::path>, Context*> library_paths = nullptr;
 
    Hook<bool, type_unifier::Unifier*, UnqualifiedType*> unify_type = nullptr;
 
    Hook<Result<declaration::Module*>, hilti::Builder*, std::istream&, const hilti::rt::filesystem::path&> parse =
        nullptr;
 
    Hook<Ctor*, Builder*, Ctor*, QualifiedType*, bitmask<CoercionStyle>> coerce_ctor = nullptr;
 
    Hook<QualifiedType*, Builder*, QualifiedType*, QualifiedType*, bitmask<CoercionStyle>> coerce_type = nullptr;
 
    Hook<void, Builder*, ASTRoot*> ast_init = nullptr;
 
    Hook<bool, Builder*, ASTRoot*> ast_build_scopes = nullptr;
 
    Hook<bool, Builder*, Node*> ast_resolve = nullptr;
 
    Hook<bool, Builder*, ASTRoot*> ast_validate_pre = nullptr;
 
    Hook<bool, Builder*, ASTRoot*> ast_validate_post = nullptr;
 
    Hook<bool, Node*, printer::Stream&> ast_print = nullptr;
 
    Hook<bool, const ID&, printer::Stream&> ast_print_id = nullptr;
 
    Hook<bool, Builder*, ASTRoot*> ast_transform = nullptr;
};
 
class PluginRegistry;
 
namespace plugin {
PluginRegistry& registry();
} // namespace plugin
 
class PluginRegistry {
public:
    PluginRegistry();
 
    const std::vector<Plugin>& plugins() const { return _plugins; }
 
    Result<std::reference_wrapper<const Plugin>> pluginForExtension(const hilti::rt::filesystem::path& ext) const;
 
    const Plugin& hiltiPlugin() const;
 
    template<typename PluginMember>
    bool hasHookFor(PluginMember hook) {
        for ( const auto& p : plugin::registry().plugins() ) {
            if ( p.*hook )
                return true;
        }
 
        return false;
    }
 
    bool supportsExtension(const hilti::rt::filesystem::path& ext) const { return pluginForExtension(ext).hasValue(); }
 
    auto supportedExtensions() const {
        return util::transform(_plugins, [](auto& p) { return p.extension; });
    }
 
    void register_(const Plugin& p);
 
private:
    std::vector<Plugin> _plugins;
};
 
namespace detail {
 
Plugin createHiltiPlugin();
 
} // namespace detail
 
} // namespace hilti