Stacktrace.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_STACKTRACE_HPP
#define MIMICPP_STACKTRACE_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/Printer.hpp"
#include "mimic++/Utility.hpp"
 
#include <algorithm>
#include <any>
// ReSharper disable once CppUnusedIncludeDirective
#include <functional> // std::invoke
#include <ranges>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace mimicpp::custom
{
    struct find_stacktrace_backend;
}
 
namespace mimicpp::stacktrace
{

    struct find_backend;

    template <typename Backend>
    struct backend_traits;

    template <typename T>
    concept backend =
        std::copyable<T>
        && requires(backend_traits<std::remove_cvref_t<T>> traits, const std::remove_cvref_t<T>& backend, const std::size_t value) {
               { decltype(traits)::current(value) } -> std::convertible_to<std::remove_cvref_t<T>>;
               { decltype(traits)::size(backend) } -> std::convertible_to<std::size_t>;
               { decltype(traits)::empty(backend) } -> std::convertible_to<bool>;
               { decltype(traits)::description(backend, value) } -> std::convertible_to<std::string>;
               { decltype(traits)::source_file(backend, value) } -> std::convertible_to<std::string>;
               { decltype(traits)::source_line(backend, value) } -> std::convertible_to<std::size_t>;
           };

}
 
namespace mimicpp::stacktrace::detail
{
    template <typename Backend>
    [[nodiscard]]
    std::size_t size(const std::any& backend)
    {
        return backend_traits<Backend>::size(
            std::any_cast<const Backend&>(backend));
    }
 
    template <typename Backend>
    [[nodiscard]]
    bool empty(const std::any& backend)
    {
        return backend_traits<Backend>::empty(
            std::any_cast<const Backend&>(backend));
    }
 
    template <typename Backend>
    [[nodiscard]]
    std::string description(const std::any& backend, const std::size_t index)
    {
        return backend_traits<Backend>::description(
            std::any_cast<const Backend&>(backend),
            index);
    }
 
    template <typename Backend>
    [[nodiscard]]
    std::string source_file(const std::any& backend, const std::size_t index)
    {
        return backend_traits<Backend>::source_file(
            std::any_cast<const Backend&>(backend),
            index);
    }
 
    template <typename Backend>
    [[nodiscard]]
    std::size_t source_line(const std::any& backend, const std::size_t index)
    {
        return backend_traits<Backend>::source_line(
            std::any_cast<const Backend&>(backend),
            index);
    }
}
 
namespace mimicpp
{
    class Stacktrace
    {
    public:
        using size_fn = std::size_t (*)(const std::any&);
        using empty_fn = bool (*)(const std::any&);
        using description_fn = std::string (*)(const std::any&, std::size_t);
        using source_file_fn = std::string (*)(const std::any&, std::size_t);
        using source_line_fn = std::size_t (*)(const std::any&, std::size_t);

        ~Stacktrace() = default;

        template <typename Inner>
            requires(!std::same_as<Stacktrace, std::remove_cvref_t<Inner>>)
                     && stacktrace::backend<Inner>
        [[nodiscard]]
        explicit constexpr Stacktrace(Inner&& inner)
            : m_Inner{std::forward<Inner>(inner)},
              m_SizeFn{&stacktrace::detail::size<std::remove_cvref_t<Inner>>},
              m_EmptyFn{&stacktrace::detail::empty<std::remove_cvref_t<Inner>>},
              m_DescriptionFn{&stacktrace::detail::description<std::remove_cvref_t<Inner>>},
              m_SourceFileFn{&stacktrace::detail::source_file<std::remove_cvref_t<Inner>>},
              m_SourceLineFn{&stacktrace::detail::source_line<std::remove_cvref_t<Inner>>}
        {
        }

        [[nodiscard]]
        Stacktrace(const Stacktrace&) = default;

        Stacktrace& operator=(const Stacktrace&) = default;

        [[nodiscard]]
        Stacktrace(Stacktrace&&) = default;

        Stacktrace& operator=(Stacktrace&&) = default;

        [[nodiscard]]
        constexpr std::size_t size() const
        {
            return std::invoke(m_SizeFn, m_Inner);
        }

        [[nodiscard]]
        constexpr bool empty() const
        {
            return std::invoke(m_EmptyFn, m_Inner);
        }

        [[nodiscard]]
        constexpr std::string description(const std::size_t at) const
        {
            return std::invoke(m_DescriptionFn, m_Inner, at);
        }

        [[nodiscard]]
        constexpr std::string source_file(const std::size_t at) const
        {
            return std::invoke(m_SourceFileFn, m_Inner, at);
        }

        [[nodiscard]]
        constexpr std::size_t source_line(const std::size_t at) const
        {
            return std::invoke(m_SourceLineFn, m_Inner, at);
        }
 
        [[nodiscard]]
        friend bool operator==(const Stacktrace& lhs, const Stacktrace& rhs)
        {
            return lhs.size() == rhs.size()
                && std::ranges::all_of(
                       std::views::iota(0u, lhs.size()),
                       [&](const std::size_t index) {
                           return lhs.description(index) == rhs.description(index)
                               && lhs.source_file(index) == rhs.source_file(index)
                               && lhs.source_line(index) == rhs.source_line(index);
                       });
        }
 
    private:
        std::any m_Inner;
        size_fn m_SizeFn;
        empty_fn m_EmptyFn;
        description_fn m_DescriptionFn;
        source_file_fn m_SourceFileFn;
        source_line_fn m_SourceLineFn;
    };
}
 
namespace mimicpp::stacktrace::detail::current_hook
{
    template <typename FindBackend, template <typename> typename Traits>
    concept existing_backend = requires {
        {
            Traits<
                typename FindBackend::type>::current(std::size_t{})
        } -> backend;
    };
 
    template <
        template <typename> typename Traits,
        existing_backend<Traits> FindBackendT = custom::find_stacktrace_backend>
    [[nodiscard]]
    constexpr auto current([[maybe_unused]] const priority_tag<2>, const std::size_t skip)
    {
        return Traits<
            typename FindBackendT::type>::current(skip + 1u);
    }
 
    template <
        template <typename> typename Traits,
        existing_backend<Traits> FindBackendT = find_backend>
    [[nodiscard]]
    constexpr auto current([[maybe_unused]] const priority_tag<1>, const std::size_t skip)
    {
        return Traits<
            typename FindBackendT::type>::current(skip + 1u);
    }
 
    template <template <typename> typename Traits>
    constexpr auto current([[maybe_unused]] const priority_tag<0>, [[maybe_unused]] const std::size_t skip)
    {
        static_assert(
            always_false<Traits<void>>{},
            "mimic++ does not have a registered stacktrace-backend.");
    }
 
    constexpr priority_tag<2> maxTag;
 
    struct current_fn
    {
        template <typename... Canary, template <typename> typename Traits = backend_traits>
        [[nodiscard]]
        Stacktrace operator()(const std::size_t skip) const
        {
            return Stacktrace{
                current_hook::current<Traits>(maxTag, skip + 1u)};
        }
 
        template <typename... Canary, template <typename> typename Traits = backend_traits>
        [[nodiscard]]
        Stacktrace operator()() const
        {
            return Stacktrace{
                current_hook::current<Traits>(maxTag, 1u)};
        }
    };
}
 
namespace mimicpp::stacktrace
{

    [[maybe_unused]]
    constexpr detail::current_hook::current_fn current{};
}
 
template <>
class mimicpp::detail::Printer<mimicpp::Stacktrace>
{
public:
    template <print_iterator OutIter>
    static OutIter print(OutIter out, const Stacktrace& stacktrace)
    {
        if (stacktrace.empty())
        {
            return format::format_to(
                std::move(out),
                "empty");
        }
 
        for (const std::size_t i : std::views::iota(0u, stacktrace.size()))
        {
            out = format::format_to(
                std::move(out),
                "{} [{}], {}\n",
                stacktrace.source_file(i),
                stacktrace.source_line(i),
                stacktrace.description(i));
        }
 
        return out;
    }
};
 
namespace mimicpp::stacktrace
{
    class NullBackend
    {
    };
}
 
template <>
struct mimicpp::stacktrace::backend_traits<mimicpp::stacktrace::NullBackend>
{
    [[nodiscard]]
    static NullBackend current([[maybe_unused]] const std::size_t skip) noexcept
    {
        return NullBackend{};
    }
 
    [[nodiscard]]
    static constexpr std::size_t size([[maybe_unused]] const NullBackend& backend) noexcept
    {
        return 0u;
    }
 
    [[nodiscard]]
    static constexpr bool empty([[maybe_unused]] const NullBackend& backend) noexcept
    {
        return true;
    }
 
    static std::string description([[maybe_unused]] const NullBackend& backend, [[maybe_unused]] const std::size_t at)
    {
        raise_unsupported_operation();
    }
 
    static std::string source_file([[maybe_unused]] const NullBackend& backend, [[maybe_unused]] const std::size_t at)
    {
        raise_unsupported_operation();
    }
 
    [[nodiscard]]
    static std::size_t source_line([[maybe_unused]] const NullBackend& backend, [[maybe_unused]] const std::size_t at)
    {
        raise_unsupported_operation();
    }
 
private:
    [[noreturn]]
    static void raise_unsupported_operation()
    {
        throw std::runtime_error{"stacktrace::NullBackend doesn't support this operation."};
    }
};
 
static_assert(
    mimicpp::stacktrace::backend<mimicpp::stacktrace::NullBackend>,
    "stacktrace::NullBackend does not satisfy the stacktrace::backend concept");
 
#if defined(MIMICPP_CONFIG_EXPERIMENTAL_STACKTRACE) \
    && not defined(NDEBUG)
 
    #ifdef MIMICPP_CONFIG_EXPERIMENTAL_USE_CPPTRACE
 
        #if __has_include(<cpptrace/basic.hpp>)
            #include <cpptrace/basic.hpp>
        #elif __has_include(<cpptrace/cpptrace.hpp>)
            // this is necessary for old cpptrace versions.
            // see: https://github.com/jeremy-rifkin/libassert/issues/110
            #include <cpptrace/cpptrace.hpp>
        #else
            #error "The cpptrace stacktrace backend is explicitly enabled, but the the required include-file can not be found."
        #endif
 
namespace mimicpp::stacktrace
{
    class CpptraceBackend
    {
    public:
        ~CpptraceBackend() = default;
 
        [[nodiscard]]
        explicit CpptraceBackend(cpptrace::raw_trace&& trace) noexcept
            : m_Trace{std::move(trace)}
        {
        }
 
        CpptraceBackend(const CpptraceBackend&) = default;
        CpptraceBackend& operator=(const CpptraceBackend&) = default;
        CpptraceBackend(CpptraceBackend&&) = default;
        CpptraceBackend& operator=(CpptraceBackend&&) = default;
 
        [[nodiscard]]
        const cpptrace::stacktrace& data() const
        {
            if (const auto* raw = std::get_if<cpptrace::raw_trace>(&m_Trace))
            {
                m_Trace = raw->resolve();
            }
 
            return std::get<cpptrace::stacktrace>(m_Trace);
        }
 
    private:
        using TraceT = std::variant<cpptrace::raw_trace, cpptrace::stacktrace>;
        mutable TraceT m_Trace;
    };
}
 
struct mimicpp::stacktrace::find_backend
{
    using type = CpptraceBackend;
};
 
template <>
struct mimicpp::stacktrace::backend_traits<mimicpp::stacktrace::CpptraceBackend>
{
    [[nodiscard]]
    static CpptraceBackend current(const std::size_t skip)
    {
        return CpptraceBackend{cpptrace::generate_raw_trace(skip + 1)};
    }
 
    [[nodiscard]]
    static std::size_t size(const CpptraceBackend& backend)
    {
        return backend.data().frames.size();
    }
 
    [[nodiscard]]
    static bool empty(const CpptraceBackend& backend)
    {
        return backend.data().empty();
    }
 
    [[nodiscard]]
    static std::string description(const CpptraceBackend& backend, const std::size_t at)
    {
        return frame(backend, at).symbol;
    }
 
    [[nodiscard]]
    static std::string source_file(const CpptraceBackend& backend, const std::size_t at)
    {
        return frame(backend, at).filename;
    }
 
    [[nodiscard]]
    static std::size_t source_line(const CpptraceBackend& backend, const std::size_t at)
    {
        return frame(backend, at).line.value_or(0u);
    }
 
    [[nodiscard]]
    static const cpptrace::stacktrace_frame& frame(const CpptraceBackend& backend, const std::size_t at)
    {
        return backend.data().frames.at(at);
    }
};
 
static_assert(
    mimicpp::stacktrace::backend<mimicpp::stacktrace::CpptraceBackend>,
    "stacktrace::CpptraceBackend does not satisfy the stacktrace::backend concept");
 
        #define MIMICPP_DETAIL_WORKING_STACKTRACE_BACKEND
 
    #elif defined(__cpp_lib_stacktrace)
 
        #include <stacktrace>
 
struct mimicpp::stacktrace::find_backend
{
    using type = std::stacktrace;
};
 
template <typename Allocator>
struct mimicpp::stacktrace::backend_traits<std::basic_stacktrace<Allocator>>
{
    using BackendT = std::basic_stacktrace<Allocator>;
 
    [[nodiscard]]
    static BackendT current(const std::size_t skip)
    {
        return BackendT::current(skip + 1);
    }
 
    [[nodiscard]]
    static std::size_t size(const BackendT& backend)
    {
        return backend.size();
    }
 
    [[nodiscard]]
    static bool empty(const BackendT& backend)
    {
        return backend.empty();
    }
 
    [[nodiscard]]
    static std::string description(const BackendT& backend, const std::size_t at)
    {
        return entry(backend, at).description();
    }
 
    [[nodiscard]]
    static std::string source_file(const BackendT& backend, const std::size_t at)
    {
        return entry(backend, at).source_file();
    }
 
    [[nodiscard]]
    static std::size_t source_line(const BackendT& backend, const std::size_t at)
    {
        return entry(backend, at).source_line();
    }
 
    [[nodiscard]]
    static const std::stacktrace_entry& entry(const BackendT& backend, const std::size_t at)
    {
        return backend.at(at);
    }
};
 
static_assert(
    mimicpp::stacktrace::backend<std::stacktrace>,
    "std::stacktrace does not satisfy the stacktrace::backend concept");
 
        #define MIMICPP_DETAIL_WORKING_STACKTRACE_BACKEND
 
    #else
 
        // neither backend is available, but maybe a custom type?
        // so, we should not emit an error here.
 
    #endif
 
#endif
 
// This is enabled as fallback solution, when neither std::stacktrace nor cpptrace is available,
// or MIMICPP_CONFIG_EXPERIMENTAL_STACKTRACE simply not defined.
#ifndef MIMICPP_DETAIL_WORKING_STACKTRACE_BACKEND
 
struct mimicpp::stacktrace::find_backend
{
    using type = NullBackend;
};
 
#endif
 
#endif