fix(flags): do not re-quote mcpp-generated link flags — restore rpath $ORIGIN

C3's shell_quote_arg (#234, for compile-time defines-with-spaces) was applied
to per-unit LINK flags too, double-quoting the already-escaped rpath token
`-Wl,-rpath,'$$ORIGIN'` → literal `'$ORIGIN'` in RUNPATH → dependency .so's
next to the exe couldn't be resolved (e2e 55/56/57/64 regressed vs 0.0.96).
join_flags gains shellQuote (default true for user compile flags); the
link-flag join passes false. Regression test locks it.

Author: Sunrisepeak

src/build/ninja_backend.cppm

@@ -96,18 +96,27 @@ std::string local_include_flags(const CompileUnit& cu) {
     return flags;
 }
 
-std::string join_flags(const std::vector<std::string>& flags) {
+std::string join_flags(const std::vector<std::string>& flags,
+                        bool shellQuote = true) {
     // mcpp#234: each vector element is already one argv token (e.g. a
     // manifest define `T=long long` arrives here as the single element
     // `-DT=long long`, pushed whole by apply_glob_flags) — but joining with
     // a bare space and no quoting let the embedded space split it into two
     // words once ninja handed the resolved command line to the shell.
     // shell_quote_arg is a no-op for tokens with nothing shell-significant
     // (`-std=c++23`, `-O2`, ...), so plain flags are untouched.
+    //
+    // shellQuote=false for mcpp-GENERATED link flags (lu.linkFlags): those
+    // are already correctly shell-quoted + ninja-escaped at construction
+    // (e.g. the rpath token `-Wl,-rpath,'$$ORIGIN'` from plan.cppm — single
+    // quotes protect it from shell $-expansion, `$$` is ninja's literal `$`).
+    // Re-running shell_quote_arg over such a token DOUBLE-quotes it, baking a
+    // literal `'$ORIGIN'` (quotes included) into the binary's RUNPATH so the
+    // dynamic linker can't resolve dependency .so's placed next to the exe.
     std::string out;
     for (auto const& flag : flags) {
         out += ' ';
-        out += shell_quote_arg(flag);
+        out += shellQuote ? shell_quote_arg(flag) : flag;
     }
     return out;
 }
@@ -889,7 +898,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             // binaries run on the build host and use the system -lc++,
             // distributable targets get the static LLVM libc++. See
             // CompileFlags::ldStdlibDefault/ldStdlibTest.
-            std::string unit = join_flags(lu.linkFlags);
+            std::string unit = join_flags(lu.linkFlags, /*shellQuote=*/false);
             unit += (lu.kind == mcpp::build::LinkUnit::TestBinary)
                 ? flags.ldStdlibTest : flags.ldStdlibDefault;
             if (!unit.empty())

tests/unit/test_ninja_backend.cpp

@@ -324,6 +324,38 @@ TEST(NinjaBackend, PlainFlagsPassThroughUnquoted) {
         << ninja;
 }
 
+// Regression: mcpp-GENERATED per-unit LINK flags are already correctly
+// shell-quoted + ninja-escaped at construction — e.g. the shared-dep rpath
+// token `-Wl,-rpath,'$$ORIGIN'` (single quotes stop shell $-expansion, `$$`
+// is ninja's literal `$`). join_flags for link flags must NOT re-run
+// shell_quote_arg over them: doing so double-quotes the token, baking a
+// literal `'$ORIGIN'` (quotes included) into the binary's RUNPATH so the
+// dynamic linker can't find dependency .so's next to the exe (e2e 55-57/64).
+TEST(NinjaBackend, LinkFlagsAreNotReQuoted) {
+    auto plan = minimal_plan();
+    plan.compileUnits.push_back({
+        .source = "src/main.cpp",
+        .object = "obj/main.o",
+        .packageName = "rpath_test",
+    });
+    plan.linkUnits.push_back({
+        .targetName = "app",
+        .kind = mcpp::build::LinkUnit::Binary,
+        .objects = {"obj/main.o"},
+        .linkFlags = {"-Wl,-rpath,'$$ORIGIN'"},
+        .output = "bin/app",
+        .entryMain = "src/main.cpp",
+    });
+
+    auto ninja = emit_ninja_string(plan);
+
+    // The rpath token passes through verbatim (ninja `$$` = literal `$`).
+    EXPECT_NE(ninja.find("-Wl,-rpath,'$$ORIGIN'"), std::string::npos) << ninja;
+    // Must NOT be double-quoted: shell_quote_arg escaping an embedded `'`
+    // produces the `'\''` sequence, which only appears if it re-quoted.
+    EXPECT_EQ(ninja.find("'\\''"), std::string::npos) << ninja;
+}
+
 TEST(NinjaBackend, RootPackageCxxflagsAreEmittedOncePerUnit) {
     auto plan = minimal_plan();
     plan.manifest.buildConfig.cxxflags = {"-DROOT_FLAG=1"};