fix(subos): set 是默认值,不是命令;prepend 要接在用户的值前面

mcpp#382 的次要观察,而它把配方写明的逃生通道整个作废了。

解析出来的键值对是**替换**子进程里的变量的(它们作为 extraEnv 进去)。于是:

- 一条 `set` 会覆盖用户已经 export 的值。xlings 的 wsl-gl-host-link 白纸黑字写着
  「用户自己 export GALLIUM_DRIVER=llvmpipe 会保留」—— 实际不保留:
  `export GALLIUM_DRIVER=llvmpipe; mcpp run` 仍然带着 subos 的 d3d12 跑,仍然失败。
- 一条 `prepend` 只发出声明值,**丢掉**用户原有的内容。对 PATH 形状的变量,那是
  用户的整条搜索路径。第二个缺陷,没人报过。

现在两者都对着调用方的环境解析:`set` 在变量已有非空值时让位,`prepend` 接在其
前面(且对已存在的元素幂等)。空值不算「用户设过」。

用户刻意设定的环境,是构建环境**唯一**不该悄悄推翻的输入。

  tests/unit/test_subos_info.cpp  +5(17 条);已验证去掉让位逻辑后该断言变红
  e2e 200 通过

Author: speak-agent

src/build/execute.cppm

@@ -361,7 +361,15 @@ compute_subos_env(const mcpp::build::BuildPlan& plan) {
     // diagnostic path in doctor.
     if (!info.note.empty())
         mcpp::log::verbose("subos", info.note);
-    return mcpp::xlings::subos::resolve_env(info, dir);
+    // Resolved AGAINST the caller's environment, not in a vacuum: these
+    // entries replace the variable in the child, so a `set` that ignores an
+    // exported value overwrites it and a `prepend` that ignores it drops it.
+    return mcpp::xlings::subos::resolve_env(
+        info, dir, [](std::string_view v) -> std::optional<std::string> {
+            if (const char* e = std::getenv(std::string(v).c_str()))
+                return std::string(e);
+            return std::nullopt;
+        });
 }
 
 // Compile a prepared BuildContext. Shared between `mcpp build` and `mcpp run`
@@ -877,7 +885,13 @@ std::optional<int> try_fast_run(const std::filesystem::path& projectRoot,
         auto subosDir = subos_dir_for_run(std::filesystem::path(match->subosDir));
         if (!subosDir.empty()) {
             auto info = mcpp::xlings::subos::read(subosDir);
-            for (auto& kv : mcpp::xlings::subos::resolve_env(info, subosDir))
+            for (auto& kv : mcpp::xlings::subos::resolve_env(
+                     info, subosDir,
+                     [](std::string_view v) -> std::optional<std::string> {
+                         if (const char* e = std::getenv(std::string(v).c_str()))
+                             return std::string(e);
+                         return std::nullopt;
+                     }))
                 childEnv.push_back(std::move(kv));
         }
     }

src/xlings/subos_info.cppm

@@ -201,9 +201,21 @@ Info read(const std::filesystem::path& subosDir) {
 // never matches and the joined value is a corrupt list. Caught by CI on
 // Windows, not by any amount of reading.
 std::vector<std::pair<std::string, std::string>>
-resolve_env(const Info& info, const std::filesystem::path& subosDir) {
+resolve_env(const Info& info, const std::filesystem::path& subosDir,
+            const std::function<std::optional<std::string>(std::string_view)>&
+                ambient = {}) {
     std::vector<std::pair<std::string, std::string>> out;
 
+    // What the caller's environment already says about a variable.
+    //
+    // The declarations are merged against this, not in a vacuum, because the
+    // result REPLACES the variable in the child (it goes in as extraEnv). A
+    // resolution that ignores the ambient value silently discards it.
+    auto ambient_of = [&](std::string_view var) -> std::optional<std::string> {
+        if (!ambient) return std::nullopt;
+        return ambient(var);
+    };
+
     const std::string subos = subosDir.string();
     auto expand = [&](std::string v) {
         constexpr std::string_view kPh = "${subosdir}";
@@ -241,7 +253,37 @@ resolve_env(const Info& info, const std::filesystem::path& subosDir) {
             std::pair<std::string, std::string>* hit = nullptr;
             for (auto& kv : out)
                 if (kv.first == d.var) { hit = &kv; break; }
-            if (!hit) { out.emplace_back(d.var, value); continue; }
+            if (!hit) {
+                auto amb = ambient_of(d.var);
+                if (d.op == "set") {
+                    // A `set` is a DEFAULT, not an order. If the caller
+                    // already exported the variable, that wins.
+                    //
+                    // Recipes document this as the escape hatch -- xlings'
+                    // wsl-gl-host-link says in so many words that a user who
+                    // exports GALLIUM_DRIVER=llvmpipe keeps it. Before this,
+                    // the subos value overwrote it and the hatch did not
+                    // exist: `export GALLIUM_DRIVER=llvmpipe; mcpp run` still
+                    // ran with d3d12 and still failed (mcpp#382). An
+                    // environment a user set deliberately is the one piece of
+                    // input a build environment must not quietly overrule.
+                    if (amb && !amb->empty()) { out.emplace_back(d.var, *amb); continue; }
+                    out.emplace_back(d.var, value);
+                    continue;
+                }
+                // `prepend` against the ambient value, not instead of it.
+                // These entries replace the variable in the child, so
+                // emitting the declared value alone DROPS whatever the caller
+                // had -- for a PATH-shaped variable that is the user's whole
+                // search path.
+                if (amb && !amb->empty() && !contains_element(*amb, value))
+                    out.emplace_back(d.var, value + sep + *amb);
+                else if (amb && !amb->empty())
+                    out.emplace_back(d.var, *amb);
+                else
+                    out.emplace_back(d.var, value);
+                continue;
+            }
             if (d.op == "set") { hit->second = value; continue; }
             if (!contains_element(hit->second, value))
                 hit->second = value + sep + hit->second;

tests/unit/test_subos_info.cpp

@@ -249,4 +249,86 @@ TEST(SubosInfo, UnknownOpIsDroppedLikeXlingsDrops) {
     EXPECT_EQ(env[0].second, "/yes");
 }
 
+// A `set` is a default; an exported value wins.
+//
+// The resolved pairs REPLACE the variable in the child (they go in as
+// extraEnv), so a `set` that ignores the caller's environment overwrites it
+// silently. Recipes are written on the opposite assumption: xlings'
+// wsl-gl-host-link documents that a user who exports GALLIUM_DRIVER=llvmpipe
+// keeps it, and that escape hatch did not exist -- `export
+// GALLIUM_DRIVER=llvmpipe; mcpp run` still ran with the subos value and still
+// failed (mcpp#382).
+TEST(SubosResolveEnv, SetDoesNotOverrideAnExportedValue) {
+    Tmp t;
+    t.write(R"({"workspace":{},"subos_info":{"schema_version":1,"runtime":"glibc@2.39",
+        "envs":{"glibc@2.39":[{"var":"GALLIUM_DRIVER","op":"set","value":"d3d12"}]}}})");
+    auto info = su::read(t.dir);
+    auto out = su::resolve_env(
+        info, t.dir, [](std::string_view v) -> std::optional<std::string> {
+            if (v == "GALLIUM_DRIVER") return std::string("llvmpipe");
+            return std::nullopt;
+        });
+    ASSERT_EQ(out.size(), 1u);
+    EXPECT_EQ(out[0].first, "GALLIUM_DRIVER");
+    EXPECT_EQ(out[0].second, "llvmpipe") << "the user's export must survive";
+}
+
+TEST(SubosResolveEnv, SetAppliesWhenNothingIsExported) {
+    Tmp t;
+    t.write(R"({"workspace":{},"subos_info":{"schema_version":1,"runtime":"glibc@2.39",
+        "envs":{"glibc@2.39":[{"var":"GALLIUM_DRIVER","op":"set","value":"d3d12"}]}}})");
+    auto info = su::read(t.dir);
+    auto out = su::resolve_env(
+        info, t.dir, [](std::string_view) { return std::optional<std::string>{}; });
+    ASSERT_EQ(out.size(), 1u);
+    EXPECT_EQ(out[0].second, "d3d12");
+}
+
+// An empty export is not an export.
+TEST(SubosResolveEnv, EmptyAmbientDoesNotBlockASet) {
+    Tmp t;
+    t.write(R"({"workspace":{},"subos_info":{"schema_version":1,"runtime":"glibc@2.39",
+        "envs":{"glibc@2.39":[{"var":"X","op":"set","value":"v"}]}}})");
+    auto info = su::read(t.dir);
+    auto out = su::resolve_env(
+        info, t.dir, [](std::string_view) { return std::optional<std::string>(""); });
+    ASSERT_EQ(out.size(), 1u);
+    EXPECT_EQ(out[0].second, "v");
+}
+
+// `prepend` prepends TO the caller's value rather than replacing it. Same
+// reason: the pair replaces the variable, so emitting the declared value alone
+// discards whatever search path the user had.
+TEST(SubosResolveEnv, PrependKeepsTheExportedValue) {
+    Tmp t;
+    t.write(R"({"workspace":{},"subos_info":{"schema_version":1,"runtime":"glibc@2.39",
+        "envs":{"glibc@2.39":[{"var":"LD_LIBRARY_PATH","op":"prepend","value":"/sub/lib"}]}}})");
+    auto info = su::read(t.dir);
+    auto out = su::resolve_env(
+        info, t.dir, [](std::string_view v) -> std::optional<std::string> {
+            if (v == "LD_LIBRARY_PATH") return std::string("/user/lib");
+            return std::nullopt;
+        });
+    ASSERT_EQ(out.size(), 1u);
+    const auto sep = mcpp::platform::env::path_list_separator();
+    EXPECT_EQ(out[0].second, std::string("/sub/lib") + sep + "/user/lib");
+}
+
+// Already there: prepending again would grow the list on every nested run.
+TEST(SubosResolveEnv, PrependIsIdempotentAgainstTheExportedValue) {
+    Tmp t;
+    t.write(R"({"workspace":{},"subos_info":{"schema_version":1,"runtime":"glibc@2.39",
+        "envs":{"glibc@2.39":[{"var":"LD_LIBRARY_PATH","op":"prepend","value":"/sub/lib"}]}}})");
+    auto info = su::read(t.dir);
+    const auto sep = mcpp::platform::env::path_list_separator();
+    const auto existing = std::string("/sub/lib") + sep + "/user/lib";
+    auto out = su::resolve_env(
+        info, t.dir, [&](std::string_view v) -> std::optional<std::string> {
+            if (v == "LD_LIBRARY_PATH") return existing;
+            return std::nullopt;
+        });
+    ASSERT_EQ(out.size(), 1u);
+    EXPECT_EQ(out[0].second, existing);
+}
+
 }  // namespace