fix: an MSVC module map writes each /reference with its value on one line, which is how cl.exe reads a command file

Author: speak-agent

src/build/ninja_backend.cppm

@@ -299,18 +299,24 @@ bool msvc_module_spelling(const BuildPlan& plan) {
     return !prefix.empty() && prefix.back() == ' ';
 }
 
-// The text of a module map's argument file (B1): one argument per line. clang
-// reads it by GNU rules on every host (#247), where a word holding a space or
-// a quote is written in double quotes with `\` and `"` escaped; the paths are
+// The text of a module map's argument file (B1). clang reads it by GNU rules on
+// every host (#247), one argument per line, where a word holding a space or a
+// quote is written in double quotes with `\` and `"` escaped; the paths are
 // written with forward slashes, so a backslash does not occur. MSVC reads it
 // by its own rules (`shell_quote_arg` on a Windows host) and needs the byte
-// order mark to read a path that is not ASCII (#693).
+// order mark to read a path that is not ASCII (#693). Its arguments come in
+// pairs, `/reference` and `<name>=<path>`, and each pair is one line: cl.exe
+// does not take an option's value from the next line of a command file
+// (`D8004: '/reference' requires an argument`, measured on windows-2025).
 std::string module_map_arguments(const std::vector<std::string>& arguments, bool msvc) {
     std::string out = msvc ? std::string(kUtf8ByteOrderMark) : std::string{};
+    if (msvc) {
+        for (std::size_t i = 0; i + 1 < arguments.size(); i += 2)
+            out += arguments[i] + " " + mcpp::build::shell_quote_arg(arguments[i + 1]) + "\n";
+        return out;
+    }
     for (auto const& a : arguments) {
-        if (msvc) {
-            out += mcpp::build::shell_quote_arg(a);
-        } else if (a.find_first_of(" \t\"'\\") == std::string::npos) {
+        if (a.find_first_of(" \t\"'\\") == std::string::npos) {
             out += a;
         } else {
             out += '"';

tests/unit/test_module_address.cpp

@@ -19,6 +19,7 @@
 
 import std;
 import mcpp.build.plan;
+import mcpp.build.ninja;
 import mcpp.manifest;
 import mcpp.modgraph.graph;
 import mcpp.modgraph.scanner;
@@ -310,3 +311,47 @@ TEST(ModuleAddress, EveryNamedArgumentFileIsOneThePlanStates) {
     // another package or of a member.
     EXPECT_EQ(named, 3u);
 }
+
+// The argument file of a module map, as each compiler reads it. MSVC takes an
+// option's value only from the same line of a command file (`D8004: '/reference'
+// requires an argument` on windows-2025 when they were on two lines), and reads
+// a non-ASCII path only with a byte order mark; clang reads GNU rules, where a
+// word with a space is quoted.
+TEST(ModuleAddress, ArgumentFilesAreWrittenAsEachCompilerReadsThem) {
+    Tmp t;
+    auto read = [](const std::filesystem::path& p) {
+        std::ifstream in(p, std::ios::binary);
+        return std::string(std::istreambuf_iterator<char>(in), {});
+    };
+
+    BuildPlan msvc;
+    msvc.outputDir = t.path / "msvc";
+    msvc.toolchain.compiler = mcpp::toolchain::CompilerId::MSVC;
+    ModuleScope ms;
+    ms.mapFile = "modmap/core-1.map";
+    ms.content = "m ifc.cache/core/m.ifc\n";
+    ms.argsFile = "modmap/core-1.modmap";
+    ms.arguments = {"/reference", "m=C:/build/ifc.cache/core/m.ifc",
+                    "/reference", "n=C:/build/ifc.cache/core/n.ifc"};
+    msvc.moduleScopes.emplace("core-1", ms);
+    write_module_maps(msvc);
+    EXPECT_EQ(read(msvc.outputDir / "modmap/core-1.modmap"),
+              "\xEF\xBB\xBF/reference m=C:/build/ifc.cache/core/m.ifc\n"
+              "/reference n=C:/build/ifc.cache/core/n.ifc\n");
+    EXPECT_EQ(read(msvc.outputDir / "modmap/core-1.map"), ms.content);
+
+    BuildPlan clang;
+    clang.outputDir = t.path / "clang";
+    clang.toolchain.compiler = mcpp::toolchain::CompilerId::Clang;
+    ModuleScope cs;
+    cs.mapFile = "modmap/core-2.map";
+    cs.content = "m pcm.cache/core/m.pcm\n";
+    cs.argsFile = "modmap/core-2.modmap";
+    cs.arguments = {"-fmodule-file=m=/build dir/pcm.cache/core/m.pcm",
+                    "-fmodule-file=n=/build/pcm.cache/core/n.pcm"};
+    clang.moduleScopes.emplace("core-2", cs);
+    write_module_maps(clang);
+    EXPECT_EQ(read(clang.outputDir / "modmap/core-2.modmap"),
+              "\"-fmodule-file=m=/build dir/pcm.cache/core/m.pcm\"\n"
+              "-fmodule-file=n=/build/pcm.cache/core/n.pcm\n");
+}