a build program under a target row's pin resolves the host's compiler, not the row's (#622)

Author: speak-agent

src/build/prepare.cppm

@@ -1712,6 +1712,19 @@ prepare_build(bool print_fingerprint,
     // learned by experiment — writing the same value a second time in
     // `[target.<triple>]` and observing that it works.
     std::string pinReplacedDefault;
+    // THE HOST SPEC AS IT STOOD BEFORE A TARGET ROW'S CONVENTION REPLACED IT,
+    // whatever its origin. `build.mcpp` is compiled and run on this machine,
+    // so its compiler is a host fact; the row's pin is a target fact. Before
+    // this snapshot existed, `host_tc_for_build_program` read `tcSpec` after
+    // the row had overwritten it and resolved the row's payload "for the
+    // host" -- which works by accident for a payload whose compiler can also
+    // target the host (an NDK clang) and cannot work for one that cannot:
+    // `em++` produces WebAssembly under every invocation, and every project
+    // with a build program failed under `--target wasm32-emscripten` inside
+    // `emcc.py` (#622, measured by the dist-web member's first build). Empty
+    // when the row replaced nothing, in which case the row's pin remains the
+    // only spec there is and the previous behaviour is kept.
+    std::optional<std::string> hostSpecBeforeRowPin;
     // THE PACKAGE WHOSE `requires` CHOSE THE COMPILER, AND WHAT IT ASKED FOR.
     //
     // Non-empty only when the graph's requirement actually changed the answer.
@@ -4114,10 +4127,19 @@ prepare_build(bool print_fingerprint,
                 "build.mcpp under a cross --target needs a resolvable host "
                 "toolchain — set one via [toolchain] or `mcpp toolchain default`"));
         }
-        auto spec = mcpp::toolchain::parse_toolchain_spec(*tcSpec);
+        // THE ROW'S CONVENTION IS NOT THE HOST'S COMPILER. When the target
+        // row's pin replaced a spec the user or the machine had chosen, the
+        // build program resolves the replaced one: it is what a native build
+        // on this machine would use, and it is what the user wrote. A pin
+        // that replaced nothing is resolved as before.
+        const std::string hostSpecText =
+            (tcOrigin == TcOrigin::TargetPin && hostSpecBeforeRowPin.has_value()
+             && !hostSpecBeforeRowPin->empty() && *hostSpecBeforeRowPin != "system")
+                ? *hostSpecBeforeRowPin : *tcSpec;
+        auto spec = mcpp::toolchain::parse_toolchain_spec(hostSpecText);
         if (!spec || spec->version.empty()) {
             return std::unexpected(std::format(
-                "toolchain spec '{}' is invalid for the build.mcpp host resolve", *tcSpec));
+                "toolchain spec '{}' is invalid for the build.mcpp host resolve", hostSpecText));
         }
         // Deliberately NO target injection: the spec resolves for the host.
         auto pkg = mcpp::toolchain::to_xim_package(*spec);
@@ -4128,7 +4150,7 @@ prepare_build(bool print_fingerprint,
         auto payload = fetcher.resolve_xpkg_path(pkg.target(), /*autoInstall=*/true, &progress);
         if (!payload) {
             return std::unexpected(std::format(
-                "host toolchain for build.mcpp ('{}'): {}", *tcSpec,
+                "host toolchain for build.mcpp ('{}'): {}", hostSpecText,
                 payload.error().message));
         }
         auto frontendR = mcpp::toolchain::payload_frontend(payload->root, pkg);
@@ -7240,6 +7262,12 @@ prepare_build(bool print_fingerprint,
             if (tcOrigin == TcOrigin::GlobalDefault && tcSpec.has_value()
                 && *tcSpec != targetPinCandidate)
                 pinReplacedDefault = *tcSpec;
+            // Kept for the build program's host resolution; see the
+            // declaration. Taken from every origin, not only the global
+            // default, because a `[toolchain]` the manifest named is just as
+            // much the host's compiler as a remembered default is.
+            if (tcSpec.has_value() && *tcSpec != targetPinCandidate)
+                hostSpecBeforeRowPin = *tcSpec;
             tcSpec   = targetPinCandidate;
             tcOrigin = TcOrigin::TargetPin;
         }

tests/e2e/657_a_build_program_under_the_web_row_uses_the_host_compiler.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# requires: elf
+# 657 -- a project with a build.mcpp builds for wasm32-emscripten (#622).
+#
+# `build.mcpp` is compiled and run on this machine. Under a cross target the
+# engine resolves a host toolchain for it from the toolchain spec, and the
+# spec was read AFTER the target row's convention had replaced it: for the
+# Web row that is `emsdk@6.0.9`, whose `em++` produces WebAssembly under every
+# invocation. Every project with a build program therefore failed under
+# `--target wasm32-emscripten`, inside emcc.py (`AssertionError ...
+# phase_compile_inputs`), measured 2026-09-12 by the first dist-web build. An
+# NDK clang can also target the host, which is why the Android rows never
+# showed it.
+#
+# The engine now keeps the spec as it stood before the row's pin replaced it
+# and resolves the build program's compiler from that. Asserted here as the
+# only criterion that distinguishes the two: the build succeeds, the program
+# runs under node, and the build program's `MCPP_HOST` equals the machine's
+# triple while `MCPP_TARGET` is the Web row. Skips honestly where no emsdk
+# payload is installed, as 650 does.
+set -e
+
+have_emsdk=0
+for d in "${MCPP_HOME:-$HOME/.mcpp}"/registry/data/xpkgs/xim-x-emsdk/*/emscripten \
+         "$HOME"/.xlings/data/xpkgs/xim-x-emsdk/*/emscripten; do
+    [[ -x "$d/em++" ]] && have_emsdk=1
+done
+if [ "$have_emsdk" -ne 1 ]; then
+    echo "SKIP: 657 -- no emsdk payload installed (looked under xim-x-emsdk/*/emscripten)"
+    exit 0
+fi
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+
+mkdir -p "$TMP/p/src"
+cat > "$TMP/p/mcpp.toml" <<'TOML'
+[package]
+name = "bp"
+version = "0.1.0"
+
+[targets.bp]
+kind = "bin"
+main = "src/main.cpp"
+
+[target.wasm32-emscripten]
+runner = ["node"]
+TOML
+cat > "$TMP/p/src/main.cpp" <<'CPP'
+#include <cstdio>
+int main() { std::puts("1-2-3"); return 0; }
+CPP
+# The build program records the two triples it was told, so the test can say
+# which machine it was compiled for without reading a compiler's argv.
+cat > "$TMP/p/build.mcpp" <<'CPP'
+import mcpp;
+#include <cstdio>
+int main() {
+    std::FILE* f = std::fopen("bp-env.txt", "w");
+    if (!f) return 1;
+    std::fprintf(f, "host=%s\ntarget=%s\n", mcpp::host(), mcpp::target());
+    std::fclose(f);
+    return 0;
+}
+CPP
+
+cd "$TMP/p"
+"$MCPP" build --target wasm32-emscripten > build.log 2>&1 \
+    || fail "a project with a build.mcpp does not build for wasm32-emscripten (the host compiler for build.mcpp was the row's em++)" build.log
+grep -q 'AssertionError' build.log && fail "emcc.py's assertion is in the log" build.log
+[ -f bp-env.txt ] || fail "the build program did not run" build.log
+host_triple=$(grep '^host=' bp-env.txt | cut -d= -f2)
+target_triple=$(grep '^target=' bp-env.txt | cut -d= -f2)
+[ "$target_triple" = "wasm32-emscripten" ] || fail "MCPP_TARGET was '$target_triple'" bp-env.txt
+case "$host_triple" in wasm32*|"") fail "MCPP_HOST was '$host_triple'" bp-env.txt ;; esac
+[ -n "$(find target/wasm32-emscripten -path '*/bin/bp.js' | head -1)" ] || fail "no bin/bp.js" build.log
+"$MCPP" run --target wasm32-emscripten > run.log 2>&1 || fail "mcpp run failed" run.log
+grep -qx '1-2-3' run.log || fail "the program did not print 1-2-3" run.log
+
+echo "PASS: 657_a_build_program_under_the_web_row_uses_the_host_compiler"