refactor(index): migrate FlatBuffers from flatc IDL to kotatsu reflection

CMakeLists.txt

@@ -124,42 +124,21 @@ if(CLICE_CI_ENVIRONMENT)
     target_compile_definitions(clice_options INTERFACE CLICE_CI_ENVIRONMENT=1)
 endif()
 
-set(FBS_SCHEMA_FILE "${PROJECT_SOURCE_DIR}/src/index/schema.fbs")
-set(GENERATED_HEADER "${PROJECT_BINARY_DIR}/generated/schema_generated.h")
-
-if(CMAKE_CROSSCOMPILING)
-    find_program(FLATC_EXECUTABLE flatc REQUIRED)
-    set(FLATC_CMD "${FLATC_EXECUTABLE}")
-else()
-    set(FLATC_CMD "$<TARGET_FILE:flatc>")
-endif()
-
-add_custom_command(
-    OUTPUT "${GENERATED_HEADER}"
-    COMMAND ${FLATC_CMD} --cpp -o "${PROJECT_BINARY_DIR}/generated" "${FBS_SCHEMA_FILE}"
-    DEPENDS "${FBS_SCHEMA_FILE}"
-    COMMENT "Generating C++ header from ${FBS_SCHEMA_FILE}"
-)
-
-add_custom_target(generate_flatbuffers_schema DEPENDS "${GENERATED_HEADER}")
-
 file(GLOB_RECURSE CLICE_CORE_SOURCES CONFIGURE_DEPENDS "${PROJECT_SOURCE_DIR}/src/*.cpp")
 add_library(clice-core STATIC ${CLICE_CORE_SOURCES})
 add_library(clice::core ALIAS clice-core)
-add_dependencies(clice-core generate_flatbuffers_schema)
 
 target_include_directories(clice-core PUBLIC
     "${PROJECT_SOURCE_DIR}/src"
-    "${PROJECT_BINARY_DIR}/generated"
 )
 target_link_libraries(clice-core PUBLIC
     clice_options
     llvm-libs
     spdlog::spdlog
     roaring::roaring
-    flatbuffers
     kota::ipc::lsp
     kota::codec::toml
+    kota::codec::flatbuffers
     simdjson::simdjson
 )
 

cmake/package.cmake

@@ -27,21 +27,10 @@ FetchContent_Declare(
 set(ENABLE_ROARING_TESTS OFF CACHE INTERNAL "" FORCE)
 set(ENABLE_ROARING_MICROBENCHMARKS OFF CACHE INTERNAL "" FORCE)
 
-# flatbuffers
-FetchContent_Declare(
-    flatbuffers
-    GIT_REPOSITORY https://github.com/google/flatbuffers.git
-    GIT_TAG v25.9.23
-    GIT_SHALLOW TRUE
-)
-set(FLATBUFFERS_BUILD_GRPC OFF CACHE BOOL "" FORCE)
-set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-set(FLATBUFFERS_BUILD_FLATHASH OFF CACHE BOOL "" FORCE)
-
 FetchContent_Declare(
     kotatsu
     GIT_REPOSITORY https://github.com/clice-io/kotatsu
-    GIT_TAG main
+    GIT_TAG refactor/flatbuffers-schema-driven
     GIT_SHALLOW TRUE
 )
 
@@ -50,7 +39,8 @@ set(KOTA_ENABLE_TEST OFF)
 set(KOTA_CODEC_ENABLE_SIMDJSON ON)
 set(KOTA_CODEC_ENABLE_YYJSON ON)
 set(KOTA_CODEC_ENABLE_TOML ON)
+set(KOTA_CODEC_ENABLE_FLATBUFFERS ON)
 set(KOTA_ENABLE_EXCEPTIONS OFF)
 set(KOTA_ENABLE_RTTI OFF)
 
-FetchContent_MakeAvailable(kotatsu spdlog croaring flatbuffers)
+FetchContent_MakeAvailable(kotatsu spdlog croaring)

src/index/include_graph.h

@@ -7,6 +7,7 @@
 
 #include "syntax/token.h"
 
+#include "kota/meta/annotation.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace clice {
@@ -42,7 +43,10 @@ struct IncludeGraph {
     /// Each `FileID` represents a new header context and is introduced
     /// by a new include directive. So a include directive is a new header
     /// context. A map between FileID and its include location.
-    llvm::DenseMap<clang::FileID, std::uint32_t> file_table;
+    ///
+    /// Runtime-only: `clang::FileID` is an AST-scoped handle; on-disk the
+    /// include graph is fully described by `paths` + `locations`.
+    kota::meta::skip<llvm::DenseMap<clang::FileID, std::uint32_t>> file_table;
 
     static IncludeGraph from(CompilationUnitRef unit);
 

src/index/kotatsu_adapters.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "semantic/relation_kind.h"
+#include "semantic/symbol_kind.h"
+#include "support/bitmap.h"
+
+#include "kota/codec/arena/traits.h"
+#include "kota/codec/detail/fwd.h"
+
+/// Type-level wire traits for clice index types.
+///
+/// These partially specialize the primary
+/// `kota::codec::serialize_traits<S, T>` / `deserialize_traits<D, T>`
+/// templates, constrained so only arena backends pick them up. They
+/// declare the wire representation for `T` and propagate through map
+/// values, sequence elements, and nested containers — no per-field
+/// `annotation<T, with<...>>` required.
+
+namespace kota::codec {
+
+/// `std::chrono::milliseconds` ⇄ `int64` tick count.
+template <typename S>
+    requires arena::arena_serializer_like<S>
+struct serialize_traits<S, std::chrono::milliseconds> {
+    using wire_type = std::int64_t;
+
+    static std::int64_t serialize(S&, std::chrono::milliseconds value) noexcept {
+        return value.count();
+    }
+};
+
+template <typename D>
+    requires arena::arena_deserializer_like<D>
+struct deserialize_traits<D, std::chrono::milliseconds> {
+    using wire_type = std::int64_t;
+
+    static std::chrono::milliseconds deserialize(const D&, std::int64_t value) noexcept {
+        return std::chrono::milliseconds(value);
+    }
+};
+
+/// `RelationKind` ⇄ underlying `uint32` bitflags.
+template <typename S>
+    requires arena::arena_serializer_like<S>
+struct serialize_traits<S, clice::RelationKind> {
+    using wire_type = std::uint32_t;
+
+    static std::uint32_t serialize(S&, const clice::RelationKind& k) noexcept {
+        return k.value();
+    }
+};
+
+template <typename D>
+    requires arena::arena_deserializer_like<D>
+struct deserialize_traits<D, clice::RelationKind> {
+    using wire_type = std::uint32_t;
+
+    static clice::RelationKind deserialize(const D&, std::uint32_t v) noexcept {
+        return clice::RelationKind(static_cast<clice::RelationKind::Kind>(v));
+    }
+};
+
+/// `SymbolKind` ⇄ underlying `uint8`.
+template <typename S>
+    requires arena::arena_serializer_like<S>
+struct serialize_traits<S, clice::SymbolKind> {
+    using wire_type = std::uint8_t;
+
+    static std::uint8_t serialize(S&, const clice::SymbolKind& k) noexcept {
+        return k.value();
+    }
+};
+
+template <typename D>
+    requires arena::arena_deserializer_like<D>
+struct deserialize_traits<D, clice::SymbolKind> {
+    using wire_type = std::uint8_t;
+
+    static clice::SymbolKind deserialize(const D&, std::uint8_t v) noexcept {
+        return clice::SymbolKind(v);
+    }
+};
+
+/// `clice::Bitmap` (= `roaring::Roaring`) ⇄ opaque byte blob produced by
+/// Roaring's non-portable serialization (matches the legacy wire format).
+template <typename S>
+    requires arena::arena_serializer_like<S>
+struct serialize_traits<S, clice::Bitmap> {
+    using wire_type = std::vector<std::byte>;
+
+    static std::vector<std::byte> serialize(S&, const clice::Bitmap& bitmap) {
+        std::vector<std::byte> buffer;
+        if(bitmap.isEmpty()) {
+            return buffer;
+        }
+        buffer.resize(bitmap.getSizeInBytes(false));
+        bitmap.write(reinterpret_cast<char*>(buffer.data()), false);
+        return buffer;
+    }
+};
+
+template <typename D>
+    requires arena::arena_deserializer_like<D>
+struct deserialize_traits<D, clice::Bitmap> {
+    using wire_type = std::vector<std::byte>;
+
+    static clice::Bitmap deserialize(const D&, std::vector<std::byte> bytes) {
+        if(bytes.empty()) {
+            return clice::Bitmap();
+        }
+        return clice::Bitmap::read(reinterpret_cast<const char*>(bytes.data()), false);
+    }
+};
+
+}  // namespace kota::codec