fix: invalid module units

Author: tsurumi-yizhou

.github/workflows/generate-docs.yml

@@ -32,6 +32,9 @@ jobs:
           restore-keys: |
             Windows-sccache-
 
+      - name: Start sccache
+        run: sccache --start-server
+
       - name: Build
         run: pixi run build
 
@@ -55,5 +58,4 @@ jobs:
           retention-days: 30
 
       - name: Stop sccache
-        if: always()
-        run: pixi run -- sccache --stop-server 2>$null
+        run: sccache --stop-server

cmake/toolchain.cmake

@@ -3,6 +3,11 @@ cmake_minimum_required(VERSION 3.30)
 set(CMAKE_C_COMPILER clang CACHE STRING "")
 set(CMAKE_CXX_COMPILER clang++ CACHE STRING "")
 
+find_program(CLANG_SCAN_DEPS_PATH "clang-scan-deps")
+if(CLANG_SCAN_DEPS_PATH)
+    set(CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS "${CLANG_SCAN_DEPS_PATH}" CACHE FILEPATH "")
+endif()
+
 find_program(LLVM_AR_PATH "llvm-ar")
 if(LLVM_AR_PATH)
     set(CMAKE_AR "${LLVM_AR_PATH}" CACHE FILEPATH "")

src/CMakeLists.txt

@@ -5,17 +5,9 @@ file(GLOB_RECURSE CLORE_MODULE_SOURCES CONFIGURE_DEPENDS
     "${CMAKE_CURRENT_SOURCE_DIR}/support/*.cppm"
 )
 
-# ── locate clang-scan-deps (required for C++20 module compilation) ───
-find_program(CLANG_SCAN_DEPS_EXE
-    NAMES clang-scan-deps
-    HINTS
-        "${CMAKE_CXX_COMPILER}/../"
-        "$ENV{CONDA_PREFIX}/Library/bin"
-        "$ENV{CONDA_PREFIX}/bin"
-)
-if(CLANG_SCAN_DEPS_EXE)
-    set(CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS "${CLANG_SCAN_DEPS_EXE}" CACHE FILEPATH "" FORCE)
-    message(STATUS "Found clang-scan-deps: ${CLANG_SCAN_DEPS_EXE}")
+# ── report clang-scan-deps configuration for C++20 module compilation ───
+if(CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS)
+    message(STATUS "Found clang-scan-deps: ${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}")
 else()
     message(STATUS "clang-scan-deps not found; will rely on CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS cache")
 endif()

src/extract/ast.cppm

@@ -4,6 +4,7 @@ module;
 #include <cstdint>
 #include <expected>
 #include <format>
+#include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>

src/extract/compdb.cppm

@@ -1,5 +1,6 @@
 module;
 
+#include <algorithm>
 #include <expected>
 #include <filesystem>
 #include <format>

src/extract/extract.cppm

@@ -287,21 +287,22 @@ auto rebuild_model_indexes(const config::TaskConfig& config, ProjectModel& model
 
 /// Populate module information from scan cache into the project model.
 auto build_module_info(ProjectModel& model, const ScanCache& scan_cache) -> void {
+    namespace fs = std::filesystem;
+
     for(auto& [file_path, scan_result] : scan_cache) {
         if(scan_result.module_name.empty()) continue;
 
         model.uses_modules = true;
 
-        auto& mod_unit = model.modules[scan_result.module_name];
+        auto source_file = fs::path(file_path).lexically_normal().generic_string();
+        auto& mod_unit = model.modules[source_file];
         mod_unit.name = scan_result.module_name;
         mod_unit.is_interface = scan_result.is_interface_unit;
-        mod_unit.source_file = file_path;
+        mod_unit.source_file = source_file;
         mod_unit.imports = scan_result.module_imports;
 
         // Associate symbols from that file to this module unit
-        namespace fs = std::filesystem;
-        auto generic_path = fs::path(file_path).generic_string();
-        auto file_it = model.files.find(generic_path);
+        auto file_it = model.files.find(source_file);
         if(file_it != model.files.end()) {
             mod_unit.symbols = file_it->second.symbols;
         }
@@ -398,38 +399,29 @@ auto extract_project(const config::TaskConfig& config)
         current_file_info.path = normalized;
         std::size_t includes_kept = 0;
 
-        if(cache_it != scan_cache.end()) {
-            for(auto& inc : cache_it->second.includes) {
-                namespace fs = std::filesystem;
-                auto inc_path = fs::path(inc.path);
-                if(inc_path.is_relative()) {
-                    inc_path = fs::path(entry.directory) / inc_path;
-                }
-                inc_path = inc_path.lexically_normal();
-                if(matches_filter(inc_path.string(), config.filter, filter_root)) {
-                    append_unique(current_file_info.includes, inc_path.generic_string());
-                    ++includes_kept;
-                }
-            }
-        } else {
+        if(cache_it == scan_cache.end()) {
             logging::warn("scan cache miss for {}, re-scanning", entry.file);
             auto scan_result = scan_file(entry);
             if(!scan_result.has_value()) {
                 return std::unexpected(ExtractError{
                     .message = std::format("failed to scan includes for {}: {}",
                                            entry.file, scan_result.error().message)});
             }
-            for(auto& inc : scan_result->includes) {
-                namespace fs = std::filesystem;
-                auto inc_path = fs::path(inc.path);
-                if(inc_path.is_relative()) {
-                    inc_path = fs::path(entry.directory) / inc_path;
-                }
-                inc_path = inc_path.lexically_normal();
-                if(matches_filter(inc_path.string(), config.filter, filter_root)) {
-                    append_unique(current_file_info.includes, inc_path.generic_string());
-                    ++includes_kept;
-                }
+
+            auto [rescanned_it, _] = scan_cache.insert_or_assign(cache_key, std::move(*scan_result));
+            cache_it = rescanned_it;
+        }
+
+        for(auto& inc : cache_it->second.includes) {
+            namespace fs = std::filesystem;
+            auto inc_path = fs::path(inc.path);
+            if(inc_path.is_relative()) {
+                inc_path = fs::path(entry.directory) / inc_path;
+            }
+            inc_path = inc_path.lexically_normal();
+            if(matches_filter(inc_path.string(), config.filter, filter_root)) {
+                append_unique(current_file_info.includes, inc_path.generic_string());
+                ++includes_kept;
             }
         }
 
@@ -510,9 +502,9 @@ auto extract_project(const config::TaskConfig& config)
     build_module_info(model, scan_cache);
     if(model.uses_modules) {
         logging::info("detected {} module units", model.modules.size());
-        for(auto& [name, mod] : model.modules) {
+        for(auto& [source_file, mod] : model.modules) {
             logging::info("  module '{}' (interface={}) from {}",
-                          name, mod.is_interface, mod.source_file);
+                          mod.name, mod.is_interface, source_file);
         }
     }
 

src/extract/model.cppm

@@ -86,7 +86,7 @@ struct ProjectModel {
 
     std::vector<std::string> file_order;
 
-    /// Module units indexed by module name (e.g. "foo", "foo:bar").
+    /// Module units indexed by normalized source file path.
     std::unordered_map<std::string, ModuleUnit> modules;
 
     /// True if the project uses C++20 modules (at least one module declaration found).

src/extract/scan.cppm

@@ -5,6 +5,7 @@ module;
 #include <filesystem>
 #include <format>
 #include <fstream>
+#include <memory>
 #include <queue>
 #include <string>
 #include <string_view>
@@ -82,6 +83,31 @@ namespace clore::extract {
 
 namespace {
 
+auto append_unique_import(ScanResult& result, std::string import_name) -> void {
+    if(std::ranges::find(result.module_imports, import_name) != result.module_imports.end()) {
+        return;
+    }
+    result.module_imports.push_back(std::move(import_name));
+}
+
+auto normalize_partition_import(std::string_view current_module_name,
+                                std::string import_name) -> std::string {
+    if(import_name.starts_with(':') && !current_module_name.empty()) {
+        auto main_name = current_module_name;
+        if(auto colon_pos = current_module_name.find(':'); colon_pos != std::string::npos) {
+            main_name = current_module_name.substr(0, colon_pos);
+        }
+
+        std::string normalized;
+        normalized.reserve(main_name.size() + import_name.size());
+        normalized += main_name;
+        normalized += import_name;
+        return normalized;
+    }
+
+    return import_name;
+}
+
 class ScanPPCallbacks : public clang::PPCallbacks {
 public:
     ScanResult& result;
@@ -187,7 +213,9 @@ auto scan_module_decl(std::string_view file_content, ScanResult& result) -> void
             }
 
             if(!import_name.empty()) {
-                result.module_imports.push_back(std::move(import_name));
+                append_unique_import(result,
+                                     normalize_partition_import(result.module_name,
+                                                                std::move(import_name)));
             }
         }
     }

src/extract/symbol.cppm

@@ -1,5 +1,6 @@
 module;
 
+#include <compare>
 #include <cstdint>
 #include <functional>
 #include <string>