Compiler Explorer

Source code

#include <meta>
#include <ranges>
#include <cassert>
#include <algorithm>
#include <stdexcept>

// to store fixed string in template argument
template <size_t N> struct fixed_string: std::array<char, N> {
    using super = std::array<char, N>;
    template <size_t... Idx> consteval fixed_string(const char * in, std::index_sequence<Idx...>) noexcept: super{in[Idx]...} { }
    consteval fixed_string(const char (&in)[N+1]) noexcept: super{fixed_string(in, std::make_index_sequence<N>())} { }

constexpr operator std::string_view() const noexcept {
        return {this->data(), this->size()};
    }
};

template <size_t N> fixed_string(const char (&)[N]) -> fixed_string<N-1>;

// extract all member functions of `T` (namespace / type) named `name`
consteval auto named_functions_of(std::meta::info context, std::string_view name, std::meta::access_context acc = std::meta::access_context::unprivileged()) {
    return std::meta::members_of(context, acc) 
    | std::views::filter([=](std::meta::info i) { 
        return 
            (is_function(i) || is_function_template(i)) 
            && has_identifier(i) 
            && identifier_of(i) == name; 
    });
}

namespace hana {

// return member function pointer of member function info
template <std::meta::info Member> static constexpr auto member_ptr_helper = &[: Member :];
consteval auto member_function_pointer_of(std::meta::info f) {
    if (is_function(f) && is_class_member(f) && !is_static_member(f)) {
        return substitute(^^member_ptr_helper, {reflect_constant(f)});
    } else {
        throw new std::invalid_argument{"not a member function"};
    }
}

// template specialisation so we can go around missing `return_type_of` and `parameters_of`
template <auto F> struct function_ptr;

// simple free function
template <typename R, typename... Args, bool NoExcept, R(*F)(Args...) noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(Args... args) noexcept(NoExcept) {
        return F(std::forward<Args>(args)...);
    }
};

// member function
template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
    static constexpr R operator()(T && obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) & noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) && noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(T && obj, Args... args) noexcept(NoExcept) {
        return (std::move(obj).*F)(std::forward<Args>(args)...);
    }
};

// const member function
template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) const noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(const T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) const & noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(const T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) const && noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(const T && obj, Args... args) noexcept(NoExcept) {
        return (std::move(obj).*F)(std::forward<Args>(args)...);
    }
};

// volatile member function
template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) volatile noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(volatile T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) volatile & noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(volatile T & obj, Args... args) noexcept(NoExcept) {
        return (obj.*F)(std::forward<Args>(args)...);
    }
};

template <typename R, typename T, typename... Args, bool NoExcept, R(T::*F)(Args...) volatile && noexcept(NoExcept)> struct function_ptr<F> {
    static constexpr R operator()(volatile T && obj, Args... args) noexcept(NoExcept) {
        return (std::move(obj).*F)(std::forward<Args>(args)...);
    }
};

template <std::meta::info F> struct function_template_ptr {
    template <typename... Args> static constexpr bool is_valid = requires(Args... args) {
        template [: F :](args...);
    };

template <typename... Args> static constexpr bool is_valid_noexcept = requires(Args... args) {
        { template [: F :](args...) } noexcept;
    };

template <typename... Args> requires (is_valid<Args...>) static constexpr decltype(auto) operator()(Args && ... args) noexcept(is_valid_noexcept<Args...>) {
        return template [: F :](std::forward<Args>(args)...);
    }
};

template <std::meta::info F> struct member_function_template_ptr {
    template <typename Obj, typename... Args> static constexpr bool is_valid = requires(Obj obj, Args... args) {
        obj.template [: F :](args...);
    };

template <typename Obj, typename... Args> static constexpr bool is_valid_noexcept = requires(Obj obj, Args... args) {
        { obj.template [: F :](args...) } noexcept;
    };

template <typename Obj, typename... Args> requires (is_valid<Obj, Args...>) static constexpr decltype(auto) operator()(Obj && obj, Args && ... args) noexcept(is_valid_noexcept<Obj, Args...>) {
        return std::forward<Obj>(obj).template [: F :](std::forward<Args>(args)...);
    }
};

template <std::meta::info F> struct unknown_target {
    // need to keep it here, so `using Overloads::operator...` later will work
    template <typename... Args> static void operator()(Args && ...) noexcept requires(false) {
        // never called anyway
    }
};

consteval auto build_overload(std::meta::info f) {
    if (is_function(f)) {
        if (is_static_member(f) || is_namespace(parent_of(f))) {
            return substitute(^^function_ptr, {f});
        }
        return substitute(^^function_ptr, {hana::member_function_pointer_of(f)});
    } else if (is_function_template(f)) {
        if (is_static_member(f) || is_namespace(parent_of(f))) {
            return substitute(^^function_template_ptr, {reflect_constant(f)});
        }
        return substitute(^^member_function_template_ptr, {reflect_constant(f)});
    }
    return substitute(^^unknown_target, {reflect_constant(f)}); // sink for unknown stuff
}

// take all overloads together
template <typename... Overloads> struct overloads: Overloads... {
    using Overloads::operator()...;
    static constexpr size_t size = sizeof...(Overloads);
};

// empty overload set which will be always an error
template <> struct overloads<> {

};

// we can join overload sets
template <typename... Lhs, typename... Rhs> consteval auto operator+(overloads<Lhs...>, overloads<Rhs...>) noexcept {
    return overloads<overloads<Lhs...>, overloads<Rhs...>>{}; // not really nice, it should be flatten
    // but later we can have even priorities
}

// this gives us an overload set from specified context of all functions named `name`
consteval auto build_overload_set(std::meta::info context, std::string_view name){
    const auto functions = define_static_array(named_functions_of(context, name)  | std::views::transform(build_overload));
    if (functions.empty()) {
        throw std::invalid_argument("overload set must be non empty");
    }
    return substitute(^^overloads, functions);
};

// this performs ADL-like (hopefully same as ADL) lookup
// giving us all free-functions in namespace 
consteval bool find_candidates_in_scope(std::meta::info scope, std::string_view name, std::vector<std::meta::info> & out) {
    //while (is_class_type(scope)) {
    //    scope = parent_of(scope); // unwind class type scope
    //}
    if (!is_namespace(scope)) { // we care only about namespaces
        return false;
    }
    bool found = false;
    for (auto candidate: named_functions_of(scope, name)) {
        found = true;
        out.push_back(candidate);
    }
    return found; // if there is something it's shadowing everything below
}
constexpr auto top_scope = ^^::;
consteval void candidates_associated_with(std::string_view name, std::meta::info type, std::vector<std::meta::info> & out) {
    if (!is_type(type)) {
        return;
    }
    
    auto parent = parent_of(type);

// look at namespace and unroll parent types if it's 
    // TODO: check if this is ADL behaviour
    while (!is_namespace(parent) && is_class_type(parent)) {
        parent = parent_of(parent);
    }

// for each parent namespace
    while (is_namespace(parent)) {
        // look for matching names
        if (find_candidates_in_scope(parent, name, out)) {
            break; // and if there are any, don't look further
        }

// otherwise continue until you get to outer namespace
        if (parent == top_scope) {
            break;
        }
        parent = parent_of(parent); 
    }
    
    // recursively inspect all template arguments if type is an instance 
    // of a template type
    if (has_template_arguments(type)) {
        auto arguments = template_arguments_of(type);
        for (auto arg: arguments) {
            if (is_value(arg)) {
                arg = type_of(arg);
            }
            candidates_associated_with(name, arg, out);
        }
    }
}

consteval std::vector<std::meta::info> get_uniques(std::vector<std::meta::info> input) {
    auto it = input.begin();
    const auto end = input.end();
    std::vector<std::meta::info> result{};

for (; it != end; ++it) {
        auto it2 = std::next(it);
        bool unique = true;
        for (; it2 != end; ++it2) {
            if (*it == *it2) {
                unique = false;
                break;
            }
        }
        if (unique) {
            result.push_back(*it);
        }
    }

return result;
}

// get all candidates and make them unique
consteval auto candidates(std::string_view name, std::span<const std::meta::info> types) {
    std::vector<std::meta::info> output{};
    for (auto type: types) {
        candidates_associated_with(name, type, output);
    }
    // std::unique somehow didn't work
    return get_uniques(std::move(output));
}

// give me a temporary overload_set based on ADL
consteval auto resolve(std::string_view name, std::span<const std::meta::info> types) {
    return substitute(^^overloads, candidates(name, types) | std::views::transform(build_overload));
}

// can we call this?
template <typename Resolver, typename... Args> concept valid_resolver = requires(Resolver res, Args... args) {
    res(args...);
};

template <fixed_string Name> struct adl_lookup {
    static constexpr auto name = std::string_view{Name};

// with ADL we look at the all candidates
    template <typename... Args, typename Resolver = typename [: hana::resolve(name, {^^Args...}) :]>
    requires (hana::valid_resolver<Resolver, Args...>) // and if there is a valid one
    static constexpr decltype(auto) operator()(Args && ... args) noexcept(noexcept(Resolver{}(std::forward<Args>(args)...))) {
        // we will pick it up
        return Resolver{}(std::forward<Args>(args)...);
    }
};

struct not_matching{
    constexpr void operator()(...) const noexcept = delete("no other matching overload");
};

// I should use something nicer than template recursion, but getting lazy
template <typename... Resolvers> struct prioritized {
    consteval prioritized(Resolvers...) noexcept { }

template <typename... Args> using resolver_for = typename [: []{
        template for (constexpr auto r : {^^Resolvers...}) {
            if constexpr (valid_resolver<typename [: r :], Args...>) {
                return r;
            }
        }
        return ^^not_matching;
    }() :];

template <typename... Args>
    requires (valid_resolver<resolver_for<Args...>, Args...>)
    static decltype(auto) operator()(Args... args) noexcept(noexcept(resolver_for<Args...>{}(std::forward<Args>(args)...))) {
        return resolver_for<Args...>{}(std::forward<Args>(args)...);
    }
};

// USER FACING INTERFACE
template <std::meta::info Context, fixed_string Name> constexpr auto qualified = typename [: hana::build_overload_set(Context, Name) :]();
template <fixed_string Name> constexpr auto adl = hana::overloads<hana::adl_lookup<Name>>{};

}

// TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS
//  TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS
// * TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS
// ** TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS
// *** TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS TESTS

struct Test {
  int myfn(int v) const { return v; }
  double myfn(double v) const { return v; }
  void myfn3(double v) const { }
  auto myfn(std::convertible_to<std::string_view> auto && v) const { return std::string(v); }
  auto view(std::convertible_to<std::string_view> auto && v) const { return std::string(v); }
  static int static_fn(int v) { return v; };
  static double static_fn(double v) { return v; };
};

// TEST qualified lookup for class members
constexpr auto myfn_in_test = hana::qualified<^^Test, "myfn">; // it must be identified by constant string

const Test const_test{};
std::same_as<double> auto a = myfn_in_test(const_test, 42.3);
std::same_as<int> auto b = myfn_in_test(Test{}, 42);

constexpr auto view_in_test = hana::qualified<^^Test, "view">; // it must be identified by constant string
std::same_as<std::string> auto c = view_in_test(Test{}, "hello");

namespace NamespaceTest {
    int myfn(int v) { return v; }
    double myfn(double v) { return v; }
    auto myfn(std::convertible_to<std::string_view> auto && v) { return std::string(v); }

struct handle { };

struct dual_handle { };

handle myfn(handle v) {
        return v;
    }
    dual_handle myfn(handle v, handle y) {
        return {};
    }
};

// test namespace qualified lookup
constexpr auto namespace_myfn = hana::qualified<^^NamespaceTest, "myfn">; // it must be identified by constant string
static_assert(namespace_myfn.size == 5);

std::same_as<std::string> auto d = namespace_myfn("hello");

// TEST ADL lookup with one argument
constexpr auto adl_myfn = hana::adl<"myfn">;
std::same_as<NamespaceTest::handle> auto x = adl_myfn(NamespaceTest::handle{});

// TEST ADL lookup with two arguments from same scope
std::same_as<NamespaceTest::dual_handle> auto y = adl_myfn(NamespaceTest::handle{}, NamespaceTest::handle{});

namespace DifferentNamespace {
    struct color { };

struct handle_and_color { };

handle_and_color myfn(NamespaceTest::handle v, color y) {
        return {};
    }

struct special_handle { };

special_handle myfn(NamespaceTest::handle) {
        return {};
    }
}

// TEST ADL lookup with two arguments from different scope
std::same_as<DifferentNamespace::handle_and_color> auto z = adl_myfn(NamespaceTest::handle{}, DifferentNamespace::color{});

// TEST priority lookup (left to right matches)
constexpr auto prio = hana::prioritized(hana::qualified<^^DifferentNamespace, "myfn">, adl_myfn);
std::same_as<DifferentNamespace::special_handle> auto w = prio(NamespaceTest::handle{});

//auto v = prio(DifferentNamespace::color{}); // failing intentionally