build: the response file is written in the grammar its driver reads

A response file is not one format. clang and GCC tokenize it the GNU way, where
a backslash escapes the next character, so the Windows paths written plainly came
back with their separators eaten:

    clang++: error: no such file or directory:
      'D:amcpp-pluginsmcpp-pluginstestsall-rules-compiletarget.build-mcpp...'

Each argument is therefore wrapped in single quotes for those drivers, inside
which nothing is special, and an embedded single quote is closed, escaped and
reopened; cl and clang-cl keep Windows quoting, where a backslash is literal.
One case per grammar.

Author: speak-agent

src/build/build_program.cppm

@@ -426,9 +426,27 @@ struct BuildProgramEnv {
 // The suffix selects the fact: `DIR` (the payload directory), `SOURCE` and
 // `PROGRAM` (where it came from, mcpp#755), read back by `xpkg_source` and
 // `xpkg_program`.
-std::string response_file_body(std::span<const std::string> args) {
+std::string response_file_body(std::span<const std::string> args, bool gnuQuoting) {
     std::string body;
     for (auto const& a : args) {
+        if (gnuQuoting) {
+            // GNU TOKENIZATION TREATS A BACKSLASH AS AN ESCAPE, everywhere but
+            // inside single quotes. A Windows path written plainly therefore
+            // arrives with its separators eaten -- clang read
+            // `D:\a\mcpp-plugins\...` back as `D:amcpp-plugins...` and
+            // reported `no such file or directory`. Inside single quotes every
+            // character is literal, so each argument is wrapped, and an embedded
+            // single quote is closed, escaped and reopened.
+            body.push_back('\'');
+            for (char c : a) {
+                if (c == '\'') body += "'\\''";
+                else body.push_back(c);
+            }
+            body += "'\n";
+            continue;
+        }
+        // Windows tokenization (cl, clang-cl): a backslash is literal except
+        // before a quote, so only whitespace and quotes need handling.
         if (a.find_first_of(" \t\"") == std::string::npos) {
             body += a;
             body.push_back('\n');
@@ -465,16 +483,17 @@ inline std::string xpkg_env_var(std::string_view ns, std::string_view name,
     return out;
 }
 
-// THE ARGV THAT PASSES `args` THROUGH A RESPONSE FILE, and the file's content.
+// THE CONTENT OF A RESPONSE FILE CARRYING `args`, one argument per line.
 //
-// Every compiler driver mcpp supports reads `@file` with one argument per line.
-// An argument that carries whitespace or a quote is quoted, and the backslashes
-// before a quote -- including a run that would otherwise escape the closing one
-// -- are escaped, which is what makes a Windows path safe to write here.
+// Every compiler driver mcpp supports reads `@file`, but not with one grammar:
+// clang and GCC tokenize it the GNU way, where a backslash escapes the next
+// character, and cl and clang-cl tokenize it the Windows way, where a backslash
+// is literal. `gnuQuoting` picks between them -- single quotes, inside which
+// nothing is special, or Windows quoting of whitespace and quotes.
 //
 // Exported because its quoting is the part worth testing, and the command it
 // serves cannot be run on a host whose limit it does not cross.
-std::string response_file_body(std::span<const std::string> args);
+std::string response_file_body(std::span<const std::string> args, bool gnuQuoting);
 
 // Does a compiler's output say the program asked for something the bundled
 // `mcpp` module does not have?
@@ -1914,7 +1933,7 @@ std::expected<void, std::string> run_build_program_impl(
                     flat, mcpp::platform::is_windows, /*needsShell=*/true)) {
                 const auto rsp = bdir / "build.mcpp.compile.rsp";
                 const auto body = response_file_body(
-                    std::span<const std::string>(compileArgv).subspan(1));
+                    std::span<const std::string>(compileArgv).subspan(1), !msvcHost);
                 std::ofstream out(rsp, std::ios::binary | std::ios::trunc);
                 out << body;
                 out.close();

tests/unit/test_sources.cpp

@@ -235,27 +235,40 @@ TEST(Sources, OverrideVersionIsCheckedAgainstRequirements) {
 
 // ── The response file a long compile command goes through ───────────────────
 
-TEST(Sources, ResponseFileWritesOneArgumentPerLineAndQuotesWhatNeedsIt) {
+TEST(Sources, ResponseFileQuotesForTheWindowsTokenizer) {
     const std::vector<std::string> args{
         "-std=c++23",
-        "-fmodule-file=mcpp=/home/u/p/mcpp.pcm",
         "/Tp C:/Program Files/x/build.mcpp",
         R"(-DNAME="v")",
         "C:\\with space\\dir\\",
     };
-    const auto body = mcpp::build::response_file_body(args);
-    EXPECT_EQ(std::ranges::count(body, '\n'), 5);
+    const auto body = mcpp::build::response_file_body(args, /*gnuQuoting=*/false);
+    EXPECT_EQ(std::ranges::count(body, '\n'), 4);
     EXPECT_NE(body.find("-std=c++23\n"), std::string::npos) << body;
-    // Quoted only where it has to be.
-    EXPECT_NE(body.find("-fmodule-file=mcpp=/home/u/p/mcpp.pcm\n"), std::string::npos) << body;
     EXPECT_NE(body.find("\"/Tp C:/Program Files/x/build.mcpp\"\n"), std::string::npos) << body;
-    // A quote inside the argument survives as one.
     EXPECT_NE(body.find("\"-DNAME=\\\"v\\\"\"\n"), std::string::npos) << body;
     // The run of backslashes that ends the argument is doubled, so it does not
     // escape the closing quote.
     EXPECT_NE(body.find("\"C:\\with space\\dir\\\\\"\n"), std::string::npos) << body;
 }
 
+TEST(Sources, ResponseFileKeepsBackslashesLiteralForTheGnuTokenizer) {
+    // clang and GCC read a backslash as an escape, so a Windows path written
+    // plainly comes back with its separators eaten; inside single quotes
+    // nothing is special.
+    const std::vector<std::string> args{
+        "-fmodule-file=mcpp=D:\\a\\p\\mcpp.pcm",
+        "D:\\a\\obj\\x.o",
+        "-DNAME=it's",
+    };
+    const auto body = mcpp::build::response_file_body(args, /*gnuQuoting=*/true);
+    EXPECT_EQ(std::ranges::count(body, '\n'), 3);
+    EXPECT_NE(body.find("'-fmodule-file=mcpp=D:\\a\\p\\mcpp.pcm'\n"), std::string::npos) << body;
+    EXPECT_NE(body.find("'D:\\a\\obj\\x.o'\n"), std::string::npos) << body;
+    // A single quote in the argument closes, escapes and reopens.
+    EXPECT_NE(body.find("'-DNAME=it'\\''s'\n"), std::string::npos) << body;
+}
+
 // ── [xlings.overrides] in config.toml ───────────────────────────────────────
 
 TEST(Sources, ConfigOverridesParseWithTheManifestsTwoShapes) {