Refactor toolchain providers

Author: Sunrisepeak

src/build/flags.cppm

@@ -11,7 +11,7 @@ export module mcpp.build.flags;
 import std;
 import mcpp.build.plan;
 import mcpp.toolchain.detect;
-import mcpp.xlings;
+import mcpp.toolchain.registry;
 
 export namespace mcpp::build {
 
@@ -37,30 +37,8 @@ namespace mcpp::build {
 
 namespace {
 
-std::filesystem::path derive_c_compiler(const std::filesystem::path& cxxPath) {
-    auto stem = cxxPath.stem().string();
-    auto parent = cxxPath.parent_path();
-    auto ext = cxxPath.extension();
-
-    // g++ → gcc, clang++ → clang, x86_64-linux-musl-g++ → x86_64-linux-musl-gcc
-    std::string cc_stem;
-    if (stem.ends_with("++")) {
-        cc_stem = stem.substr(0, stem.size() - 2);
-        // g++ → gcc; x86_64-linux-musl-g++ → x86_64-linux-musl-gcc;
-        // clang++ → clang.
-        if (cc_stem == "g" || cc_stem.ends_with("-g"))
-            cc_stem += "cc";  // g → gcc
-        // else clang++ → clang (already correct after stripping ++)
-    } else {
-        cc_stem = stem;  // fallback: same as cxx
-    }
-    return parent / (cc_stem + ext.string());
-}
-
 std::filesystem::path staged_std_bmi_path(const BuildPlan& plan) {
-    if (plan.toolchain.compiler == mcpp::toolchain::CompilerId::Clang)
-        return plan.outputDir / "pcm.cache" / "std.pcm";
-    return plan.outputDir / "gcm.cache" / "std.gcm";
+    return mcpp::toolchain::staged_std_bmi_path(plan.toolchain, plan.outputDir);
 }
 
 // Escape a path for embedding in ninja rule strings.
@@ -81,7 +59,7 @@ std::string escape_path(const std::filesystem::path& p) {
 CompileFlags compute_flags(const BuildPlan& plan) {
     CompileFlags f;
     f.cxxBinary = plan.toolchain.binaryPath;
-    f.ccBinary = derive_c_compiler(plan.toolchain.binaryPath);
+    f.ccBinary = mcpp::toolchain::derive_c_compiler(plan.toolchain);
     f.toolEnv = mcpp::toolchain::compiler_env_prefix(plan.toolchain);
 
     // PIC?
@@ -109,14 +87,13 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     }
 
     // Binutils -B flag
-    bool isMuslTc = plan.toolchain.targetTriple.find("-musl") != std::string::npos;
-    bool isClang = plan.toolchain.compiler == mcpp::toolchain::CompilerId::Clang;
+    bool isMuslTc = mcpp::toolchain::is_musl_target(plan.toolchain);
+    bool isClang = mcpp::toolchain::is_clang(plan.toolchain);
     std::filesystem::path binutilsBin;
     if (!isMuslTc && !isClang) {
-        if (auto ar = mcpp::xlings::paths::find_sibling_binary(
-                plan.toolchain.binaryPath, "binutils", "bin/ar")) {
-            binutilsBin = ar->parent_path();  // bin/ar → bin/
-        }
+        auto ar = mcpp::toolchain::archive_tool(plan.toolchain);
+        if (!ar.empty())
+            binutilsBin = ar.parent_path();
     }
     std::string b_flag;
     if (!binutilsBin.empty()) {
@@ -125,17 +102,7 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     }
 
     // AR binary
-    if (isClang) {
-        auto llvmAr = plan.toolchain.binaryPath.parent_path() / "llvm-ar";
-        if (std::filesystem::exists(llvmAr))
-            f.arBinary = llvmAr;
-    } else if (!binutilsBin.empty()) {
-        f.arBinary = binutilsBin / "ar";
-    } else if (isMuslTc) {
-        auto muslAr = plan.toolchain.binaryPath.parent_path() / "x86_64-linux-musl-ar";
-        if (std::filesystem::exists(muslAr))
-            f.arBinary = muslAr;
-    }
+    f.arBinary = mcpp::toolchain::archive_tool(plan.toolchain);
 
     // Opt level (musl ICE workaround)
     std::string opt_flag = isMuslTc ? " -Og" : " -O2";

src/build/ninja_backend.cppm

@@ -24,6 +24,7 @@ import mcpp.build.flags;
 import mcpp.build.compile_commands;
 import mcpp.dyndep;
 import mcpp.toolchain.detect;
+import mcpp.toolchain.registry;
 import mcpp.xlings;
 
 export namespace mcpp::build {
@@ -118,39 +119,6 @@ std::filesystem::path mcpp_exe_path() {
     return "mcpp";  // fall back to PATH lookup
 }
 
-// Derive a sibling C compiler from a C++ compiler binary path. Used so .c
-// sources can be compiled by the actual C frontend (cc1), not g++ which
-// rejects implicit `void*` conversions and `restrict` etc.
-//   .../bin/g++                       → .../bin/gcc
-//   .../bin/x86_64-linux-musl-g++     → .../bin/x86_64-linux-musl-gcc
-//   .../bin/clang++                   → .../bin/clang
-//   .../bin/c++                       → .../bin/cc
-// If no sibling exists, return "gcc" so PATH lookup is the final fallback
-// (this also keeps unit tests that don't touch a real toolchain happy).
-std::filesystem::path derive_c_compiler(const std::filesystem::path& cxx) {
-    auto fname = cxx.filename().string();
-    auto try_replace = [&](std::string_view from,
-                           std::string_view to) -> std::optional<std::filesystem::path> {
-        auto pos = fname.rfind(from);
-        if (pos == std::string::npos)
-            return std::nullopt;
-        std::string repl = fname;
-        repl.replace(pos, from.size(), to);
-        auto p = cxx.parent_path() / repl;
-        std::error_code ec;
-        if (std::filesystem::exists(p, ec))
-            return p;
-        return std::nullopt;
-    };
-    if (auto p = try_replace("clang++", "clang"))
-        return *p;
-    if (auto p = try_replace("g++", "gcc"))
-        return *p;
-    if (auto p = try_replace("c++", "cc"))
-        return *p;
-    return "gcc";
-}
-
 bool is_c_source(const std::filesystem::path& src) {
     return src.extension() == ".c";
 }
@@ -159,7 +127,7 @@ bool is_c_source(const std::filesystem::path& src) {
 
 std::string emit_ninja_string(const BuildPlan& plan) {
     bool dyndep = dyndep_mode_enabled()
-               && plan.toolchain.compiler == mcpp::toolchain::CompilerId::GCC;
+               && mcpp::toolchain::is_gcc(plan.toolchain);
     std::string out;
     auto append = [&](std::string s) { out += std::move(s); };
 
@@ -278,9 +246,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     }
 
     // Stage prebuilt std artifacts into the compiler-specific BMI cache.
-    auto std_bmi_dst = plan.toolchain.compiler == mcpp::toolchain::CompilerId::Clang
-        ? std::filesystem::path("pcm.cache") / "std.pcm"
-        : std::filesystem::path("gcm.cache") / "std.gcm";
+    auto std_bmi_dst = mcpp::toolchain::staged_std_bmi_path(plan.toolchain, {});
     auto std_o_dst = std::filesystem::path("obj") / "std.o";
 
     bool has_std_artifacts = !plan.stdBmiPath.empty() && !plan.stdObjectPath.empty();