feat(toolchain): MinGW-w64 GCC via the xlings ecosystem (mingw@16.1.0) (0.0.89)

User-facing 'mingw' spec → xim:mingw-gcc (winlibs GCC 16.1.0 + MinGW-w64
14.0.0 UCRT standalone build, mirrored at xlings-res/mingw-gcc). Reuses the
GCC backend end-to-end (gcm module pipeline, bits/std.cc import std);
Windows adds static libstdc++/libgcc defaults so produced exes run
standalone, and -static under linkage="static". archive_tool resolves the
bundled ar.exe; std.cc lookup gains a version-dir scan fallback.

Fixes ridden along: toolchain list 'Available' + partial-version resolution
read xpkg versions for the HOST platform (was hardcoded linux — empty on
win/mac); toolchain install no longer pulls glibc/linux-headers on win/mac.

e2e 97 (requires: windows cap) + ci-windows MinGW step + unit tests
(dialect rows, mingw spec mapping); docs + CHANGELOG; version 0.0.89.

Author: Sunrisepeak

.github/workflows/ci-windows.yml

@@ -220,6 +220,16 @@ jobs:
           cd hello_win
           "$MCPP_SELF" run
 
+      # MinGW-w64 GCC via the xlings ecosystem (xim:mingw-gcc → xlings-res
+      # winlibs mirror): install → default → modules build/run → standalone
+      # exe. Same flow as e2e 97 but as a visible CI step. Payload is cached
+      # via the mcpp sandbox cache after the first run.
+      - name: "Toolchain: MinGW — install → build → run (xim:mingw-gcc)"
+        shell: bash
+        run: |
+          export MCPP_VENDORED_XLINGS="$XLINGS_BIN"
+          MCPP="$MCPP_SELF" bash tests/e2e/97_mingw_toolchain.sh
+
       # windows-latest ships VS 2022 Enterprise with the VC workload, so
       # msvc@system detection MUST succeed here — a failure is a regression
       # in the discovery/identification chain (vswhere → env → paths).

CHANGELOG.md

@@ -3,6 +3,36 @@
 > 本文件追踪 `mcpp-community/mcpp` 公开仓的版本演进。
 > 格式参考 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)。
 
+## [0.0.89] — 2026-07-13
+
+### 新增
+
+- **MinGW-w64 工具链入 xlings 生态(Windows 原生 GCC,无需 Visual Studio)**。
+  `mcpp toolchain install mingw 16.1.0` / `default mingw@16.1.0`:xim 包
+  `mingw-gcc`(winlibs GCC 16.1.0 + MinGW-w64 14.0.0 UCRT 独立构建,镜像于
+  xlings-res/mingw-gcc,GitHub+GitCode 双端)。复用既有 GCC 后端
+  (gcm 模块管线、libstdc++ `bits/std.cc` 的 `import std`);Windows 上
+  libstdc++/libgcc 默认静态链接(产物免带 DLL,`[build] static_stdlib=false`
+  可关),`linkage="static"` 升级全静态。e2e 97 覆盖 install→default→
+  多模块 build/run→独立 exe 验证;ci-windows 新增专项步骤。
+  连带修复:`toolchain list` 的 Available 段与部分版本解析此前硬编码按
+  "linux" 平台读取 xpkg 版本(Windows/macOS 上恒空);`toolchain install`
+  在 Windows/macOS 不再错误安装 glibc/linux-headers 依赖。
+
+### 重构
+
+- **工具链后端抽象层(Part A,对 GCC/Clang 零行为变化,build.ninja 零 diff
+  实证)**。新增 `mcpp.toolchain.dialect`(命令行拼写 traits:gnu/msvc 两行
+  数据,`-I/-D/-std=/-c/-o/-O/-g/ar` 及归档命令模板经其发射);`BmiTraits`
+  并入模块旗标拼写(`compileModulesFlag`/`stdBmiUsePrefix`/
+  `moduleOutputPrefix`/`bmiSearchPrefix`),flags.cppm 的 is_clang 分支改由
+  数据驱动;`ProviderCapabilities.has_builtin_p1689_scan` 取代 ninja 后端的
+  is_gcc 门;`Toolchain::envOverrides`(EnvVar 表,注入 ninja 子进程环境,
+  为 MSVC 后端 INCLUDE/LIB/PATH 预留);gcc provider 增加与 clang 同形的
+  `std_module_build_commands`(命令序列);`resolve_link_model` 在 Windows
+  显式返回 PE 空模型。设计:`.agents/docs/2026-07-13-toolchain-backend-
+  abstraction-msvc-mingw-design.md` + 同日触点审计文档。
+
 ## [0.0.88] — 2026-07-13
 
 ### 新增

docs/03-toolchains.md

@@ -69,6 +69,30 @@ Available (run `mcpp toolchain install <compiler> <version>`):
 
 The entry marked with `*` is the current default toolchain. `@mcpp/...` is shorthand for `~/.mcpp/...`, used to keep the output narrower.
 
+## MinGW (Windows-native GCC, no Visual Studio required)
+
+On Windows, `mingw` installs a self-contained MinGW-w64 GCC (winlibs
+standalone build, UCRT runtime) into mcpp's sandbox — the same managed-xpkg
+model as `gcc`/`llvm`, no Visual Studio needed:
+
+```bash
+mcpp toolchain install mingw 16.1.0
+mcpp toolchain default mingw@16.1.0
+```
+
+It uses the regular GCC module pipeline (`gcm.cache`, `import std` via
+libstdc++'s `bits/std.cc`). Produced binaries statically link libstdc++ and
+libgcc by default, so they run standalone — no `libstdc++-6.dll` needs to
+travel next to your exe (opt out with `[build] static_stdlib = false`).
+`[build] linkage = "static"` upgrades that to a fully static link.
+
+In a manifest:
+
+```toml
+[toolchain]
+windows = "mingw@16.1.0"
+```
+
 ## MSVC (System Toolchain, Windows)
 
 MSVC is different from every other toolchain mcpp manages: it is a **system

mcpp.toml

@@ -1,6 +1,6 @@
 [package]
 name        = "mcpp"
-version     = "0.0.88"
+version     = "0.0.89"
 description = "Modern C++ build & package management tool"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]

src/toolchain/fingerprint.cppm

@@ -18,7 +18,7 @@ import mcpp.toolchain.detect;
 
 export namespace mcpp::toolchain {
 
-inline constexpr std::string_view MCPP_VERSION = "0.0.88";
+inline constexpr std::string_view MCPP_VERSION = "0.0.89";
 
 struct FingerprintInputs {
     Toolchain                       toolchain;

src/toolchain/gcc.cppm

@@ -70,6 +70,21 @@ std::optional<std::filesystem::path> find_std_module_source(
     auto p = root / "include" / "c++" / std::string(version) / "bits" / "std.cc";
     if (std::filesystem::exists(p)) return p;
 
+    // Version-dir scan fallback: the header dir doesn't always equal the
+    // full driver version (e.g. distro / MinGW-w64 builds using the major
+    // version, or a patched banner). Any bits/std.cc under include/c++ is
+    // this installation's — take the first.
+    {
+        std::error_code ec;
+        auto cxxInclude = root / "include" / "c++";
+        if (std::filesystem::exists(cxxInclude, ec)) {
+            for (auto& entry : std::filesystem::directory_iterator(cxxInclude, ec)) {
+                auto cand = entry.path() / "bits" / "std.cc";
+                if (std::filesystem::exists(cand, ec)) return cand;
+            }
+        }
+    }
+
     auto cmd = std::format("'{}' -print-file-name=libstdc++.so 2>/dev/null",
                            cxx_binary.string());
     auto r = mcpp::toolchain::run_capture(cmd);

src/toolchain/lifecycle.cppm

@@ -123,7 +123,15 @@ list_available_xpkg_versions(const mcpp::config::GlobalConfig& cfg,
         if (!std::filesystem::exists(p, ec)) return std::nullopt;
         std::ifstream is(p);
         std::string body((std::istreambuf_iterator<char>(is)), {});
-        return mcpp::manifest::list_xpkg_versions(body, "linux");
+        // xpkg descriptors key platforms as linux / macosx / windows — list
+        // the HOST's block (previously hardcoded "linux", which made the
+        // Available section and partial-version resolution empty on
+        // Windows/macOS for any package, e.g. mingw-gcc has no linux block).
+        constexpr std::string_view xpkgPlatform =
+            mcpp::platform::is_windows ? "windows"
+          : mcpp::platform::is_macos   ? "macosx"
+                                       : "linux";
+        return mcpp::manifest::list_xpkg_versions(body, xpkgPlatform);
     };
 
     auto data = cfg.xlingsHome() / "data";
@@ -388,8 +396,11 @@ export int toolchain_install(const mcpp::config::GlobalConfig& cfg,
 
         // Ensure sysroot dependencies (glibc, linux-headers) are installed.
         // These are required for C library + kernel headers during compilation.
-        // musl-gcc is self-contained and doesn't need these.
-        if (!spec->isMusl) {
+        // musl-gcc is self-contained and doesn't need these; neither do
+        // Windows (llvm/mingw — PE, own CRT) or macOS (SDK) toolchains.
+        // Mirrors the platform guard on prepare.cppm's first-run install.
+        if (!spec->isMusl
+            && !mcpp::platform::is_windows && !mcpp::platform::is_macos) {
             for (auto dep : {"xim:glibc", "xim:linux-headers"}) {
                 mcpp::log::verbose("toolchain", std::format("installing dep: {}", dep));
                 auto depPayload = fetcher.resolve_xpkg_path(dep, /*autoInstall=*/true, &progress);

src/toolchain/model.cppm

@@ -65,6 +65,7 @@ bool is_gcc(const Toolchain& tc);
 bool is_clang(const Toolchain& tc);
 bool is_musl_target(const Toolchain& tc);
 bool is_msvc_target(const Toolchain& tc);
+bool is_mingw_target(const Toolchain& tc);
 
 struct BmiTraits {
     std::string_view bmiDir;     // "gcm.cache" | "pcm.cache" | "ifc.cache"
@@ -103,6 +104,11 @@ bool is_msvc_target(const Toolchain& tc) {
     return tc.targetTriple.find("msvc") != std::string::npos;
 }
 
+bool is_mingw_target(const Toolchain& tc) {
+    // "x86_64-w64-mingw32" (mingw-w64) / legacy "*-pc-mingw32".
+    return tc.targetTriple.find("mingw32") != std::string::npos;
+}
+
 BmiTraits bmi_traits(const Toolchain& tc) {
     if (tc.compiler == CompilerId::MSVC) {
         // Native cl.exe builds are gated off until the .ifc pipeline lands;

src/toolchain/registry.cppm

@@ -3,6 +3,7 @@
 export module mcpp.toolchain.registry;
 
 import std;
+import mcpp.platform;
 import mcpp.toolchain.clang;
 import mcpp.toolchain.gcc;
 import mcpp.toolchain.llvm;
@@ -101,6 +102,7 @@ std::vector<std::string> frontend_candidates_for(std::string_view ximName,
     if (ximName == "gcc") return {"g++"};
     if (ximName == "llvm") return mcpp::toolchain::llvm::frontend_candidates();
     if (ximName == "msvc") return {"cl.exe"};
+    if (ximName == "mingw-gcc") return {"g++.exe", "g++"};
     return {"g++", "clang++", "x86_64-linux-musl-g++", "cl.exe"};
 }
 
@@ -170,6 +172,10 @@ XimToolchainPackage to_xim_package(const ToolchainSpec& spec) {
     std::string ximCompiler = spec.compiler;
     if (mcpp::toolchain::llvm::is_alias(ximCompiler))
         ximCompiler = mcpp::toolchain::llvm::package_name();
+    // Windows-native MinGW-w64 GCC: user-facing name `mingw`, xim package
+    // `mingw-gcc` (winlibs GCC+MinGW-w64 UCRT builds mirrored at xlings-res).
+    if (ximCompiler == "mingw")
+        ximCompiler = "mingw-gcc";
 
     pkg.ximName = ximCompiler;
     pkg.ximVersion = spec.version;
@@ -221,6 +227,8 @@ std::filesystem::path toolchain_frontend(const std::filesystem::path& binDir,
 std::string display_label(std::string_view compiler, std::string_view version) {
     if (compiler == "musl-gcc")
         return std::format("gcc {}-musl", version);
+    if (compiler == "mingw-gcc")
+        return std::format("mingw {}", version);
     return std::format("{} {}", compiler, version);
 }
 
@@ -235,6 +243,12 @@ bool matches_default_toolchain(std::string_view configuredDefault,
     // The persisted msvc default is always the stable "msvc@system" (never a
     // concrete version), so it matches whatever version detection reports.
     if (compiler == "msvc" && configuredDefault == "msvc@system") return true;
+    // Installed-payload rows report the xim name (mingw-gcc); the user-facing
+    // spec is mingw@<ver> (same shape as the musl-gcc clause above).
+    if (compiler == "mingw-gcc"
+        && configuredDefault == std::format("mingw@{}", version)) {
+        return true;
+    }
     return false;
 }
 
@@ -243,11 +257,15 @@ bool is_system_toolchain(const ToolchainSpec& spec) {
 }
 
 std::vector<std::pair<std::string, std::string>> available_toolchain_indexes() {
-    return {
+    std::vector<std::pair<std::string, std::string>> out{
         {"gcc",      "gcc"},
         {"musl-gcc", "musl-gcc"},
         {mcpp::toolchain::llvm::package_name(), "llvm"},
     };
+    // Windows-native toolchain — only meaningful to list on Windows hosts.
+    if constexpr (mcpp::platform::is_windows)
+        out.emplace_back("mingw-gcc", "mingw-gcc");
+    return out;
 }
 
 std::filesystem::path derive_c_compiler(const Toolchain& tc) {
@@ -257,6 +275,15 @@ std::filesystem::path derive_c_compiler(const Toolchain& tc) {
 std::filesystem::path archive_tool(const Toolchain& tc) {
     if (is_clang(tc)) return mcpp::toolchain::clang::archive_tool(tc);
 
+    // MinGW bundles its own binutils next to the frontend (self-contained,
+    // like musl) — never an external binutils xpkg.
+    if (is_mingw_target(tc)) {
+        auto ar = tc.binaryPath.parent_path() / "ar.exe";
+        std::error_code ec;
+        if (std::filesystem::exists(ar, ec)) return ar;
+        return {};
+    }
+
     if (!is_musl_target(tc)) {
         if (auto binutilsBin = mcpp::toolchain::gcc::find_binutils_bin(tc.binaryPath))
             return *binutilsBin / "ar";

tests/e2e/97_mingw_toolchain.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# requires: windows
+# 97_mingw_toolchain.sh — Windows-native MinGW-w64 GCC via the xlings
+# ecosystem (xim:mingw-gcc, winlibs GCC 16.1.0 UCRT):
+#   - `toolchain install mingw 16.1.0` resolves + installs the xpkg
+#   - `toolchain default mingw@16.1.0` persists; `list` stars `mingw 16.1.0`
+#   - new → build → run works with import std + a named module (gcm pipeline)
+#   - the produced exe is portable: runs from a clean dir without the
+#     toolchain's bin on PATH (static libstdc++/libgcc defaults)
+set -e
+
+CONF="${MCPP_HOME:-$HOME/.mcpp}/config.toml"
+ORIG_DEFAULT=""
+if [[ -f "$CONF" ]]; then
+    ORIG_DEFAULT=$(sed -n '/^\[toolchain\]/,/^\[/p' "$CONF" \
+        | grep '^default' | head -1 | cut -d'"' -f2 || true)
+fi
+TMP=$(mktemp -d)
+restore() {
+    if [[ -n "$ORIG_DEFAULT" ]]; then
+        "$MCPP" toolchain default "$ORIG_DEFAULT" >/dev/null 2>&1 || true
+    fi
+    rm -rf "$TMP"
+}
+trap restore EXIT
+
+cd "$TMP"   # neutral cwd — project mcpp.toml [toolchain] must not shadow
+
+# 1) install via the xlings ecosystem (xlings-res mirror)
+out=$("$MCPP" toolchain install mingw 16.1.0 2>&1) \
+    || { echo "FAIL: install mingw: $out"; exit 1; }
+[[ "$out" == *"Installed"* || "$out" == *"already"* || "$out" == *"mingw"* ]] \
+    || { echo "FAIL: install output: $out"; exit 1; }
+
+# 2) switch default + list shows it starred
+"$MCPP" toolchain default mingw@16.1.0 \
+    || { echo "FAIL: default mingw@16.1.0"; exit 1; }
+out=$("$MCPP" toolchain list 2>&1)
+echo "$out" | grep -E '\*\s*mingw 16\.1\.0' >/dev/null \
+    || { echo "FAIL: mingw not starred: $out"; exit 1; }
+
+# 3) real build: import std + named module through the gcm pipeline
+"$MCPP" new hello_mingw >/dev/null 2>&1
+cd hello_mingw
+mkdir -p src
+cat > src/greet.cppm <<'EOF'
+export module hello.greet;
+import std;
+export namespace hello {
+std::string greet() { return "mingw-ok"; }
+}
+EOF
+cat > src/main.cpp <<'EOF'
+import std;
+import hello.greet;
+int main() { std::println("{}", hello::greet()); return 0; }
+EOF
+out=$("$MCPP" build 2>&1) || { echo "FAIL: build: $out"; exit 1; }
+run_out=$("$MCPP" run 2>&1) || { echo "FAIL: run: $run_out"; exit 1; }
+[[ "$run_out" == *"mingw-ok"* ]] || { echo "FAIL: run output: $run_out"; exit 1; }
+
+# 4) portability: the exe must run from a clean dir WITHOUT the toolchain
+#    bin dir on PATH (no libstdc++-6.dll / libgcc_s hitchhikers needed).
+EXE=$(find target -name "hello_mingw.exe" -path "*/bin/*" | head -1)
+[[ -n "$EXE" ]] || { echo "FAIL: no exe produced"; exit 1; }
+ISO="$TMP/iso"; mkdir -p "$ISO"
+cp "$EXE" "$ISO/"
+iso_out=$(cd "$ISO" && PATH="/usr/bin:/c/Windows/System32" ./hello_mingw.exe 2>&1) \
+    || { echo "FAIL: exe not standalone (static libstdc++/libgcc?): $iso_out"; exit 1; }
+[[ "$iso_out" == *"mingw-ok"* ]] || { echo "FAIL: standalone output: $iso_out"; exit 1; }
+
+echo "PASS: mingw toolchain — install, default, modules build/run, standalone exe"