deps: the Linux GCC row keeps vcpkg's detection; the MSBuild refusal reads the call stack

- mcpp runs its GCC payload with a sysroot, a binutils directory and a link
  model that only its own command lines carry, so the driver alone is not a
  complete handover: vcpkg's compiler detection failed with it on CI. On that
  row the host compiler's libstdc++ is the program's C++ library, and
  `resolved` answers `detected`, stating why. The clang payloads are complete
  through their `.cfg` files and stay `chain`.
- The MSBuild watch matched the current file, which inside a function is the
  caller's (the portfile), so it never fired; it now matches the helper in the
  call stack, by its own directory and file names (measured with CMake 4.4:
  the helper is refused, a CMake helper's read is not).

Author: Sunrisepeak

.github/scripts/check-deps-and-qt.sh

@@ -72,18 +72,25 @@ vcpkg_consumer() {
 
     # THE MECHANISM (0.17.0). On the Visual Studio row the instance mcpp
     # resolved is selected and the standard triplet is used, so the ABI hash is
-    # the one vcpkg computes by itself; on the other rows a derived triplet
-    # names the resolved tools.
+    # the one vcpkg computes by itself. On the Linux GCC row (this job's
+    # default) vcpkg's own detection is kept: the payload driver runs with
+    # flags only mcpp's command lines carry. On the clang rows (macOS here) a
+    # derived triplet names the resolved tools.
     if is_windows; then
         grep -rqs 'VCPKG_VISUAL_STUDIO_PATH=' target --include=build.ninja ||
             fail "the installation does not select the Visual Studio instance mcpp resolved"
         [ -d target/vcpkg_installed/x64-windows/x64-windows ] || fail "the instance mechanism did not use x64-windows"
         echo "ok: the installation selects the Visual Studio instance and keeps the standard triplet"
-    else
+    elif is_macos; then
         ls -d target/vcpkg_installed/*-mcpp-*/*-mcpp-* > /dev/null 2>&1 ||
             fail "no derived <base>-mcpp-<hash> prefix under target/vcpkg_installed"
         grep -rqs 'MCPP_VCPKG_CXX=' target --include=build.ninja || fail "the installation does not hand vcpkg the resolved compiler"
         echo "ok: the installation names the resolved compiler in a derived triplet"
+    else
+        ls -d target/vcpkg_installed/*-linux/*-linux > /dev/null 2>&1 ||
+            fail "the GCC row did not keep the standard <arch>-linux triplet"
+        ! grep -rqs 'MCPP_VCPKG_CXX=' target --include=build.ninja || fail "the GCC row named its compiler to vcpkg"
+        echo "ok: the GCC row keeps vcpkg's detection and the standard triplet"
     fi
 
     if is_windows; then
@@ -126,8 +133,8 @@ vcpkg_libcxx() {
     "$MCPP" run | tee target/ci/default-run.log
     grep -qE '^vcpkg-consumer: fmt [0-9]+ says 42$' target/ci/default-run.log || fail "the default toolchain's program did not print through fmt"
     [ -f "$lib" ] || fail "the default toolchain's installation removed the $gen prefix"
-    [ "$(ls -d target/vcpkg_installed/*-mcpp-* | wc -l)" -ge 2 ] ||
-        fail "the default toolchain did not derive a triplet of its own"
+    [ "$(ls -d target/vcpkg_installed/*/ | wc -l)" -ge 2 ] ||
+        fail "the default toolchain did not install a prefix of its own"
     local stamp; stamp=$(find target -path '*deps-vcpkg*' -name "$gen.stamp" | head -1)
     [ -n "$stamp" ] || fail "no $gen installation stamp"
     touch -r "$stamp" target/ci/before-switch-back
@@ -455,7 +462,7 @@ vcpkg_msbuild_refused() {
     if "$MCPP" build --toolchain "$MSVC_MANAGED" > target/ci/build.log 2>&1; then
         cat target/ci/build.log; fail "an MSBuild port built without Visual Studio"
     fi
-    grep -q "builds with MSBuild, which needs a Visual Studio instance" target/ci/build.log ||
+    grep -q "builds with MSBuild" target/ci/build.log ||
         { tail -60 target/ci/build.log; fail "the MSBuild port failed without the plugin's reason"; }
     echo "ok: an MSBuild port is refused by name without Visual Studio"
 }

deps/vcpkg.cppm

@@ -267,17 +267,24 @@ inline std::string chain_toolchain_text() {
 }
 
 // What an MSBuild port meets under `chain`: vcpkg runs MSBuild with
-// `/p:PlatformToolset=external` and fails without naming the cause. The
-// MSBuild helpers read `VCPKG_PLATFORM_TOOLSET` to build that argument; the
-// watch stops the port there and says why.
+// `/p:PlatformToolset=external` and fails without naming the cause ("msbuild:
+// no such file or directory" when no Visual Studio exists). The MSBuild
+// helpers read `VCPKG_PLATFORM_TOOLSET` to build that argument; the watch
+// stops the port there and says why. The helper is recognised in the watch's
+// CALL STACK, not its current file: a read inside a function reports the
+// caller's file (the portfile), and the stack names the file that defines the
+// function (measured with CMake 4.4). The pattern names the helper's own
+// directory and files, so a project whose path contains "msbuild" is not
+// refused.
 inline std::string msbuild_refusal_text(std::string_view identity) {
     return std::format(
         "# mcpp.deps.vcpkg: a port that builds with MSBuild needs a Visual Studio\n"
         "# instance, and this toolset comes from none.\n"
         "if(PORT AND NOT DEFINED Z_MCPP_MSBUILD_WATCH)\n"
         "  set(Z_MCPP_MSBUILD_WATCH 1)\n"
-        "  function(z_mcpp_msbuild_watch variable access value current_file)\n"
-        "    if(access STREQUAL \"READ_ACCESS\" AND current_file MATCHES \"msbuild\")\n"
+        "  function(z_mcpp_msbuild_watch variable access value current_file stack)\n"
+        "    if(access STREQUAL \"READ_ACCESS\" AND stack MATCHES "
+        "\"/vcpkg-msbuild/|vcpkg_install_msbuild\\\\.cmake|vcpkg_build_msbuild\\\\.cmake\")\n"
         "      message(FATAL_ERROR \"mcpp.deps.vcpkg: the port '${{PORT}}' builds with MSBuild, which "
         "needs a Visual Studio instance; the toolset mcpp resolved ({}) comes from none. Build with "
         "the toolchain msvc@system on a machine with Visual Studio, or set the deps-vcpkg option "

docs/deps.md

@@ -108,8 +108,18 @@ vcpkg follows where the toolset came from:
 | mechanism | when | what vcpkg receives | port kinds that build |
 |---|---|---|---|
 | `instance` | an MSVC toolset from a Visual Studio instance (`msvc@system`, the default on a machine with Visual Studio) | `VCPKG_VISUAL_STUDIO_PATH` naming that instance; the standard triplet, or a derived one with `VCPKG_PLATFORM_TOOLSET_VERSION` when the resolved toolset is not the instance's default | CMake, make and MSBuild |
-| `chain` | any other toolset: a managed MSVC toolset (`xim:msvc@<version>`), and the toolsets of the Linux and macOS rows | a derived triplet `<base>-mcpp-<hash>` that chain-loads a toolchain naming the tools, and the tools' environment | CMake and make; an MSBuild port is refused by name |
-| `detected` | `options.toolset.toolset = detected` | nothing: vcpkg finds its own toolset, as in 0.16.0 | as vcpkg's own detection allows |
+| `chain` | a managed MSVC toolset (`xim:msvc@<version>`), and the clang toolsets of the Linux and macOS rows | a derived triplet `<base>-mcpp-<hash>` that chain-loads a toolchain naming the tools, and the tools' environment | CMake and make; an MSBuild port is refused by name |
+| `detected` | `options.toolset.toolset = detected`; and, under `resolved`, the Linux GCC row | nothing: vcpkg finds its own toolset, as in 0.16.0 | as vcpkg's own detection allows |
+
+**The Linux GCC row.** mcpp runs its GCC payload with a sysroot, a binutils
+directory and a link model (the payload's dynamic linker and C library) that
+its own command lines add; the driver alone is not a complete toolset, and
+vcpkg's compiler detection fails with it on a machine whose host compiler does
+not fill the gaps (measured on the plugins' CI). The clang payloads carry their
+configuration in their own `.cfg` files and are complete. On the GCC row the
+host compiler's libstdc++ is the program's C++ library, so `resolved` keeps
+vcpkg's detection there and the member states why in `mcpp.plugins.toolset`'s
+`reason`.
 
 **The derived triplet.** The base triplet's text is copied into it, not
 included, because vcpkg hashes a triplet file's content and not the files it
@@ -145,14 +155,15 @@ a second C++ runtime into the process without a word. `crt_linkage` states the
 ports' linkage explicitly and wins.
 
 **Linux.** Linux has two C++ standard libraries that do not link with each
-other. The derived triplet names the program's compiler, so the ports use the
-program's library on every row: libc++ under mcpp's clang (`std::__1::`), and
-the GCC payload's libstdc++ under mcpp's GCC.
-
-**Upgrading from 0.16.0.** On Linux and macOS, and on Windows with a managed
-toolset, the installation moves to a derived triplet, so each port is built once
-more (or restored from a binary cache that already holds it); the prefixes of
-0.16.0 (`<arch>-linux-libcxx`, `x64-linux`) are left where they are. With
+other. Under mcpp's clang the derived triplet names that clang, so the ports
+use libc++ (`std::__1::`) as the program does; under mcpp's GCC the host
+compiler's libstdc++ is the program's library, and vcpkg's detection is kept.
+
+**Upgrading from 0.16.0.** On the clang rows of Linux and macOS, and on Windows
+with a managed toolset, the installation moves to a derived triplet, so each
+port is built once more (or restored from a binary cache that already holds
+it); the prefixes of 0.16.0 (`<arch>-linux-libcxx`) are left where they are. The
+Linux GCC row is unchanged. With
 Visual Studio and the dynamic C runtime nothing changes: the standard triplet
 and the instance vcpkg selects by itself give the same ABI hash. A program that
 links the C runtime statically moves to `x64-windows-static`.

src/toolset.cppm

@@ -14,13 +14,15 @@
 //              toolset loading stays in place, pointed at the instance mcpp
 //              resolved, so MSBuild is present and every kind of project
 //              builds.
-//   chain      Any other toolset -- a managed MSVC toolset, and every toolset
-//              on the other rows -- is named: absolute tool paths, the
+//   chain      Any other toolset -- a managed MSVC toolset, and the clang
+//              toolsets of the other rows -- is named: absolute tool paths, the
 //              environment they run with, and the directories that go first
 //              on PATH. On the MSVC ABI without an instance no MSBuild exists.
-//   detected   `source::detected`: nothing is named, and the foreign system
-//              finds its own toolset, as the deps members did before 0.17.0.
-//              Kept by `src/compat/detected_toolset.cppm` until 2027-03-28.
+//   detected   Nothing is named, and the foreign system finds its own
+//              toolset. `source::detected` asks for it (kept by
+//              `src/compat/detected_toolset.cppm` until 2027-03-28); `resolved`
+//              answers it on the Linux GCC row, whose payload driver is not a
+//              complete handover (see `resolve`).
 //
 // NONE OF THIS NAMES A FOREIGN SYSTEM. vcpkg's triplet and CMake's generator
 // are written by the plugins that drive them (`mcpp.deps.vcpkg`,
@@ -73,6 +75,9 @@ struct resolved_tools {
     std::string identity;           // toolset_identity(): "msvc 14.44.35207; sdk 10.0.26100.0", "clang 22.1.8"
     std::string crt;                // msvc_crt_linkage(): "static", "dynamic", or empty off the MSVC ABI
     bool        msvc_abi = false;
+    // Why `resolved` answered `detected`: empty unless the resolved toolset
+    // cannot be handed over by its tools alone.
+    std::string reason;
 };
 
 inline bool msvc_abi() {
@@ -216,6 +221,22 @@ inline std::expected<resolved_tools, std::string> resolve(const choice& c = {})
             "arrived in mcpp 2026.9.28.3 (protocol 14). Pin \"mcpp\": \"2026.9.28.3\" or newer "
             "in .xlings.json, or set the plugin's `toolset` option to `detected`."));
 
+    // THE GCC PAYLOAD IS NOT A COMPLETE HANDOVER. mcpp runs it with a sysroot,
+    // a binutils directory and a link model (`--sysroot`, `-B`, the payload's
+    // dynamic linker and C library) that its own command lines add and a
+    // foreign build system does not receive; given the driver alone, vcpkg's
+    // compiler detection failed on CI while it passed on a machine whose host
+    // compiler filled the gaps. The clang payloads carry their configuration in
+    // their own `.cfg` files and are complete. On the GCC row the host
+    // compiler's libstdc++ is the same C++ library, so the foreign system's
+    // detection agrees with the program, as it did before 0.17.0.
+    if (!r.msvc_abi && std::string_view(mcpp::compiler()) == "gcc") {
+        r.how    = mechanism::detected;
+        r.reason = "the GCC payload runs with a sysroot, binutils and a link model that only mcpp's "
+                   "own command lines carry; the host compiler's libstdc++ is the program's C++ library";
+        return r;
+    }
+
     const std::string instance = forward(mcpp::msvc_instance_dir());
     if (r.msvc_abi && !instance.empty() && c.cc == compiler::abi_native) {
         r.how              = mechanism::instance;

tests/plugin-logic/build.mcpp

@@ -176,41 +176,45 @@ int main(int argc, char** argv) {
                        "the compatibility note is printed");
           } },
 
-        { "vcpkg: the Linux GCC row is chained with vcpkg's linux.cmake",
+        { "vcpkg: the Linux GCC row keeps vcpkg's detection, and says why",
           with_vcpkg(t::row::linux_gcc()),
+          [] {
+              const auto r = ts::resolve();
+              std::printf("reason=%s\n", r ? r->reason.c_str() : "");
+              return vcpkg_use();
+          },
+          [](const t::result& r, t::checker& c) {
+              c.expect(r.has_line("mcpp:action=", {"deps-vcpkg:install:x64-linux\""}),
+                       "the standard triplet x64-linux is used");
+              c.expect(!r.has_line("mcpp:action=", {"MCPP_VCPKG_CXX="}), "no compiler is named");
+              c.expect(r.has_line("reason=", {"GCC payload"}), "the resolution states why");
+          } },
+
+        { "vcpkg: the Linux libc++ row hands over mcpp's clang through linux.cmake",
+          with_vcpkg(t::row::linux_libcxx()),
           [] { return vcpkg_use(); },
           [](const t::result& r, t::checker& c) {
-              const auto f = derived_triplet(r);
-              const auto name = stem(f);
+              const auto name = stem(derived_triplet(r));
               c.expect(name.starts_with("x64-linux-mcpp-"), "the derived triplet is x64-linux-mcpp-<hash>");
               c.expect(r.file("out/deps-vcpkg/triplets/mcpp-chain-linux.cmake")
                            .find("/scripts/toolchains/linux.cmake\")") != std::string::npos,
                        "the toolchain includes vcpkg's linux.cmake");
               const auto a = r.line("mcpp:action=", {"deps-vcpkg:install:" + name});
-              c.expect(a.find("MCPP_VCPKG_CXX=") != std::string::npos && a.find("gcc/bin/g++") != std::string::npos,
-                       "the row's g++ is handed to vcpkg");
+              c.expect(a.find("MCPP_VCPKG_CXX=") != std::string::npos && a.find("llvm/bin/clang++") != std::string::npos,
+                       "clang++ is handed to vcpkg");
               c.expect(a.find("--host-triplet") == std::string::npos, "host tools keep vcpkg's host triplet");
               c.expect(a.find("\"PATH=") == std::string::npos, "PATH is left alone off the MSVC ABI");
               first_linux_name = name;
           } },
 
         { "vcpkg: the derived triplet's name does not depend on where the tools are",
-          with_vcpkg(t::row::linux_gcc()),
+          with_vcpkg(t::row::linux_libcxx()),
           [] { return vcpkg_use(); },
           [](const t::result& r, t::checker& c) {
               c.expect(!first_linux_name.empty() && stem(derived_triplet(r)) == first_linux_name,
                        "the same toolset under another root derives the same triplet");
           } },
 
-        { "vcpkg: the Linux libc++ row hands over mcpp's clang",
-          with_vcpkg(t::row::linux_libcxx()),
-          [] { return vcpkg_use(); },
-          [](const t::result& r, t::checker& c) {
-              c.expect(r.has_line("mcpp:action=", {"MCPP_VCPKG_CXX=", "llvm/bin/clang++"}),
-                       "clang++ is handed to vcpkg");
-              c.expect(stem(derived_triplet(r)) != first_linux_name, "the two toolsets derive two triplets");
-          } },
-
         // ── deps-cmake ──────────────────────────────────────────────────────
         { "cmake: a Visual Studio toolset keeps the Visual Studio generator on that instance",
           with_subproject(t::row::windows_visual_studio("14.43.34808", "14.44.35207")),