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_UTILITIES_STACKTRACE_HPP
#define MIMICPP_UTILITIES_STACKTRACE_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/config/Settings.hpp"
#include "mimic++/printing/PathPrinter.hpp"
#include "mimic++/printing/StatePrinter.hpp"
#include "mimic++/printing/TypePrinter.hpp"
#include "mimic++/utilities/Concepts.hpp"
#include "mimic++/utilities/PriorityTag.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <functional> // std::invoke
    #include <limits>
    #include <memory>
    #include <ranges>
    #include <stdexcept>
    #include <type_traits>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::custom
{
    struct find_stacktrace_backend;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::util::stacktrace
{

    struct find_backend;

    template <typename Backend>
    struct backend_traits;

    template <typename T>
    concept backend =
        std::semiregular<std::remove_cvref_t<T>>
        && requires(backend_traits<std::remove_cvref_t<T>> traits, std::remove_cvref_t<T> const& backend, std::size_t const value) {
               { decltype(traits)::current(value) } -> std::convertible_to<std::remove_cvref_t<T>>;
               { decltype(traits)::current(value, value) } -> std::convertible_to<std::remove_cvref_t<T>>;
               { decltype(traits)::size(backend) } -> std::convertible_to<std::size_t>;
               { decltype(traits)::empty(backend) } -> util::boolean_testable;
               { 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>;
           };

    class NullBackend
    {
    };

}
 
template <>
struct mimicpp::util::stacktrace::backend_traits<mimicpp::util::stacktrace::NullBackend>
{
    [[nodiscard]]
    static constexpr NullBackend current([[maybe_unused]] std::size_t const skip, [[maybe_unused]] std::size_t const max) noexcept
    {
        return NullBackend{};
    }
 
    [[nodiscard]]
    static constexpr NullBackend current([[maybe_unused]] std::size_t const skip) noexcept
    {
        return NullBackend{};
    }
 
    [[nodiscard]]
    static constexpr std::size_t size([[maybe_unused]] NullBackend const& stacktrace) noexcept
    {
        return 0u;
    }
 
    [[nodiscard]]
    static constexpr bool empty([[maybe_unused]] NullBackend const& stacktrace) noexcept
    {
        return true;
    }
 
    static std::string description([[maybe_unused]] NullBackend const& stacktrace, [[maybe_unused]] std::size_t const at)
    {
        raise_unsupported_operation();
    }
 
    static std::string source_file([[maybe_unused]] NullBackend const& stacktrace, [[maybe_unused]] std::size_t const at)
    {
        raise_unsupported_operation();
    }
 
    [[nodiscard]]
    static std::size_t source_line([[maybe_unused]] NullBackend const& stacktrace, [[maybe_unused]] std::size_t const 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::util::stacktrace::backend<mimicpp::util::stacktrace::NullBackend>,
    "stacktrace::NullBackend does not satisfy the stacktrace::backend concept");
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::util
{
    class Stacktrace
    {
    private:
        class Concept
        {
        public:
            [[nodiscard]]
            constexpr virtual bool empty() const = 0;
 
            [[nodiscard]]
            constexpr virtual std::size_t size() const = 0;
 
            [[nodiscard]]
            constexpr virtual std::string description(std::size_t at) const = 0;
 
            [[nodiscard]]
            constexpr virtual std::string source_file(std::size_t at) const = 0;
 
            [[nodiscard]]
            constexpr virtual std::size_t source_line(std::size_t at) const = 0;
 
        protected:
            virtual ~Concept() = default;
            Concept() = default;
            Concept(Concept const&) = default;
            Concept& operator=(Concept const&) = default;
            Concept(Concept&&) = default;
            Concept& operator=(Concept&&) = default;
        };
 
        template <typename Backend>
        class Model final
            : public Concept
        {
        public:
            using BackendTraits = stacktrace::backend_traits<Backend>;
 
            [[nodiscard]]
            explicit Model(Backend&& backend) noexcept(std::is_nothrow_move_constructible_v<Backend>)
                : m_Backend{std::move(backend)}
            {
            }
 
            [[nodiscard]]
            constexpr bool empty() const override
            {
                return std::invoke(BackendTraits::empty, m_Backend);
            }
 
            [[nodiscard]]
            constexpr std::size_t size() const override
            {
                return std::invoke(BackendTraits::size, m_Backend);
            }
 
            [[nodiscard]]
            constexpr std::string description(std::size_t const at) const override
            {
                return std::invoke(BackendTraits::description, m_Backend, at);
            }
 
            [[nodiscard]]
            constexpr std::string source_file(std::size_t const at) const override
            {
                return std::invoke(BackendTraits::source_file, m_Backend, at);
            }
 
            [[nodiscard]]
            constexpr std::size_t source_line(std::size_t const at) const override
            {
                return std::invoke(BackendTraits::source_line, m_Backend, at);
            }
 
        private:
            Backend m_Backend;
        };
 
    public:
        ~Stacktrace() = default;

        Stacktrace()
            : Stacktrace{stacktrace::NullBackend{}}
        {
        }

        template <typename Backend>
            requires(!std::same_as<Stacktrace, std::remove_cvref_t<Backend>>)
                 && stacktrace::backend<Backend>
        [[nodiscard]]
        explicit Stacktrace(Backend backend)
            : m_Backend{std::make_shared<Model<Backend>>(std::move(backend))}
        {
        }

        Stacktrace(Stacktrace const&) = default;

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

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

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

        [[nodiscard]]
        std::size_t size() const
        {
            return backend().size();
        }

        [[nodiscard]]
        bool empty() const
        {
            return backend().empty();
        }

        [[nodiscard]]
        std::string description(std::size_t const at) const
        {
            return backend().description(at);
        }

        [[nodiscard]]
        std::string source_file(std::size_t const at) const
        {
            return backend().source_file(at);
        }

        [[nodiscard]]
        std::size_t source_line(std::size_t const at) const
        {
            return backend().source_line(at);
        }
 
        [[nodiscard]]
        friend bool operator==(Stacktrace const& lhs, Stacktrace const& rhs)
        {
            return lhs.size() == rhs.size()
                && std::ranges::all_of(
                       std::views::iota(0u, lhs.size()),
                       [&](std::size_t const 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::shared_ptr<Concept> m_Backend;
 
        [[nodiscard]]
        Concept const& backend() const noexcept
        {
            MIMICPP_ASSERT(m_Backend, "Invalid state");
 
            return *m_Backend;
        }
    };
}
 
namespace mimicpp::util::stacktrace::detail
{
    template <typename T>
    concept backend_finder = requires {
        typename T::type;
    };
 
    // ReSharper disable CppFunctionIsNotImplemented
    template <template <typename> typename Traits, backend_finder FindBackend = custom::find_stacktrace_backend>
    Traits<typename FindBackend::type> find_traits_impl([[maybe_unused]] priority_tag<1u>);
 
    // When users explicitly register a custom stacktrace, we should not accidentally fall back to another backend.
#ifndef MIMICPP_CONFIG_EXPERIMENTAL_USE_CUSTOM_STACKTRACE
    template <template <typename> typename Traits, backend_finder FindBackend = stacktrace::find_backend>
    Traits<typename FindBackend::type> find_traits_impl([[maybe_unused]] priority_tag<0u>);
#endif
    // ReSharper restore CppFunctionIsNotImplemented
 
    template <template <typename> typename Traits>
    auto find_traits()
    {
        return find_traits_impl<Traits>(priority_tag<1u>{});
    }
 
    [[nodiscard]]
    inline std::size_t calc_skip(std::size_t const skip)
    {
        std::size_t const baseSkip = settings::stacktrace_base_skip().load();
        MIMICPP_ASSERT(skip < std::numeric_limits<std::size_t>::max() - 1u, "Skip is too high.");
        MIMICPP_ASSERT(skip < std::numeric_limits<std::size_t>::max() - baseSkip, "Skip + base-skip is too high.");
 
        return skip + 1u + baseSkip;
    }
 
    struct current_fn
    {
        template <typename... Canary, template <typename> typename TraitsTemplate = backend_traits>
        [[nodiscard]]
        Stacktrace operator()(std::size_t const skip, std::size_t const max) const
        {
            using Traits = decltype(find_traits<TraitsTemplate>());
 
            return Stacktrace{Traits::current(calc_skip(skip), max)};
        }
 
        template <typename... Canary, template <typename> typename TraitsTemplate = backend_traits>
        [[nodiscard]]
        Stacktrace operator()(std::size_t const skip) const
        {
            using Traits = decltype(find_traits<TraitsTemplate>());
 
            return Stacktrace{Traits::current(calc_skip(skip))};
        }
 
        template <typename... Canary, template <typename> typename TraitsTemplate = backend_traits>
        [[nodiscard]]
        Stacktrace operator()() const
        {
            using Traits = decltype(find_traits<TraitsTemplate>());
 
            return Stacktrace{Traits::current(calc_skip(0u))};
        }
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::util::stacktrace
{
    [[maybe_unused]]
    inline constexpr detail::current_fn current{};
}
 
namespace mimicpp::util::stacktrace::detail
{
    template <print_iterator OutIter>
    constexpr OutIter print_entry(OutIter out, Stacktrace const& stacktrace, std::size_t const index)
    {
        MIMICPP_ASSERT(index < stacktrace.size(), "Index out of bounds.");
 
        return printing::detail::print_source_location(
            std::move(out),
            stacktrace.source_file(index),
            stacktrace.source_line(index),
            stacktrace.description(index));
    }
}
 
template <>
struct mimicpp::printing::detail::state::common_type_printer<mimicpp::util::Stacktrace>
{
    template <print_iterator OutIter>
    static constexpr OutIter print(OutIter out, util::Stacktrace const& stacktrace)
    {
        if (stacktrace.empty())
        {
            return format::format_to(std::move(out), "empty");
        }
 
        for (std::size_t const i : std::views::iota(0u, stacktrace.size()))
        {
            out = format::format_to(std::move(out), "#{} ", i);
            out = util::stacktrace::detail::print_entry(
                std::move(out),
                stacktrace,
                i);
            out = format::format_to(std::move(out), "\n");
        }
 
        return out;
    }
};
 
#if MIMICPP_CONFIG_EXPERIMENTAL_USE_CXX23_STACKTRACE
    #include "mimic++_ext/stacktrace/std-stacktrace.hpp"
    #define MIMICPP_DETAIL_HAS_WORKING_STACKTRACE_BACKEND 1
#elif MIMICPP_CONFIG_EXPERIMENTAL_USE_BOOST_STACKTRACE
    #include "mimic++_ext/stacktrace/boost-stacktrace.hpp"
    #define MIMICPP_DETAIL_HAS_WORKING_STACKTRACE_BACKEND 1
#elif MIMICPP_CONFIG_EXPERIMENTAL_USE_CPPTRACE
    #include "mimic++_ext/stacktrace/cpptrace.hpp"
    #define MIMICPP_DETAIL_HAS_WORKING_STACKTRACE_BACKEND 1
#else
namespace mimicpp::util::stacktrace
{
    struct find_backend
    {
        using type = NullBackend;
    };
}
#endif
 
#endif