fix(build): 多段 glob 源文件路径在 Windows 上保持原生分隔符 (#390) (#391)

* fix(build): 多段 glob 源文件路径在 Windows 上保持原生分隔符 (#390)

manifest glob(如 `generated/modules/**/*.cppm`)用 `/` 拼路径;
MSVC 的 std::filesystem::path 保留输入分隔符原样,于是
`root / prefix` 与目录迭代子路径都是混合形式
(`...\9bca0b44ae3aa660\generated/modules\ccc.when.cppm`),
一路流入 CompileUnit::source → compile_commands.json 的 file/-c 字段,
CLion 拒绝解析。ninja 侧一律 generic_string()(全正斜杠)所以构建正常,
CDB 是第一个 .string() 消费者,缺陷只在那里显现。

新增 mcpp::modgraph::native_path_from_generic(glob.cppm),在
glob_literal_prefix / expand_dir_glob / scan_one_into / 绝对 include dir
分支 / directives::abs_against 摄入点归一化;顺带修复 build.mcpp 指令
路径与 TOML 绝对 include dir(C:/SDL2/include)同类混合问题。

单测:GlobLiteralPrefixUsesNativeSeparators / NativePathFromGeneric /
ExpandGlobMultiSegmentUsesNativeSeparators /
ExpandDirGlobMultiSegmentUsesNativeSeparators。
e2e:76 增加多段 glob 源 + Windows 原生分隔符断言;47 增加无残留引号断言。

* fix(build): #390 修复补全 —— 摄入点收敛 + emitter 兜底 + 合并去重自愈

按 review(#391) 补全同一决策的全部推导点,不再依赖「所有摄入点都被找全」:

- P1: 补上 plan.cppm expand_manifest_include_entry(绝对分支与
  generated/ 裸拼接回退)、scanner.cppm rewrite_rel_copy(cxxflags 的
  -Ithird_party/inc 通道)、flags.cppm [build] include_dirs 全局 cxxflags
  通道;并在 emit_compile_commands 加最后一层兜底:file/directory/-c/-o/-I
  统一 make_preferred,对 CDB 契约给出无条件保证。
- P2: merge_compile_commands 去重键改为归一化路径(lexically_normal +
  make_preferred),旧 CDB 里的混合分隔符条目与 fresh 原生拼写视为同一
  文件 → 升级后第一次 build 即自愈,用户无需手删 compile_commands.json。
  已在带旧条目的工程上实测:注入混合条目后重建,归零。
- P3: e2e 76 的 Windows 断言改为平台无关的「同时含 \ 与 / 即失败」
  (消掉 os.name 依赖,避免 MSYS python 假绿);新增 extra.cpp 必须进
  CDB 的 grep 守卫;python3 缺失时显式 SKIP。
- native_path_from_generic 改用标准库 make_preferred;include_dirs 绝对
  分支不再做 generic_string 窄串往返(ANSI 代码页拼不出的名字会抛,
  mcpp#230)。
- 单测:NormalizedFileKeysHealStaleSeparatorSpellings(合并自愈)、
  EmittedPathsUseNativeSeparators(emitter 兜底)、
  Plan.ExpandManifestIncludeEntryNativeSpelling(plan.cppm 摄入点,
  expand_manifest_include_entry 为此从匿名命名空间提出并导出)。

注:directives::abs_against 归一化会改写 build.mcpp 指令路径的拼写,
声明输入指纹一次性失效 → 一次多余重建,属预期。

* test(cdb): 自愈守卫此前在两个平台都空转 —— 修好它,顺带收敛 flags.cppm 的第四份 join

review 第二轮的四条:

1) NormalizedFileKeysHealStaleSeparatorSpellings 之前测不到东西。
   测试 helper `entry()` 用 std::format 手拼 JSON,而 Windows 的
   `file` 值带反斜杠 —— `...\generated\...` 里的 `\g` 不是合法 JSON
   转义,整份 fixture 无法解析。merge_compile_commands 对解析失败的
   回答是 `return std::string(fresh)`,于是三条断言在没有跑到 norm_key
   的情况下全部通过。POSIX 上则是另一种空转:stale 用
   p.generic_string(),与 fresh 的 p.string() 逐字节相同,换回修改前
   的字面串键一样能过。
   修法两处:entry() 改由 nlohmann 序列化(转义按构造保证);stale
   拼写换成 `/p/generated/./modules/a.cpp` —— `/./` 在 POSIX 上也必须
   经 lexically_normal 折叠才能与 fresh 对齐,Windows 上再叠一层
   make_preferred。cdb() 里加一条 fixture 自检,让「拼出来的 JSON 不
   可解析」这类空转以后直接红。
   已验证先红:把 norm_key 临时退回字面串键,该测试在 Linux 上失败
   (正是它原来空转的平台),恢复后 68/68。

2) emitter 兜底的范围说清楚。它覆盖 CDB schema 的路径字段与 emitter
   自己构造的 argv 位置,不覆盖 split_flags(f.cxx) 与 package 的
   cflags/cxxflags —— 对任意 flag 载荷做路径归一化本来就不安全
   (`-DPATH="/etc/x"` 里的斜杠是真的)。注释按实际范围改写。
   EmittedPathsUseNativeSeparators 里那个「以 - 开头的参数不得含 /」
   的循环在原 fixture 下遍历不到任何带路径的参数(flags 全空,只剩
   裸 -c/-o),换成填上 localIncludeDirs / localIncludeDirsAfter 后
   逐条断言 -I 与 -idirafter,POSIX 分支也一并断言。

3) flags.cppm 的 include join 收敛成一个 abs_native lambda,四处共用
   ({include_dirs, include_dirs_after} × {C/C++ 通道, NASM 通道})。
   NASM 那两处此前既没归一化分隔符,谓词也用的是 is_absolute() 而非
   has_root_path() —— 同一个 manifest 键在两个通道产出不同的路径。
   两者只在 Windows 的根相对拼法(`/x`)上有别,现在与编译器通道一致。
   够不到 CDB(.asm 单元被 emitter 显式跳过),但这正是本 PR 要终结的
   那类债。新增 NasmIncludeDirsMatchTheCxxChannelSpelling 钉住契约
   (POSIX 上是防回归守卫,Windows 上才是新断言)。

4) rewrite_rel_copy 的绝对分支不再无谓往返:没有 `/` 可改时直接返回
   原字节,不经 path 的窄转换 —— 那个转换对 ANSI 代码页拼不出的名字
   会抛 std::system_error(mcpp#230),而本 PR 刚以同一理由删掉别处的
   generic_string() 往返。

本机:mcpp build 自举通过,mcpp test 68/68,e2e 47 / 76 / 105 /
141 / 148 / 179 / 25 / 51 通过。

---------

Co-authored-by: speak-agent <x.d2learn.org@gmail.com>

Author: ZheFeng7110

src/build/compile_commands.cppm

@@ -142,16 +142,34 @@ std::vector<std::string> split_flags(std::string_view s) {
 
 namespace {
 
+// NATIVE separators for every path this emitter SPELLS ITSELF. Each ingestion
+// point (manifest globs, include_dirs, build.mcpp directives) is normalized at
+// the source, but this is the last line for the fields the CDB schema defines
+// — a path that slips through with a mixed `root\a/b` spelling (MSVC keeps
+// input `/` verbatim) breaks CLion, and "all ingestion points are covered" is
+// not a claim that can be proven once and stay true.
+//
+// It is NOT a whole-argv guarantee: the flag strings (split_flags(f.cxx), the
+// package cflags/cxxflags) pass through untouched, because normalizing an
+// arbitrary flag payload is unsafe — `-DPATH="/etc/x"` holds real slashes.
+// Those channels are normalized where they are ingested instead.
+// make_preferred() is a no-op on POSIX.
+std::string native_string(const std::filesystem::path& p) {
+    auto n = p;
+    n.make_preferred();
+    return n.string();
+}
+
 std::vector<std::string> local_include_args(const CompileUnit& cu) {
     std::vector<std::string> args;
     args.reserve(cu.localIncludeDirs.size());
     for (auto const& inc : cu.localIncludeDirs) {
-        args.push_back("-I" + inc.string());
+        args.push_back("-I" + native_string(inc));
     }
     // #249: after-dirs keep their -idirafter spelling in the compile DB so
     // tooling (clangd) reproduces the compiler's search order.
     for (auto const& inc : cu.localIncludeDirsAfter) {
-        args.push_back("-idirafter" + inc.string());
+        args.push_back("-idirafter" + native_string(inc));
     }
     return args;
 }
@@ -186,7 +204,7 @@ std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& fla
                             : isCSource   ? flags.cc
                                           : flags.cxx;
 
-        auto output_path = (plan.outputDir / cu.object).string();
+        auto output_path = native_string(plan.outputDir / cu.object);
 
         // Build arguments array.
         nlohmann::json args = nlohmann::json::array();
@@ -198,13 +216,13 @@ std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& fla
         for (auto& f : package_flag_args(cu, isCSource))
             args.push_back(std::move(f));
         args.push_back("-c");
-        args.push_back(cu.source.string());
+        args.push_back(native_string(cu.source));
         args.push_back("-o");
         args.push_back(output_path);
 
         nlohmann::json entry;
-        entry["directory"] = plan.projectRoot.string();
-        entry["file"] = cu.source.string();
+        entry["directory"] = native_string(plan.projectRoot);
+        entry["file"] = native_string(cu.source);
         entry["arguments"] = std::move(args);
         entry["output"] = output_path;
 
@@ -222,11 +240,25 @@ std::string merge_compile_commands(
     if (freshJ.is_discarded() || !freshJ.is_array())
         return std::string(fresh);
 
+    // Dedup key = the file's PATH, spelled the way a fresh plan spells it
+    // (native separators). A prior CDB written before the mixed-separator
+    // fix (#390) carries `root\generated/modules\x.cppm` entries that are
+    // the SAME file as the fresh `root\generated\modules\x.cppm` — a literal
+    // string comparison would keep both and the user's upgrade would not
+    // visibly fix anything. Normalizing makes the merge self-healing: the
+    // stale mixed entry is skipped on the first `mcpp build` after upgrade.
+    // fileExists still probes the raw spelling — Windows accepts both.
+    auto norm_key = [](std::string_view f) {
+        auto p = std::filesystem::path(std::string(f)).lexically_normal();
+        p.make_preferred();
+        return p.string();
+    };
+
     // Files the current plan already covers — those entries are authoritative.
     std::set<std::string> freshFiles;
     for (auto const& e : freshJ) {
         if (e.contains("file") && e["file"].is_string())
-            freshFiles.insert(e["file"].get<std::string>());
+            freshFiles.insert(norm_key(e["file"].get<std::string>()));
     }
 
     // Keep fresh order, then append still-valid prior entries the plan doesn't
@@ -238,7 +270,7 @@ std::string merge_compile_commands(
         for (auto const& e : existingJ) {
             if (!e.contains("file") || !e["file"].is_string()) continue;
             auto f = e["file"].get<std::string>();
-            if (freshFiles.contains(f)) continue;             // fresh wins
+            if (freshFiles.contains(norm_key(f))) continue;       // fresh wins
             if (!fileExists(std::filesystem::path(f))) continue;  // pruned
             merged.push_back(e);
         }

src/build/directives.cppm

@@ -366,7 +366,10 @@ const Def* find_by_tag(std::string_view tag) {
 }
 
 std::string abs_against(const fs::path& base, std::string_view p) {
-    fs::path pp(p);
+    // Native spelling (see mcpp::modgraph::native_path_from_generic): a
+    // directive path like `generated/modules/x` would otherwise stay mixed
+    // on MSVC and leak into include flags / the CDB.
+    fs::path pp = mcpp::modgraph::native_path_from_generic(p);
     if (pp.is_relative()) pp = base / pp;
     return pp.lexically_normal().string();
 }

src/build/flags.cppm

@@ -315,10 +315,24 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // ninja-$-escape and shell-quote per token (#234) so an include dir
     // whose name contains a space can't silently split into two shell words
     // once ninja hands the resolved command line to the shell.
+    // The one place this file turns a manifest include entry into a path.
+    // make_preferred: a multi-segment TOML entry like `generated/inc` keeps
+    // its `/` on MSVC, and the bare `projectRoot / inc` join would be MIXED —
+    // reaching both the ninja command line and the CDB's arguments (via
+    // f.cxx → split_flags). Same rule as every other manifest-path ingestion
+    // point (#390); no-op on POSIX. ONE lambda because the same join is needed
+    // four times in this function — {include_dirs, include_dirs_after} × {the
+    // C/C++ token list, the NASM one} — and re-deriving it per site is how the
+    // two channels drifted apart in the first place.
+    auto abs_native = [&](const std::filesystem::path& inc) {
+        auto p = inc.has_root_path() ? inc : (plan.projectRoot / inc);
+        p.make_preferred();
+        return p;
+    };
+
     std::vector<std::string> includeTokens;
     for (auto& inc : plan.manifest.buildConfig.includeDirs) {
-        std::filesystem::path p = inc.has_root_path() ? inc : (plan.projectRoot / inc);
-        includeTokens.push_back(include_token(d, p));
+        includeTokens.push_back(include_token(d, abs_native(inc)));
     }
     // #249: `[build] include_dirs_after` — searched AFTER the toolchain's
     // system dirs via -idirafter (gcc+clang), so entries can't shadow
@@ -327,10 +341,8 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // (documented degradation; clang-MSVC uses the gnu dialect).
     const bool msvcInclude = d.includePrefix == std::string_view("/I");
     for (auto& inc : plan.manifest.buildConfig.includeDirsAfter) {
-        std::filesystem::path ip(inc);
-        std::filesystem::path p = ip.has_root_path() ? ip : (plan.projectRoot / ip);
         includeTokens.push_back(
-            include_token(d, p, msvcInclude ? "/I" : "-idirafter"));
+            include_token(d, abs_native(inc), msvcInclude ? "/I" : "-idirafter"));
     }
     std::string include_flags;
     for (auto& t : includeTokens) {
@@ -529,17 +541,22 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     // re-spelt with -I regardless of dialect (nasm ≥2.14 inserts a missing
     // path separator itself); DWARF debug info exists on ELF only.
     if (!plan.nasmPath.empty()) {
+        // Same abs_native join as the C/C++ channel above — one decision, one
+        // implementation. Two knock-on effects, both wanted: the entry is now
+        // spelt with native separators (#390), and the "already rooted?" test
+        // becomes has_root_path() instead of is_absolute(), so a root-relative
+        // `/x` entry is left alone here exactly as it is for the C/C++ include
+        // list. The two predicates only differ on Windows, and only for that
+        // spelling — where NASM disagreeing with the compiler about the SAME
+        // `include_dirs` key was the bug, not the feature.
         std::string nasm_includes;
         for (auto& inc : plan.manifest.buildConfig.includeDirs) {
-            auto abs = inc.is_absolute() ? inc : (plan.projectRoot / inc);
-            nasm_includes += " -I" + escape_path(abs);
+            nasm_includes += " -I" + escape_path(abs_native(inc));
         }
         // #249: nasm has no system header dirs to defer to — after-dirs
         // degrade to plain -I appended at the end.
         for (auto& inc : plan.manifest.buildConfig.includeDirsAfter) {
-            std::filesystem::path ip(inc);
-            auto abs = ip.is_absolute() ? ip : (plan.projectRoot / ip);
-            nasm_includes += " -I" + escape_path(abs);
+            nasm_includes += " -I" + escape_path(abs_native(inc));
         }
         std::string nasm_debug;
         if (prof.debug && plan.nasmFormat.starts_with("elf"))

src/build/plan.cppm

@@ -220,6 +220,14 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
          // simply makes those units uncacheable.
          const std::vector<std::filesystem::path>& storeRoots = {});
 
+// Expand one manifest `include_dirs` entry against the project root — the
+// #249 consistency join + the expand_dir_glob the dep path uses. Exported
+// (like modgraph's glob_literal_prefix) so unit tests can assert its
+// native-separator contract directly; see the definition below.
+std::vector<std::filesystem::path>
+expand_manifest_include_entry(const std::filesystem::path& root,
+                              const std::filesystem::path& inc);
+
 } // namespace mcpp::build
 
 namespace mcpp::build {
@@ -368,22 +376,42 @@ std::vector<std::string> shared_library_link_flags(
     return flags;
 }
 
+}  // namespace
+
 // #249 consistency fix: expand include_dirs entries with the same
 // `expand_dir_glob` the dep path (prepare.cppm) uses, so a main-manifest
 // `include_dirs = ["*/include"]` glob works identically here. For a literal
 // (wildcard-free) entry expand_dir_glob only returns EXISTING directories,
 // whereas this helper historically joined unconditionally — keep the plain
 // join as a fallback so an -I for a dir created later (e.g. by a build
 // step) isn't silently dropped.
+//
+// Deliberately OUTSIDE the anonymous namespace: it is exported for its unit
+// test (like modgraph's glob_literal_prefix), and the two
+// local_include_dirs_*_for_manifest consumers below ride along so a single
+// namespace split serves the whole trio.
 std::vector<std::filesystem::path>
 expand_manifest_include_entry(const std::filesystem::path& root,
                               const std::filesystem::path& inc)
 {
-    if (inc.is_absolute()) return { inc };
+    if (inc.is_absolute()) {
+        // A TOML value like `C:/SDL2/include` keeps its `/` on MSVC — make
+        // it native so the CDB's -I (via local_include_args) is uniform.
+        auto n = inc;
+        n.make_preferred();
+        return { std::move(n) };
+    }
     const auto glob = inc.generic_string();
     auto expanded = mcpp::modgraph::expand_dir_glob(root, glob);
-    if (expanded.empty() && glob.find('*') == std::string::npos)
-        expanded.push_back(root / inc);
+    if (expanded.empty() && glob.find('*') == std::string::npos) {
+        // Same native-spelling rule for the bare join (see above): `root / p`
+        // with a multi-segment `generated/inc` is MIXED on MSVC, and this
+        // fallback exists precisely for dirs like `generated/` that a later
+        // build step creates — the #390 shape.
+        auto joined = root / inc;
+        joined.make_preferred();
+        expanded.push_back(std::move(joined));
+    }
     return expanded;
 }
 
@@ -412,6 +440,8 @@ local_include_dirs_after_for_manifest(const std::filesystem::path& root,
     return dirs;
 }
 
+namespace {
+
 void append_unique_path(std::vector<std::filesystem::path>& out,
                         std::filesystem::path path)
 {

src/build/prepare.cppm

@@ -16,6 +16,7 @@ import mcpp.platform.axis;
 import mcpp.libs.json;
 import mcpp.log;
 import mcpp.manifest;
+import mcpp.modgraph.glob;
 import mcpp.modgraph.graph;
 import mcpp.modgraph.scanner;
 import mcpp.modgraph.validate;
@@ -2996,7 +2997,13 @@ prepare_build(bool print_fingerprint,
         std::vector<std::filesystem::path> dirs;
         for (auto const& inc : manifest.buildConfig.includeDirs) {
             if (inc.is_absolute()) {
-                appendUniquePath(dirs, inc);
+                // Native spelling: a TOML `C:/SDL2/include` stays mixed on
+                // MSVC and leaks into the CDB's -I otherwise. Direct
+                // make_preferred — no generic_string round trip, which can
+                // throw for names the ANSI codepage cannot spell (mcpp#230).
+                auto n = inc;
+                n.make_preferred();
+                appendUniquePath(dirs, std::move(n));
                 continue;
             }
             for (auto& dir : mcpp::modgraph::expand_dir_glob(
@@ -3016,7 +3023,9 @@ prepare_build(bool print_fingerprint,
         std::vector<std::filesystem::path> dirs;
         for (auto const& inc : manifest.buildConfig.includeDirsAfter) {
             if (inc.is_absolute()) {
-                appendUniquePath(dirs, inc);
+                auto n = inc;
+                n.make_preferred();
+                appendUniquePath(dirs, std::move(n));
                 continue;
             }
             for (auto& dir : mcpp::modgraph::expand_dir_glob(

src/modgraph/glob.cppm

@@ -12,6 +12,26 @@ import std;
 
 export namespace mcpp::modgraph {
 
+// Convert a manifest-style path or glob prefix (always spelled with the
+// generic `/` separator) to the platform's native spelling.
+//
+// MSVC's std::filesystem::path preserves the separators of the string it
+// was constructed from instead of normalizing them, so wrapping a raw
+// `generated/modules` in a path and joining it with `root / p` yields the
+// MIXED `C:\...\generated/modules` — and the directory-walk children built
+// on top of that stay mixed. `.string()` then carries the mixed form into
+// `compile_commands.json` (its `file` / `-c` fields), which CLion refuses
+// to parse. Ninja never notices because it renders everything via
+// generic_string(); the CDB is the first `.string()` consumer.
+//
+// POSIX is untouched (`make_preferred()` is a no-op there, and it is also
+// safe for already-native Windows input, which never contains `/`).
+std::filesystem::path native_path_from_generic(std::string_view s) {
+    std::filesystem::path p(s);
+    p.make_preferred();
+    return p;
+}
+
 // Does `candidate` match `glob`, interpreted relative to `root`?
 //
 // Supports "**" (any number of directory levels) and "*" (within one segment).

src/modgraph/scanner.cppm

@@ -268,7 +268,12 @@ std::filesystem::path glob_literal_prefix(std::string_view glob) {
         ? glob : glob.substr(0, wildcard);
     auto slash = literal.find_last_of('/');
     if (slash == std::string_view::npos) return {};
-    return std::filesystem::path(literal.substr(0, slash));
+    // Native separators, not the raw generic form: MSVC keeps the input's
+    // `/` verbatim, and `root / p` plus the directory walk then propagate a
+    // MIXED `root\generated/modules` into every downstream path — which is
+    // what `compile_commands.json`'s `file` field showed on Windows for
+    // multi-segment globs. See mcpp::modgraph::native_path_from_generic.
+    return native_path_from_generic(literal.substr(0, slash));
 }
 
 // mcpp#228: `{a,b}` alternation, recursively. Finds the first top-level `{`,
@@ -442,7 +447,9 @@ std::vector<std::filesystem::path> expand_dir_glob(const std::filesystem::path&
     // expand_glob) — include_dirs entries are meant to name one literal
     // directory each; a caller wanting alternatives lists multiple entries.
     if (glob.find('*') == std::string_view::npos) {
-        auto p = root / std::filesystem::path(glob);
+        // Native spelling (see native_path_from_generic — a raw `a/b` would
+        // come back mixed from .string() on MSVC).
+        auto p = root / native_path_from_generic(glob);
         if (std::filesystem::is_directory(p, ec)) out.push_back(p);
         return out;
     }
@@ -494,10 +501,24 @@ namespace {
 
 // has_root_path: leave absolute AND root-relative ("/x" on Windows)
 // spellings alone — only genuinely root-less paths are project-relative.
+// Both branches normalize to NATIVE separators: a `-Ithird_party/inc` cxxflag
+// would otherwise come back as `C:\proj\third_party/inc` on MSVC (path keeps
+// the input `/` verbatim) and reach the CDB's arguments via packageCxxflags.
 std::string rewrite_rel_copy(const std::string& p, const std::filesystem::path& root) {
     std::filesystem::path fp(p);
-    if (fp.has_root_path()) return p;
-    return (root / fp).string();
+    if (fp.has_root_path()) {
+        // Nothing to re-spell → hand back the ORIGINAL bytes rather than
+        // round-tripping them through path's narrow conversion, which throws
+        // std::system_error for names the ANSI codepage cannot express
+        // (mcpp#230 — see path_matches_glob). A rooted path with no '/' is
+        // already native on both platform families.
+        if (p.find('/') == std::string::npos) return p;
+        fp.make_preferred();
+        return fp.string();
+    }
+    auto joined = root / fp;
+    joined.make_preferred();
+    return joined.string();
 }
 
 void rewrite_rel(std::string& p, const std::filesystem::path& root) {
@@ -682,7 +703,14 @@ local_include_dirs_for(const std::filesystem::path& root,
     std::vector<std::filesystem::path> dirs;
     for (auto const& inc : manifest.buildConfig.includeDirs) {
         if (inc.is_absolute()) {
-            dirs.push_back(inc);
+            // A TOML value like `C:/SDL2/include` keeps its `/` on MSVC —
+            // normalize so the CDB's -I comes out native (mixed separators
+            // break CLion). Direct make_preferred, no generic_string round
+            // trip: the narrow conversion can throw for names the ANSI
+            // codepage cannot spell (mcpp#230).
+            auto n = inc;
+            n.make_preferred();
+            dirs.push_back(std::move(n));
             continue;
         }
         for (auto& d : expand_dir_glob(root, inc.generic_string())) {
@@ -701,7 +729,9 @@ local_include_dirs_after_for(const std::filesystem::path& root,
     std::vector<std::filesystem::path> dirs;
     for (auto const& inc : manifest.buildConfig.includeDirsAfter) {
         if (inc.is_absolute()) {
-            dirs.push_back(inc);
+            auto n = inc;
+            n.make_preferred();
+            dirs.push_back(std::move(n));
             continue;
         }
         for (auto& d : expand_dir_glob(root, inc.generic_string())) {
@@ -738,7 +768,10 @@ void scan_one_into(ScanResult& result,
             // Literal absolute entry — e.g. a dependency build.mcpp's OUT_DIR
             // generated source, which lives OUTSIDE the (possibly read-only)
             // package root. No glob expansion; taken as-is when it exists.
-            if (std::filesystem::path gp(g); gp.is_absolute()) {
+            // Native spelling: a raw `C:/abs/x.cppm` would stay mixed on MSVC
+            // (see native_path_from_generic) and leak into the CDB.
+            auto gp = native_path_from_generic(g);
+            if (gp.is_absolute()) {
                 std::error_code aec;
                 if (std::filesystem::is_regular_file(gp, aec)) all_files.insert(gp);
                 continue;