reflect_annotate.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
// std-interop-file: dev-time code-generation tool (std::string-heavy), never part of the formatting hot path.
 
#include "../detail/compat.hpp"
 
#include <type_traits>
 
namespace microfmt {
 
template <typename T> struct enable_reflect_format : std::false_type {};
 
} // namespace microfmt
 
#if RELOCO_HAS_REFLECTION
 
#include <meta>
#include <string>
#include <string_view>
#include <vector>
 
namespace microfmt::detail {
 
struct reflect_dump_entry {
  std::string type_name;
  std::string generated_code;
};
 
inline std::vector<reflect_dump_entry> &reflect_dump_registry() {
  static std::vector<reflect_dump_entry> registry;
  return registry;
}
 
template <typename E> std::string generate_reflect_enum_dump(std::string_view type_name) {
  std::string out;
  out += "template <> struct microfmt::formatter<";
  out += type_name;
  out += "> {\n  constexpr void parse(format_parse_context &ctx) noexcept { (void)ctx; }\n";
  out += "  void format(";
  out += type_name;
  out += " val, const sink &out) const noexcept {\n    switch (val) {\n";
 
  template for (constexpr auto e : define_static_array(std::meta::enumerators_of(^^E))) {
    constexpr std::string_view enumerator_name = std::meta::identifier_of(e);
    out += "    case ";
    out += type_name;
    out += "::";
    out += enumerator_name;
    out += ": out.write(\"";
    out += enumerator_name;
    out += "\"); return;\n";
  }
 
  out += "    default: break;\n    }\n    format_to(out, \"{}\", static_cast<std::underlying_type_t<";
  out += type_name;
  out += ">>(val));\n  }\n};\n";
  return out;
}
 
template <typename T> std::string generate_reflect_struct_dump(std::string_view type_name) {
  std::string members_code;
  bool has_members = false;
 
  template for (constexpr auto member :
                define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::current()))) {
    constexpr std::string_view name = std::meta::identifier_of(member);
    if (has_members) {
      members_code += "    out.write(\", \");\n";
    }
    has_members = true;
    members_code += "    out.write(\"";
    members_code += name;
    members_code += ": \");\n    microfmt::format_to(out, \"{}\", microfmt::as_debug(val.";
    members_code += name;
    members_code += "));\n";
  }
 
  std::string out;
  out += "template <> struct reloco::Debug<";
  out += type_name;
  out += "> {\n  static void format(const ";
  out += type_name;
  out += " &val, const reloco::sink &out) noexcept {\n";
 
  if (!has_members) {
    out += "    out.write(\"";
    out += type_name;
    out += " {}\");\n";
  } else {
    out += "    out.write(\"";
    out += type_name;
    out += " { \");\n";
    out += members_code;
    out += "    out.write(\" }\");\n";
  }
 
  out += "  }\n};\n";
  return out;
}
 
template <typename E> bool register_reflect_dump_enum(std::string_view type_name) {
  reflect_dump_registry().push_back({std::string(type_name), generate_reflect_enum_dump<E>(type_name)});
  return true;
}
 
template <typename T> bool register_reflect_dump_struct(std::string_view type_name) {
  reflect_dump_registry().push_back({std::string(type_name), generate_reflect_struct_dump<T>(type_name)});
  return true;
}
 
inline std::string render_reflect_dump() {
  std::string out = "// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>\n"
                    "//\n// SPDX-License-Identifier: BSD-2-Clause\n\n"
                    "// Auto-generated by tools/reflect_dump -- do not edit by hand.\n"
                    "// Regenerate with a -freflection build; see docs/reflection.md.\n\n"
                    "#pragma once\n\n"
                    "#include <microfmt/detail/compat.hpp>\n\n"
                    "#if !RELOCO_HAS_REFLECTION\n\n"
                    "#include <microfmt/microfmt.hpp>\n"
                    "#include <type_traits>\n\n";
 
  for (const auto &entry : reflect_dump_registry()) {
    out += entry.generated_code;
    out += "\n";
  }
 
  out += "#endif // !RELOCO_HAS_REFLECTION\n";
  return out;
}
 
} // namespace microfmt::detail
 
#if defined(MICROFMT_REFLECT_DUMP_MODE)
 
// Three levels of indirection are required, not two: `__COUNTER__` is only
// macro-expanded while being passed as a plain (non-`##`-adjacent)
// argument. `MICROFMT_REFLECT_DUMP_ENUM`/`_STRUCT` pass it to a pure
// forwarding macro first (`..._FWD`), which is what actually expands it
// before `..._IMPL` pastes the now-numeric token -- collapsing this to two
// levels silently pastes the literal text `__COUNTER__` instead.
#define MICROFMT_REFLECT_DUMP_ENUM_IMPL(Type, Counter)                                                                 \
  static const bool microfmt_reflect_dump_enum_##Counter = ::microfmt::detail::register_reflect_dump_enum<Type>(#Type)
#define MICROFMT_REFLECT_DUMP_ENUM_FWD(Type, Counter) MICROFMT_REFLECT_DUMP_ENUM_IMPL(Type, Counter)
#define MICROFMT_REFLECT_DUMP_ENUM(Type) MICROFMT_REFLECT_DUMP_ENUM_FWD(Type, __COUNTER__)
 
#define MICROFMT_REFLECT_DUMP_STRUCT_IMPL(Type, Counter)                                                               \
  static const bool microfmt_reflect_dump_struct_##Counter =                                                           \
      ::microfmt::detail::register_reflect_dump_struct<Type>(#Type)
#define MICROFMT_REFLECT_DUMP_STRUCT_FWD(Type, Counter) MICROFMT_REFLECT_DUMP_STRUCT_IMPL(Type, Counter)
#define MICROFMT_REFLECT_DUMP_STRUCT(Type) MICROFMT_REFLECT_DUMP_STRUCT_FWD(Type, __COUNTER__)
 
#else // !MICROFMT_REFLECT_DUMP_MODE
 
#define MICROFMT_REFLECT_DUMP_ENUM(Type)
#define MICROFMT_REFLECT_DUMP_STRUCT(Type)
 
#endif // MICROFMT_REFLECT_DUMP_MODE
 
#define MICROFMT_REFLECT_FORMAT(Type)                                                                                  \
  template <> struct microfmt::enable_reflect_format<Type> : std::true_type {};                                        \
  MICROFMT_REFLECT_DUMP_STRUCT(Type)
 
#else // !RELOCO_HAS_REFLECTION
 
#define MICROFMT_REFLECT_FORMAT(Type)
#define MICROFMT_REFLECT_DUMP_ENUM(Type)
#define MICROFMT_REFLECT_DUMP_STRUCT(Type)
 
#endif // RELOCO_HAS_REFLECTION