fix: macOS link strategy — no sysroot for linker + 3-step self-host CI

Root cause: passing --sysroot to macOS linker forces it to use SDK
.tbd stubs which lack libc++abi exports. Fix: only pass sysroot to
compiler (for headers), let clang++ driver handle linking natively.

CI now validates 3 steps:
1. xmake builds mcpp (bootstrap)
2. That mcpp builds itself (self-host)
3. The self-hosted mcpp builds itself again (stability proof)

Author: Sunrisepeak

.github/workflows/ci-macos.yml

@@ -268,15 +268,57 @@ jobs:
             *)              echo "FAIL: unexpected platform"; exit 1 ;;
           esac
 
-      - name: Install mcpp@0.0.16 via xlings
+      - name: Build mcpp (xmake bootstrap)
         run: |
-          xlings install mcpp -y
-          mcpp --version
+          # Step 1: Use xmake to produce first mcpp binary from source
+          brew install xmake
+          cat > xmake.lua << 'XMAKE'
+          add_rules("mode.release")
+          set_languages("c++23")
+          package("cmdline")
+              set_homepage("https://github.com/mcpplibs/cmdline")
+              add_urls("https://github.com/mcpplibs/cmdline/archive/refs/tags/$(version).tar.gz")
+              add_versions("0.0.1", "3fb2f5495c1a144485b3cbb2e43e27059151633460f702af0f3851cbff387ef0")
+              on_install(function (package)
+                  import("package.tools.xmake").install(package)
+              end)
+          package_end()
+          add_requires("cmdline 0.0.1")
+          target("mcpp")
+              set_kind("binary")
+              add_files("src/main.cpp")
+              add_files("src/**.cppm")
+              add_packages("cmdline")
+              add_includedirs("src/libs/json")
+              set_policy("build.c++.modules", true)
+          XMAKE
+          xmake f -y -m release --toolchain=llvm --sdk="$LLVM_ROOT"
+          xmake build -y mcpp
+          rm -f xmake.lua
+          MCPP_V1=$(find build -name mcpp -type f -perm +111 | head -1)
+          test -x "$MCPP_V1"
+          "$MCPP_V1" --version
+          echo ":: Step 1 PASS: xmake produced mcpp"
+          echo "MCPP_V1=$MCPP_V1" >> "$GITHUB_ENV"
 
       - name: Self-host (mcpp builds mcpp)
         run: |
+          # Step 2: Use the xmake-built mcpp to build itself
+          export PATH="$(dirname "$MCPP_V1"):$PATH"
           mcpp build
-          SELFHOST=$(find target -path "*/bin/mcpp" | head -1)
-          test -x "$SELFHOST"
-          "$SELFHOST" --version
-          echo ":: Self-host successful!"
+          MCPP_V2=$(find target -path "*/bin/mcpp" -not -path "*/build/*" | head -1)
+          test -x "$MCPP_V2"
+          "$MCPP_V2" --version
+          echo ":: Step 2 PASS: mcpp self-hosted"
+          echo "MCPP_V2=$MCPP_V2" >> "$GITHUB_ENV"
+
+      - name: Self-host again (v2 builds itself)
+        run: |
+          # Step 3: Use the self-hosted mcpp to build itself again (proves stability)
+          rm -rf target
+          export PATH="$(dirname "$MCPP_V2"):$PATH"
+          mcpp build
+          MCPP_V3=$(find target -path "*/bin/mcpp" -not -path "*/build/*" | head -1)
+          test -x "$MCPP_V3"
+          "$MCPP_V3" --version
+          echo ":: Step 3 PASS: mcpp self-host stable (v2 → v3)"

src/build/flags.cppm

@@ -161,15 +161,21 @@ CompileFlags compute_flags(const BuildPlan& plan) {
         runtime_dirs += " -L" + escape_path(dir);
         runtime_dirs += " -Wl,-rpath," + escape_path(dir);
     }
+
 #if defined(__APPLE__)
-    // macOS: explicitly link libc++ when using Clang with xlings LLVM.
-    // The cfg's -nostdinc++ suppresses the implicit -lc++ that clang++ normally adds.
-    std::string stdlib_link = isClang ? " -lc++" : "";
+    // macOS linking strategy:
+    // - Do NOT pass --sysroot to the linker. The macOS SDK contains .tbd
+    //   stubs that lack libc++abi exports, causing undefined symbols for
+    //   exception/RTTI infrastructure. Without --sysroot, clang++ driver
+    //   uses the system default (/usr/lib/libc++, libc++abi, libSystem)
+    //   which works correctly.
+    // - sysroot is still used for compilation (finding system headers).
+    f.ld = std::format("{}{}{}{}", full_static, static_stdlib, b_flag, runtime_dirs);
 #else
-    std::string stdlib_link;
+    // Linux: sysroot must be passed to linker (glibc/musl lives there)
+    f.ld = std::format("{}{}{}{}{}", full_static, static_stdlib, sysroot_flag, b_flag,
+                       runtime_dirs);
 #endif
-    f.ld = std::format("{}{}{}{}{}{}", full_static, static_stdlib, sysroot_flag, b_flag,
-                       runtime_dirs, stdlib_link);
 
     return f;
 }