build: the GNU response file doubles backslashes, because the tokenizer escapes them inside quotes too

The first form single-quoted each argument, which a POSIX shell would take
literally and this tokenizer does not: LLVM's GNU tokenizer escapes a backslash
inside quotes as well as outside, so the Windows paths still arrived with their
separators eaten. Measured with clang 22.1.8 -- a response file holding
`'-DX=a\b'` yields `X=ab`, one holding `-DX=a\\b` yields `X=a\b` -- so every
backslash is doubled, every quote escaped, and whitespace handled by quoting the
whole argument. The case states the measurement.

Author: speak-agent

src/build/build_program.cppm

@@ -430,19 +430,24 @@ std::string response_file_body(std::span<const std::string> args, bool gnuQuotin
     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
+            // GNU TOKENIZATION TREATS A BACKSLASH AS AN ESCAPE, INCLUDING INSIDE
+            // QUOTES -- which is where this differs from a POSIX shell, and where
+            // the first attempt at this function was wrong. A Windows path
+            // written plainly 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('\'');
+            // reported `no such file or directory`, and single-quoting it changed
+            // nothing. Measured with clang 22.1.8: a response file holding
+            // `'-DX=a\b'` yields `X=ab`, and one holding `-DX=a\\b` yields
+            // `X=a\b`. So every backslash is doubled and every quote escaped,
+            // and whitespace is handled by quoting the whole argument.
+            const bool quote = a.find_first_of(" \t") != std::string::npos;
+            if (quote) body.push_back('"');
             for (char c : a) {
-                if (c == '\'') body += "'\\''";
-                else body.push_back(c);
+                if (c == '\\' || c == '"') body.push_back('\\');
+                body.push_back(c);
             }
-            body += "'\n";
+            if (quote) body.push_back('"');
+            body.push_back('\n');
             continue;
         }
         // Windows tokenization (cl, clang-cl): a backslash is literal except

tests/unit/test_sources.cpp

@@ -253,20 +253,25 @@ TEST(Sources, ResponseFileQuotesForTheWindowsTokenizer) {
 }
 
 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.
+    // clang and GCC read a backslash as an escape, inside quotes as well as
+    // outside, so a Windows path survives only when every backslash is doubled.
+    // Measured with clang 22.1.8: `'-DX=a\b'` in a response file yields `X=ab`,
+    // and `-DX=a\\b` yields `X=a\b`.
     const std::vector<std::string> args{
         "-fmodule-file=mcpp=D:\\a\\p\\mcpp.pcm",
         "D:\\a\\obj\\x.o",
-        "-DNAME=it's",
+        "/Tp D:\\a\\b c\\build.mcpp",
+        R"(-DNAME="v")",
     };
     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;
+    EXPECT_EQ(std::ranges::count(body, '\n'), 4);
+    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;
+    // Whitespace is handled by quoting the whole argument; the doubling holds
+    // inside the quotes too.
+    EXPECT_NE(body.find("\"/Tp D:\\\\a\\\\b c\\\\build.mcpp\"\n"), std::string::npos) << body;
+    // A quote of the argument's own is escaped.
+    EXPECT_NE(body.find("-DNAME=\\\"v\\\"\n"), std::string::npos) << body;
 }
 
 // ── [xlings.overrides] in config.toml ───────────────────────────────────────