fix(build): #261 keep only $local_includes in the response file — CI caught the #247 trap one level deeper

The Windows leg failed with

  module file 'D:amcppmcpptargetx86_64-windows-msvcc1ffdc8b90b687f4pcm.cachestd.pcm'
  not found

i.e. D:\a\mcpp\mcpp\target\...\pcm.cache\std.pcm with every separator eaten.
Response-file content is tokenized GNU-style, where backslash is an ESCAPE
character. Switching escape_flag_path to generic_string() covered the -I
paths this file builds itself, but $cxxflags carries paths produced
elsewhere — flags.cppm's -fprebuilt-module-path= and module-file mappings —
which are still native-separated. Moving those off the command line broke
every `import std;`.

The fix is to scope the response file to what this file can guarantee the
form of: $local_includes only. $cxxflags / $unit_cxxflags / $asmflags stay
inline, where a backslash is just a character. That is also sufficient for
#261: the unbounded axis is one -I per dependency include dir, and the rest
of the payload is bounded. Making every flag producer emit forward slashes
would be the more general fix, but it is a much wider change than this batch
should carry, and it is not needed for the ceiling.

Only the `mcpp test` step failed, not the build: the build step runs the
bootstrap mcpp, so the freshly-built binary is first exercised when it
compiles the test targets.

Also makes e2e 118 use a portable in-place edit. Dropping its
`# requires: gcc` gate in #257 meant it ran on macOS for the first time,
where BSD sed reads `-i`'s next argument as a backup suffix and swallows the
script. The other three new e2e tests pass on macOS as-is.

Author: Sunrisepeak

src/build/ninja_backend.cppm

@@ -554,6 +554,18 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     //
     // POSIX keeps the inline form byte-identical: ARG_MAX is ample and an
     // inline command is far easier to re-run by hand when debugging.
+    //
+    // ONLY $local_includes goes in. Response-file content is tokenized
+    // GNU-style, where backslash is an ESCAPE character, so every path that
+    // moves off the command line must be forward-slashed — and the only
+    // paths whose form this file controls are the -I/-idirafter entries it
+    // builds via escape_flag_path(). $cxxflags carries paths produced
+    // elsewhere (flags.cppm's -fprebuilt-module-path=, module-file mappings)
+    // that are still native-separated; routing those through the rsp ate the
+    // separators of the std.pcm path and broke every `import std;` on the
+    // Windows CI leg. They stay inline, where a backslash is just a
+    // character. Sufficient, too: the unbounded axis #261 is about is one -I
+    // per dependency include dir, and the rest of the payload is bounded.
     // Also keyed on the msvc dialect, which only ever runs on Windows: it
     // makes the response-file shape reachable from a non-Windows test host,
     // the same over-approximation the link rules use (`separateLinker ||
@@ -576,11 +588,10 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     append("rule cxx_module\n");
     if constexpr (mcpp::platform::is_windows) {
         // Windows: skip BMI restat optimization (requires POSIX shell).
-        const auto payload = std::format(
-            " $local_includes $cxxflags $unit_cxxflags{}{}",
-            module_output_flag, module_src_flags);
-        append(std::format("  command = $cxx{} {}\n",
-                           rsp_ref(payload), compile_tail));
+        const std::string payload = " $local_includes";
+        append(std::format("  command = $cxx{} $cxxflags $unit_cxxflags{}{} {}\n",
+                           rsp_ref(payload), module_output_flag,
+                           module_src_flags, compile_tail));
         append_rspfile(payload);
         append_cxx_deps();
     } else {
@@ -604,8 +615,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
 
     append("rule cxx_object\n");
     if constexpr (mcpp::platform::is_windows) {
-        const std::string payload = " $local_includes $cxxflags $unit_cxxflags";
-        append(std::format("  command = $cxx{} {}\n",
+        const std::string payload = " $local_includes";
+        append(std::format("  command = $cxx{} $cxxflags $unit_cxxflags {}\n",
                            rsp_ref(payload), compile_tail));
         append_rspfile(payload);
     } else {
@@ -621,8 +632,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
 
     if (need_c_rule) {
         append("rule c_object\n");
-        const std::string payload = " $local_includes $cflags $unit_cflags";
-        append(std::format("  command = $cc{} {}{}\n",
+        const std::string payload = " $local_includes";
+        append(std::format("  command = $cc{} $cflags $unit_cflags {}{}\n",
                            rsp_ref(payload), c_mmd_flag, compile_tail));
         append_rspfile(payload);
         append("  description = CC $out\n");
@@ -641,17 +652,17 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         // clang emits `argument unused during compilation: '-MMD'` for every
         // such file and writes nothing, and ninja's `deps = gcc` treats an
         // absent depfile as an error. So `.s` keeps the pre-#257 shape.
-        const std::string payload = " $local_includes $asmflags $unit_asmflags";
+        const std::string payload = " $local_includes";
         append("rule asm_object\n");     // .S — preprocessed, tracks #include
-        append(std::format("  command = $cc{} {}{}\n",
+        append(std::format("  command = $cc{} $asmflags $unit_asmflags {}{}\n",
                            rsp_ref(payload), c_mmd_flag, compile_tail));
         append_rspfile(payload);
         append("  description = AS $out\n");
         append_cxx_deps();
         append("\n");
 
         append("rule asm_object_raw\n");  // .s — not preprocessed, no depfile
-        append(std::format("  command = $cc{} {}\n",
+        append(std::format("  command = $cc{} $asmflags $unit_asmflags {}\n",
                            rsp_ref(payload), compile_tail));
         append_rspfile(payload);
         append("  description = AS $out\n\n");
@@ -733,16 +744,16 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         // The scan command is strictly LONGER than the compile command for
         // the same TU (it wraps it), so it carries the same unbounded
         // include payload through the same response file (#261).
-        const std::string scanPayload = " $local_includes $cxxflags $unit_cxxflags";
+        const std::string scanPayload = " $local_includes";
         if (msvcDeps) {
             // MSVC: compiler-integrated P1689 via /scanDependencies (scan
             // only — no codegen); /TP because our module units are .cppm.
-            append(std::format("  command = $cxx{} "
+            append(std::format("  command = $cxx{} $cxxflags $unit_cxxflags "
                    "/scanDependencies $out /TP /c $in /Fo:$compile_target\n",
                    rsp_ref(scanPayload)));
         } else if (plan.scanDepsPath.empty()) {
             // GCC path: compiler-integrated P1689 scanning.
-            append(std::format("  command = $cxx{} -fmodules "
+            append(std::format("  command = $cxx{} $cxxflags $unit_cxxflags -fmodules "
                    "-fdeps-format=p1689r5 "
                    "-fdeps-file=$out -fdeps-target=$compile_target "
                    "-M -MM -MF $out.dep -E $in -o $compile_target\n",
@@ -757,7 +768,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             // overruns (#261: 48 -I entries at a deep consumer path).
             append(std::format(
                    "  command = $scan_deps -format=p1689 -o $out -- "
-                   "$cxx{} -c $in -o $compile_target\n", rsp_ref(scanPayload)));
+                   "$cxx{} $cxxflags $unit_cxxflags -c $in -o $compile_target\n",
+                   rsp_ref(scanPayload)));
         }
         append_rspfile(scanPayload);
         append("  description = SCAN $out\n\n");

tests/e2e/118_purview_include_rebuild.sh

@@ -17,6 +17,13 @@ set -e
 # Resolved before any cd: the script changes directory below.
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 
+# Portable in-place edit. This test lost its `# requires: gcc` gate in #257,
+# so it now runs on macOS too, where BSD sed reads `-i`'s next argument as a
+# backup suffix and swallows the script.
+subst() {  # subst <sed-expr> <file>
+    sed "$1" "$2" > "$2.tmp" && mv "$2.tmp" "$2"
+}
+
 TMP=$(mktemp -d)
 trap "rm -rf $TMP" EXIT
 
@@ -51,7 +58,7 @@ EOF
 out="$("$MCPP" run 2>&1 | tail -1)"
 [[ "$out" == "41" ]] || { echo "unexpected initial output: $out"; exit 1; }
 
-sed -i 's/41/42/' src/vals.inc
+subst 's/41/42/' src/vals.inc
 
 out="$("$MCPP" run 2>&1 | tail -1)"
 [[ "$out" == "42" ]] || {
@@ -83,7 +90,7 @@ EOF
 out="$("$MCPP" run 2>&1 | tail -1)"
 [[ "$out" == "42 100" ]] || { echo "unexpected output before header edit: $out"; exit 1; }
 
-sed -i 's/100/200/' src/helper.h
+subst 's/100/200/' src/helper.h
 
 out="$("$MCPP" run 2>&1 | tail -1)"
 [[ "$out" == "42 200" ]] || {
@@ -130,7 +137,7 @@ EOF
     out="$("$MCPP" run 2>&1 | tail -1)"
     [[ "$out" == "41" ]] || { echo "clang: unexpected initial output: $out"; exit 1; }
 
-    sed -i 's/41/42/' src/vals.inc
+    subst 's/41/42/' src/vals.inc
 
     out="$("$MCPP" run 2>&1 | tail -1)"
     [[ "$out" == "42" ]] || {
@@ -158,7 +165,7 @@ EOF
     out="$("$MCPP" run 2>&1 | tail -1)"
     [[ "$out" == "42 100" ]] || { echo "clang: unexpected output before header edit: $out"; exit 1; }
 
-    sed -i 's/100/200/' src/helper.h
+    subst 's/100/200/' src/helper.h
 
     out="$("$MCPP" run 2>&1 | tail -1)"
     [[ "$out" == "42 200" ]] || {

tests/unit/test_ninja_backend.cpp

@@ -637,13 +637,24 @@ TEST(NinjaBackend, CompileAndScanRulesRouteFlagsThroughRspfileUnderMsvcDialect)
 
         EXPECT_NE(body.find("@$out.rsp"), std::string::npos) << body;
         EXPECT_NE(body.find("rspfile = $out.rsp"), std::string::npos) << body;
-        EXPECT_NE(body.find("rspfile_content = $local_includes"),
+        // ONLY $local_includes may live in the response file: its content
+        // is tokenized GNU-style (backslash = escape), and those are the
+        // only paths this file forward-slashes itself. $cxxflags carries
+        // native-separated paths from flags.cppm and must stay inline —
+        // routing it through the rsp ate the separators of the std.pcm path
+        // and broke every `import std;` on Windows.
+        EXPECT_NE(body.find("rspfile_content = $local_includes\n"),
                   std::string::npos) << body;
         // The payload must not ALSO remain inline, or the ceiling stands.
         auto cmdStart = body.find("command = ");
         auto cmdEnd = body.find('\n', cmdStart);
         auto cmd = body.substr(cmdStart, cmdEnd - cmdStart);
         EXPECT_EQ(cmd.find("$local_includes"), std::string::npos) << cmd;
+        // ...and the flags that must NOT move off the command line stay there.
+        if (rule != "rule c_object\n")
+            EXPECT_NE(cmd.find("$cxxflags"), std::string::npos) << cmd;
+        else
+            EXPECT_NE(cmd.find("$cflags"), std::string::npos) << cmd;
     }
 }