fix(build): a platform limit nobody asked about is not a diagnostic

The MSVC runtime has no self-contained mechanism at all (no /MT emission),
so the default contract degraded on EVERY Windows build and printed a warning
nobody could act on. A diagnostic is for a broken promise — mcpp said the
artifact would be self-contained and it is not. Where mcpp never made the
promise, the cell now stays quiet unless the contract was written down
explicitly. Cells that DO promise something (a missing libc++.a under the
default) still report regardless.

Author: Sunrisepeak

src/build/distribution.cppm

@@ -134,6 +134,17 @@ Contract default_contract(Role r) {
 struct MechanismInput {
     Contract         requested = Contract::SelfContained;
     Role             role      = Role::Distributable;
+    // Did a human write this contract down, or is it just our default?
+    //
+    // The distinction decides whether a cell with no mechanism SPEAKS. A
+    // diagnostic is for a BROKEN PROMISE: mcpp said the artifact would be
+    // self-contained and it is not. Under the MSVC runtime mcpp never made
+    // that promise — there is no /MT emission at all — so warning on every
+    // Windows build would be noise nobody can act on. Write
+    // `cxx_runtime = "self-contained"` there and you get told, once, that it
+    // is not implemented. Cells where mcpp DOES promise something (a missing
+    // libc++.a under the default, say) report regardless.
+    bool             explicitRequest = false;
     // Toolchain capability id: "libstdc++", "libc++", or an MSVC STL spelling.
     std::string_view stdlibId;
     Format           format = Format::Elf;
@@ -205,7 +216,7 @@ Mechanism resolve(const MechanismInput& in) {
             // Mach-O without libc++ is not a configuration mcpp produces.
             m.effective = Contract::HostCoupled;
             m.unitFlags = " -lc++";
-            if (in.requested != Contract::HostCoupled) {
+            if (in.requested != Contract::HostCoupled && in.explicitRequest) {
                 m.degraded = true;
                 m.diagnostic = std::format(
                     "cxx_runtime = \"{}\" is not available for stdlib '{}' on "
@@ -266,12 +277,14 @@ Mechanism resolve(const MechanismInput& in) {
             // producing the same bytes and reporting success.
             m.effective = Contract::HostCoupled;
             if (in.requested == Contract::SelfContained) {
-                m.degraded = true;
-                m.diagnostic =
-                    "cxx_runtime = \"self-contained\" is not implemented for the "
-                    "MSVC runtime yet (it would need the /MT runtime); using "
-                    "host-coupled — the artifact needs the VC++ redistributable";
+                m.degraded   = in.explicitRequest;
+                m.diagnostic = in.explicitRequest
+                    ? "cxx_runtime = \"self-contained\" is not implemented for the "
+                      "MSVC runtime yet (it would need the /MT runtime); using "
+                      "host-coupled — the artifact needs the VC++ redistributable"
+                    : "";
             } else if (in.requested == Contract::ToolchainCoupled) {
+                // Only reachable from an explicit request: it is never a default.
                 m.degraded = true;
                 m.diagnostic =
                     "cxx_runtime = \"toolchain-coupled\" has no meaning for the "
@@ -338,7 +351,7 @@ Mechanism resolve(const MechanismInput& in) {
         // Unknown stdlib on ELF: emit nothing rather than guess, but say so
         // when something was actually asked for.
         m.effective = Contract::HostCoupled;
-        if (in.requested != Contract::HostCoupled) {
+        if (in.requested != Contract::HostCoupled && in.explicitRequest) {
             m.degraded = true;
             m.diagnostic = std::format(
                 "cxx_runtime = \"{}\" has no mechanism for stdlib '{}'; "

src/build/flags.cppm

@@ -609,12 +609,18 @@ CompileFlags compute_flags(const BuildPlan& plan) {
                 mi.libunwindArchive = find_archive("libunwind.a");
         }
 
-        for (auto [role, requested] : {
-                 std::pair{dist::Role::Distributable, base},
-                 std::pair{dist::Role::Test,          testsContract},
-                 std::pair{dist::Role::Intermediate,  base}}) {
-            mi.role      = role;
-            mi.requested = requested;
+        // "Explicit" = a human wrote it down. `static_stdlib = false` counts:
+        // nobody sets a flag to its default to get non-default behavior.
+        const bool explicitBase  = !bc.cxxRuntime.empty() || !bc.staticStdlib;
+        const bool explicitTests = explicitBase || !bc.cxxRuntimeTests.empty();
+
+        for (auto [role, requested, wasAsked] : {
+                 std::tuple{dist::Role::Distributable, base,          explicitBase},
+                 std::tuple{dist::Role::Test,          testsContract, explicitTests},
+                 std::tuple{dist::Role::Intermediate,  base,          explicitBase}}) {
+            mi.role            = role;
+            mi.requested       = requested;
+            mi.explicitRequest = wasAsked;
             auto r = dist::resolve(mi);
             auto i = static_cast<std::size_t>(role);
             f.ldStdlibByRole[i] = r.unitFlags;

tests/unit/test_distribution.cpp

@@ -217,8 +217,9 @@ TEST(Distribution, MingwParity) {
 // success; now it names the gap.
 TEST(Distribution, MsvcSelfContainedIsAnHonestGap) {
     dist::MechanismInput in;
-    in.format   = dist::Format::Pe;
-    in.stdlibId = "msvc";
+    in.format          = dist::Format::Pe;
+    in.stdlibId        = "msvc";
+    in.explicitRequest = true;
     auto m = dist::resolve(in);
     EXPECT_EQ(m.effective, dist::Contract::HostCoupled);
     EXPECT_TRUE(m.degraded);
@@ -227,6 +228,16 @@ TEST(Distribution, MsvcSelfContainedIsAnHonestGap) {
 
     in.requested = dist::Contract::HostCoupled;
     EXPECT_FALSE(dist::resolve(in).degraded);
+
+    // ...but the DEFAULT must be quiet. mcpp never promised a self-contained
+    // MSVC artifact — it emits no /MT at all — so warning on every Windows
+    // build would be unactionable noise. A diagnostic is for a broken
+    // promise, not for a platform limit nobody asked about.
+    in.requested       = dist::Contract::SelfContained;
+    in.explicitRequest = false;
+    auto quiet = dist::resolve(in);
+    EXPECT_FALSE(quiet.degraded);
+    EXPECT_TRUE(quiet.diagnostic.empty());
 }
 
 // ---------------------------------------------------------------------------
@@ -249,11 +260,13 @@ TEST(Distribution, TableIsTotalAndEveryDowngradeExplainsItself) {
     for (auto role : roles)
     for (bool archives : {false, true}) {
         dist::MechanismInput in;
-        in.requested = c;
-        in.format    = fmt;
-        in.stdlibId  = sl;
-        in.role      = role;
-        in.macosFloor = true;
+        in.requested       = c;
+        in.format          = fmt;
+        in.stdlibId        = sl;
+        in.role            = role;
+        in.macosFloor      = true;
+        in.explicitRequest = true;   // the question is "what if you ASK for it"
+
         if (archives) {
             in.libcxxArchive    = "/a.a";
             in.libcxxAbiArchive = "/b.a";