lookup.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_PARSER_LOOKUP_HPP
#define CEL_PARSER_LOOKUP_HPP
 
#include <array>
#include <cel/parser/diagnostic.hpp>
#include <cel/runtime.hpp>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <utility>
#include <vector>

 
namespace cel {
 
namespace parser_detail {
enum class lookup_selector;
enum class scope_selection;
struct lookup_access;
} // namespace parser_detail
using scope_callback =
    std::function<bool(std::string_view, dyn_segment&, std::size_t, source_span)>;
using operation_emitter = std::function<void(dyn_segment&, source_span)>;

namespace parser_detail {
struct name_hash {
    using is_transparent = void; 

    std::size_t operator()(std::string_view name) const noexcept {
        return std::hash<std::string_view>{}(name);
    }
};
} // namespace parser_detail

class op_lookup {
    friend struct parser_detail::lookup_access;
    struct operation {
        std::vector<value_type> inputs; 
        value_type result;              
        operation_emitter emit;         
    };
    struct function_binding {
        value_type marker;      
        operation_emitter emit; 
    };
    template <class T>
    using names = std::unordered_map<std::string, T, parser_detail::name_hash, std::equal_to<>>;
    names<value_type> types_;
    names<std::vector<operation>> operations_;
    names<std::vector<operation>> structural_;
    names<std::vector<operation>> builtins_;
    names<function_binding> functions_;
    std::unordered_map<std::type_index, std::string> marker_names_;
    std::vector<scope_callback> libraries_;
    std::vector<scope_callback> scopes_;

    static void insert(names<std::vector<operation>>& destination,
                       std::string_view name,
                       std::span<const value_type> inputs,
                       value_type result,
                       operation_emitter emit);
    static bool emit_match(const names<std::vector<operation>>& registrations,
                           std::string_view name,
                           dyn_segment& builder,
                           std::size_t arity,
                           source_span span);
    bool scope_match(std::string_view name,
                     dyn_segment& builder,
                     std::size_t arity,
                     source_span span,
                     parser_detail::scope_selection selection) const;
    bool direct_match(std::string_view name,
                      dyn_segment& builder,
                      std::size_t arity,
                      source_span span,
                      parser_detail::scope_selection selection) const;
    void install_builtins();
    template <class R, class... A, class F>
    void builtin(std::string_view name, F&& callback) {
        const std::array<value_type, sizeof...(A)> inputs{native_type<A>()...};
        insert(builtins_, name, inputs, native_type<R>(),
               [callback = std::forward<F>(callback)](dyn_segment& builder, source_span) {
                   builder.template op<R, A...>(callback);
               });
    }
    void insert_type(std::string_view name, value_type type);
    void insert_function(std::string_view name, value_type marker, operation_emitter emit);

    void push_scope(scope_callback callback);
    void pop_scope();
    std::vector<scope_callback> isolate_scopes();
    void restore_scopes(std::vector<scope_callback> saved);
    void apply(std::string_view name,
               dyn_segment& builder,
               std::size_t arity,
               source_span span,
               parser_detail::lookup_selector selector,
               parser_detail::scope_selection selection) const;
    void apply_cast(std::string_view target, dyn_segment& builder, source_span span) const;
 
public:
    std::optional<value_type> find_type(std::string_view name) const;
    op_lookup();
    op_lookup(const op_lookup&) = delete;
    op_lookup& operator=(const op_lookup&) = delete;
    op_lookup(op_lookup&&) noexcept = default;
    op_lookup& operator=(op_lookup&&) noexcept = default;
    // [knowledge] Keep registries noncopyable: shared mutable callback captures are not
    // independent value copies, even when their std::function wrappers can be copied.
    template <class T>
    void register_type(std::string_view name) {
        if constexpr (!detail::native_leaf<T>) {
            throw std::invalid_argument("named leaf registration requires an opaque leaf");
        } else {
            auto type = value_type::leaf<T>();
            if (!type.compatible_with(native_type<T>()))
                throw std::invalid_argument("named leaf registration requires an opaque leaf");
            insert_type(name, std::move(type));
        }
    }

    void register_record(std::string_view name, std::span<const record_field> fields);
    void register_operation(std::string_view name,
                            std::span<const value_type> inputs,
                            value_type result,
                            operation_emitter emit);
    void register_structural_op(std::string_view name,
                                std::span<const value_type> inputs,
                                value_type result,
                                operation_emitter emit);
    template <class R, class... A, class F>
    requires(!std::is_void_v<R> && requires(dyn_segment & b, F&& callback) {
        b.template op<R, A...>(std::forward<F>(callback));
    }) void register_op(std::string_view name, F&& callback) {
        const std::array<value_type, sizeof...(A)> inputs{native_type<A>()...};
        auto owned = std::make_shared<const std::decay_t<F>>(std::forward<F>(callback));
        register_operation(name, inputs, native_type<R>(),
                           [owned = std::move(owned)](dyn_segment& builder, source_span) {
                               builder.template op<R, A...>([owned](A&&... arguments) -> R {
                                   return std::invoke(*owned, std::move(arguments)...);
                               });
                           });
    }

    template <class M>
    void register_function(std::string_view name, M&& marker) {
        using marker_type = std::decay_t<M>;
        if constexpr (!detail::native_leaf<marker_type>) {
            throw std::invalid_argument("function markers require an opaque leaf");
        } else {
            const auto type = value_type::leaf<marker_type>();
            auto owned = value::from<marker_type>(std::forward<M>(marker));
            if (!type.compatible_with(owned.type()))
                throw std::invalid_argument("function markers require an opaque leaf");
            insert_function(name, type,
                            [owned = std::move(owned)](dyn_segment& builder, source_span) {
                                builder.just(owned);
                            });
        }
    }

    void push_library_scope(scope_callback callback);
};

} // namespace cel
#endif