cenv_probe: cacheRoot before hostStripMacros; presents=none emits -fno-short-wchar

The previous parameter order put hostStripMacros before cacheRoot. That
meant callers passing a custom cache directory (the test suite does this
in every TEST) had to also pass an empty hostStripMacros, even though
they did not care about the strip. Reordering puts cacheRoot first so
the strip's default value (`{}`) is what callers that override cache
actually mean, and tests that want to assert the strip's behaviour pass
both. prepare.cppm's call passes both, in the reordered order.

The "presents = none" wchar branch used to assert tokens.empty(). That
is wrong under the new freestanding-wchar rule: -fno-short-wchar is
emitted regardless of presents, because the wchar realisation is
about width (the toolchain's host-contaminated default), not about
identity (what macros the preprocessor states). Updated to assert the
flag's presence and the absence of any identity macros.

Author: speak-agent

src/build/prepare.cppm

@@ -10927,6 +10927,7 @@ prepare_build(bool print_fingerprint,
                     tc->binaryPath, probeArgv,
                     tc->cEnvExpectWcharBits, tc->cEnvExpectLongBytes,
                     tc->cEnvExpectDefined, tc->cEnvExpectUndefined,
+                    mcpp::home::cache_root(),
                     hostStripMacros);
                 if (!probe) {
                     refusal::record(refusal::Code::CEnvUnrealisable);

src/toolchain/cenv_probe.cppm

@@ -85,14 +85,20 @@ struct Result {
 // DIFFERENT failure from the declaration disagreeing with what compiled: the
 // caller reports it as a build error naming the command, not as a §3.2
 // verification mismatch.
+//
+// `hostStripMacros` is placed AFTER `cacheRoot` (the latter being the test
+// suite's frequent override) to keep the existing call sites — which pass
+// neither — source-compatible. New callers that DO need the strip supply
+// both arguments; tests that pin a temp cache directory pass the strip
+// empty by default.
 std::expected<Result, std::string> verify(
     const std::filesystem::path& compilerBin,
     const std::vector<std::string>& argv,
     int expectWcharBits, int expectLongBytes,
     const std::vector<std::string>& expectDefined,
     const std::vector<std::string>& expectUndefined,
-    const std::vector<std::string>& hostStripMacros = {},
-    const std::filesystem::path& cacheRoot = mcpp::home::cache_root());
+    const std::filesystem::path& cacheRoot = mcpp::home::cache_root(),
+    const std::vector<std::string>& hostStripMacros = {});
 
 } // namespace mcpp::toolchain::cenv_probe
 
@@ -141,8 +147,8 @@ std::expected<Result, std::string> verify(
     int expectWcharBits, int expectLongBytes,
     const std::vector<std::string>& expectDefined,
     const std::vector<std::string>& expectUndefined,
-    const std::vector<std::string>& hostStripMacros,
-    const std::filesystem::path& cacheRoot) {
+    const std::filesystem::path& cacheRoot,
+    const std::vector<std::string>& hostStripMacros) {
 
     // The cache key is the compiler binary's own identity plus every argv
     // token, in order — exactly the inputs that can change what `-dM`

tests/unit/test_cenv.cpp

@@ -166,7 +166,22 @@ TEST(CEnv, FreestandingAcceptsNone) {
     auto ok = decl(ts::CAbiPresents::None, ts::CAbiDataModel::ArchDefault, 32);
     auto r1 = cenv::realise(ok, "none", "riscv64", true);
     ASSERT_TRUE(r1.has_value()) << r1.error();
-    EXPECT_TRUE(r1->tokens.empty());
+    // The wchar branch ALWAYS emits on a freestanding target now (wave
+    // 2026-09-18, openkal-llvm-runtime#24, Windows-host × riscv64-none-elf
+    // measurement): the toolchain's host-contaminated default is not
+    // something the engine can trust, so `wchar = 32` produces
+    // `-fno-short-wchar` regardless of what `presents` says. Identity
+    // macros stay absent (the `none` presents value's whole point),
+    // but the wchar realisation still applies — and so does the
+    // expectation, which the probe then measures.
+    EXPECT_TRUE(has(r1->tokens, "-fno-short-wchar"));
+    EXPECT_TRUE(r1->expectUndefined.empty())
+        << "presents = none declares NO environment-identity macros, "
+           "neither defined nor undefined";
+    EXPECT_TRUE(r1->expectDefined.empty());
+    // Data-model is not checked on freestanding (no C library runtime to
+    // present it), so `expectLongBytes` stays at 0.
+    EXPECT_EQ(r1->expectLongBytes, 0);
 }
 
 // A freestanding target ALSO realises `presents = "posix"` (design §3.3,

tests/unit/test_cenv_probe.cpp

@@ -245,7 +245,7 @@ TEST(CenvProbe, AHostStrippedMacroIsAbsentFromTheDump) {
     // First confirm the host's compiler would NOT define the macro absent
     // any help — a baseline so the strip's effect is unambiguous.
     auto baseline = cp::verify(cxx(), {}, 0, 0, {}, {kProbeStripUndefined},
-                               {}, cache.dir);
+                               cache.dir);
     ASSERT_TRUE(baseline.has_value()) << baseline.error();
     EXPECT_TRUE(baseline->mismatches.empty())
         << "test-only macro " << kProbeStripUndefined
@@ -258,8 +258,9 @@ TEST(CenvProbe, AHostStrippedMacroIsAbsentFromTheDump) {
         {std::format("-D{}=", kProbeStripDefined)},
         0, 0,
         {}, {kProbeStripDefined},                 // expected: undefined
-        {std::format("-U{}", kProbeStripDefined)}, // host strip
-        cache.dir);
+        cache.dir,
+        {std::format("-U{}", kProbeStripDefined)} // host strip
+    );
     ASSERT_TRUE(stripped.has_value()) << stripped.error();
     EXPECT_TRUE(stripped->mismatches.empty())
         << "a `-D…` followed by `-U…` must yield no mismatch: "
@@ -269,11 +270,10 @@ TEST(CenvProbe, AHostStrippedMacroIsAbsentFromTheDump) {
 TEST(CenvProbe, AStripListDoesNotShareACacheSlotWithAnEmptyStrip) {
     if (cxx().empty()) GTEST_SKIP() << "no C++ compiler found to probe";
     TmpCache cache;
-    auto noStrip = cp::verify(cxx(), {}, 0, 0, {}, {}, {}, cache.dir);
+    auto noStrip = cp::verify(cxx(), {}, 0, 0, {}, {}, cache.dir);
     ASSERT_TRUE(noStrip.has_value()) << noStrip.error();
-    auto withStrip = cp::verify(cxx(), {}, 0, 0, {}, {},
-                                {"-U_MCPP_PROBE_TEST_NO_SUCH_MACRO"},
-                                cache.dir);
+    auto withStrip = cp::verify(cxx(), {}, 0, 0, {}, {}, cache.dir,
+                                {"-U_MCPP_PROBE_TEST_NO_SUCH_MACRO"});
     ASSERT_TRUE(withStrip.has_value()) << withStrip.error();
     EXPECT_TRUE(noStrip->ran);
     EXPECT_TRUE(withStrip->ran)