Add LLVM import std toolchain support

Sunrisepeak · Sunrisepeak · commit 830092755a6a · 2026-05-13T13:01:47.000+08:00
diff --git a/src/build/flags.cppm b/src/build/flags.cppm
@@ -57,6 +57,12 @@ std::filesystem::path derive_c_compiler(const std::filesystem::path& cxxPath) {
     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";
+}
+
 // Escape a path for embedding in ninja rule strings.
 std::string escape_path(const std::filesystem::path& p) {
     auto s = p.string();
@@ -152,8 +158,12 @@ CompileFlags compute_flags(const BuildPlan& plan) {
 
     // Assemble
     std::string module_flag = isClang ? "" : " -fmodules";
-    f.cxx = std::format("-std=c++23{}{}{}{}{}{}{}", module_flag, opt_flag, pic_flag,
-                        sysroot_flag, b_flag, include_flags, user_cxxflags);
+    std::string std_module_flag;
+    if (isClang && !plan.stdBmiPath.empty()) {
+        std_module_flag = " -fmodule-file=std=" + escape_path(staged_std_bmi_path(plan));
+    }
+    f.cxx = std::format("-std=c++23{}{}{}{}{}{}{}{}", module_flag, std_module_flag,
+                        opt_flag, pic_flag, sysroot_flag, b_flag, include_flags, user_cxxflags);
     f.cc = std::format("-std={}{}{}{}{}{}{}", c_std, opt_flag, pic_flag, sysroot_flag, b_flag,
                        include_flags, user_cflags);
 
diff --git a/src/build/ninja_backend.cppm b/src/build/ninja_backend.cppm
@@ -277,8 +277,10 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         append("  restat = 1\n\n");
     }
 
-    // Stage prebuilt std artifacts into our gcm.cache/
-    auto std_bmi_dst = std::filesystem::path("gcm.cache") / "std.gcm";
+    // 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_o_dst = std::filesystem::path("obj") / "std.o";
 
     bool has_std_artifacts = !plan.stdBmiPath.empty() && !plan.stdObjectPath.empty();
@@ -383,7 +385,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
                 for (auto& imp : cu.imports) {
                     if (imp == "std" || imp == "std.compat") {
                         if (has_std_artifacts)
-                            implicit += " gcm.cache/std.gcm";
+                            implicit += " " + escape_ninja_path(std_bmi_dst);
                         continue;
                     }
                     implicit += " " + bmi_path(imp);
diff --git a/src/cli.cppm b/src/cli.cppm
@@ -35,6 +35,7 @@ import mcpp.pm.resolver;   // PR-R4: extracted from cli.cppm
 import mcpp.pm.commands;   // PR-R5: cmd_add / cmd_remove / cmd_update live here now
 import mcpp.pm.mangle;     // Level 1 multi-version fallback (cross-major coexistence)
 import mcpp.pm.compat;     // 0.0.6: namespace field + dotted-name compat shims
+import mcpp.pm.dep_spec;
 import mcpp.ui;
 import mcpp.bmi_cache;
 import mcpp.dyndep;
@@ -1348,9 +1349,22 @@ prepare_build(bool print_fingerprint,
             auto fqname = ns.empty() ? shortName
                 : std::format("{}.{}", ns, shortName);
             mcpp::ui::info("Downloading", std::format("{} v{}", fqname, version));
-            std::vector<std::string> targets{ std::format("{}@{}", fqname, version) };
-            CliInstallProgress progress;
-            auto r = fetcher.install(targets, &progress);
+            auto install_one = [&](std::string target) {
+                std::vector<std::string> targets{ std::move(target) };
+                CliInstallProgress progress;
+                return fetcher.install(targets, &progress);
+            };
+            auto target = std::format("{}@{}", fqname, version);
+            auto r = install_one(target);
+            if (r && r->exitCode != 0 &&
+                (ns.empty() || ns == mcpp::pm::kDefaultNamespace)) {
+                auto compatTarget = std::format("compat.{}@{}", shortName, version);
+                if (compatTarget != target) {
+                    mcpp::ui::info("Downloading", std::format("{} v{}",
+                                     std::format("compat.{}", shortName), version));
+                    r = install_one(compatTarget);
+                }
+            }
             if (!r) return std::unexpected(std::format(
                 "fetch '{}@{}': {}", depName, version, r.error().message));
             if (r->exitCode != 0) {
diff --git a/src/config.cppm b/src/config.cppm
@@ -46,6 +46,7 @@ struct GlobalConfig {
     // From config.toml [xlings]
     std::string                     xlingsBinaryMode;    // "bundled" | "system" | absolute path
     std::filesystem::path           xlingsHomeOverride;  // empty = use registryDir
+    std::string                     xlingsMirror = "CN"; // "CN" | "GLOBAL" | empty = xlings default
 
     // From config.toml [index]
     std::string                     defaultIndex;        // "mcpplibs"
@@ -174,6 +175,30 @@ void write_file(const std::filesystem::path& p, std::string_view content) {
     os << content;
 }
 
+std::string normalize_xlings_mirror(std::string mirror) {
+    for (char& ch : mirror) {
+        if (ch >= 'a' && ch <= 'z') ch = static_cast<char>(ch - 'a' + 'A');
+    }
+    return mirror;
+}
+
+std::optional<std::string> read_xlings_json_mirror(const std::filesystem::path& path) {
+    std::ifstream is(path);
+    if (!is) return std::nullopt;
+    std::stringstream ss;
+    ss << is.rdbuf();
+    auto content = ss.str();
+    auto key = content.find("\"mirror\"");
+    if (key == std::string::npos) return std::nullopt;
+    auto colon = content.find(':', key);
+    if (colon == std::string::npos) return std::nullopt;
+    auto first = content.find('"', colon + 1);
+    if (first == std::string::npos) return std::nullopt;
+    auto second = content.find('"', first + 1);
+    if (second == std::string::npos) return std::nullopt;
+    return content.substr(first + 1, second - first - 1);
+}
+
 bool write_default_config_toml(const std::filesystem::path& path) {
     constexpr auto tmpl = R"(# mcpp global config — auto-generated; safe to edit.
 
@@ -182,6 +207,8 @@ bool write_default_config_toml(const std::filesystem::path& path) {
 binary = "bundled"
 # home:   empty = use $MCPP_HOME/registry; can override
 home   = ""
+# mirror: "CN" | "GLOBAL" | "" (defer to xlings)
+mirror = "CN"
 
 [index]
 default = "mcpplibs"
@@ -202,7 +229,8 @@ default_backend = "ninja"
 }
 
 bool write_default_xlings_json(const std::filesystem::path& path,
-                               const std::vector<IndexRepo>& repos)
+                               const std::vector<IndexRepo>& repos,
+                               std::string_view mirror)
 {
     // Delegate to xlings module. Convert IndexRepo vec to pair span.
     std::vector<std::pair<std::string,std::string>> pairs;
@@ -212,7 +240,7 @@ bool write_default_xlings_json(const std::filesystem::path& path,
     // construct a temporary Env with home = path.parent_path().
     mcpp::xlings::Env env;
     env.home = path.parent_path();
-    mcpp::xlings::seed_xlings_json(env, pairs);
+    mcpp::xlings::seed_xlings_json(env, pairs, mirror);
     return std::filesystem::exists(path);
 }
 
@@ -356,6 +384,15 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
     cfg.xlingsBinaryMode = doc->get_string("xlings.binary").value_or("bundled");
     if (auto h = doc->get_string("xlings.home"); h && !h->empty())
         cfg.xlingsHomeOverride = *h;
+    cfg.xlingsMirror = normalize_xlings_mirror(
+        doc->get_string("xlings.mirror").value_or("CN"));
+    if (!cfg.xlingsMirror.empty() &&
+        cfg.xlingsMirror != "CN" &&
+        cfg.xlingsMirror != "GLOBAL") {
+        return std::unexpected(ConfigError{
+            std::format("invalid xlings.mirror '{}': expected CN, GLOBAL, or empty",
+                        cfg.xlingsMirror)});
+    }
     cfg.defaultIndex   = doc->get_string("index.default").value_or("mcpplibs");
     cfg.searchTtlSeconds = doc->get_int("cache.search_ttl_seconds").value_or(3600);
     cfg.defaultJobs    = doc->get_int("build.default_jobs").value_or(0);
@@ -387,7 +424,7 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
     // 5. Seed registry/.xlings.json if missing
     auto xjson = cfg.xlingsHome() / ".xlings.json";
     if (!std::filesystem::exists(xjson)) {
-        write_default_xlings_json(xjson, cfg.indexRepos);
+        write_default_xlings_json(xjson, cfg.indexRepos, cfg.xlingsMirror);
     }
 
     // 6. Acquire xlings binary if needed
@@ -408,6 +445,15 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
                 "configured xlings binary not found: {}", cfg.xlingsBinary.string())});
     }
 
+    if (!cfg.xlingsMirror.empty() &&
+        read_xlings_json_mirror(xjson).value_or("") != cfg.xlingsMirror) {
+        auto rc = mcpp::xlings::set_mirror(make_xlings_env(cfg), cfg.xlingsMirror, true);
+        if (rc != 0 && !quiet) {
+            std::println(stderr,
+                "warning: failed to set xlings mirror to '{}'", cfg.xlingsMirror);
+        }
+    }
+
     // 7. Sandbox bootstrap (mcpp self-contained xlings environment).
     //    Order matters:
     //      a. Mirror xlings binary into sandbox so shim creation works.
@@ -429,6 +475,8 @@ void print_env(const GlobalConfig& cfg) {
     std::println("MCPP_HOME           = {}", cfg.mcppHome.string());
     std::println("xlings binary       = {}", cfg.xlingsBinary.string());
     std::println("xlings home         = {}", cfg.xlingsHome().string());
+    std::println("xlings mirror       = {}",
+                 cfg.xlingsMirror.empty() ? "(xlings default)" : cfg.xlingsMirror);
     std::println("config              = {}", cfg.configFile.string());
     std::println("BMI cache           = {}", cfg.bmiCacheDir.string());
     std::println("meta cache          = {}", cfg.metaCacheDir.string());
diff --git a/src/pm/compat.cppm b/src/pm/compat.cppm
@@ -189,6 +189,12 @@ inline std::vector<std::string> install_dir_candidates(std::string_view ns,
     // Old index-prefixed layout: <index>-x-<ns>.<shortName>
     candidates.push_back(std::format("{}-x-{}", indexName, fqname));
 
+    // Fallback: compat.<shortName> packages serving default-namespace deps
+    // such as bare `gtest = "1.15.2"`.
+    if (ns.empty() || ns == mcpp::pm::kDefaultNamespace) {
+        candidates.push_back(std::format("compat-x-compat.{}", shortName));
+    }
+
     // Bare short name variants
     if (!ns.empty()) {
         candidates.push_back(std::format("{}-x-{}", ns, shortName));
diff --git a/src/toolchain/detect.cppm b/src/toolchain/detect.cppm
@@ -179,6 +179,39 @@ std::string lower_copy(std::string_view s) {
     return out;
 }
 
+std::string trim_line(std::string s) {
+    while (!s.empty() && (s.back() == '\n' || s.back() == '\r' || s.back() == ' '))
+        s.pop_back();
+    while (!s.empty() && (s.front() == '\n' || s.front() == '\r' || s.front() == ' '))
+        s.erase(s.begin());
+    return s;
+}
+
+std::optional<std::string>
+json_string_value_after(std::string_view body, std::size_t start, std::string_view key) {
+    auto keyToken = std::string{"\""} + std::string(key) + "\"";
+    auto keyPos = body.find(keyToken, start);
+    if (keyPos == std::string_view::npos) return std::nullopt;
+
+    auto colon = body.find(':', keyPos + keyToken.size());
+    if (colon == std::string_view::npos) return std::nullopt;
+
+    auto quote = body.find('"', colon + 1);
+    if (quote == std::string_view::npos) return std::nullopt;
+
+    std::string out;
+    for (std::size_t i = quote + 1; i < body.size(); ++i) {
+        char c = body[i];
+        if (c == '"') return out;
+        if (c == '\\' && i + 1 < body.size()) {
+            out.push_back(body[++i]);
+        } else {
+            out.push_back(c);
+        }
+    }
+    return std::nullopt;
+}
+
 } // namespace
 
 std::string compiler_env_prefix(const Toolchain& tc) {
@@ -212,6 +245,47 @@ std::optional<std::filesystem::path> find_std_module_source(
     return std::nullopt;
 }
 
+std::optional<std::filesystem::path> find_libcxx_std_module_source(
+    const std::filesystem::path& cxx_binary, const std::string& envPrefix) {
+    auto manifest_r = run_capture(std::format("{}{} -print-library-module-manifest-path 2>/dev/null",
+                                              envPrefix,
+                                              mcpp::xlings::shq(cxx_binary.string())));
+    if (manifest_r) {
+        auto manifestPath = std::filesystem::path(trim_line(*manifest_r));
+        if (!manifestPath.empty() && std::filesystem::exists(manifestPath)) {
+            std::ifstream is(manifestPath);
+            std::stringstream ss;
+            ss << is.rdbuf();
+            auto body = ss.str();
+
+            std::size_t cursor = 0;
+            while (true) {
+                auto logical = body.find("\"logical-name\"", cursor);
+                if (logical == std::string::npos) break;
+                auto name = json_string_value_after(body, logical, "logical-name");
+                if (name && *name == "std") {
+                    auto src = json_string_value_after(body, logical, "source-path");
+                    if (src) {
+                        std::filesystem::path p = *src;
+                        if (p.is_relative())
+                            p = manifestPath.parent_path() / p;
+                        std::error_code ec;
+                        auto canon = std::filesystem::weakly_canonical(p, ec);
+                        if (!ec) p = canon;
+                        if (std::filesystem::exists(p)) return p;
+                    }
+                }
+                cursor = logical + 1;
+            }
+        }
+    }
+
+    auto root = cxx_binary.parent_path().parent_path();
+    auto fallback = root / "share" / "libc++" / "v1" / "std.cppm";
+    if (std::filesystem::exists(fallback)) return fallback;
+    return std::nullopt;
+}
+
 std::expected<Toolchain, DetectError>
 detect(const std::filesystem::path& explicit_compiler) {
     Toolchain tc;
@@ -304,6 +378,10 @@ detect(const std::filesystem::path& explicit_compiler) {
         tc.stdlibId      = "libc++";
         tc.stdlibVersion = tc.version.empty() ? "unknown" : tc.version;
         tc.linkRuntimeDirs = discover_link_runtime_dirs(tc.binaryPath, tc.targetTriple);
+        if (auto p = find_libcxx_std_module_source(tc.binaryPath, envPrefix)) {
+            tc.stdModuleSource = *p;
+            tc.hasImportStd    = true;
+        }
     }
 
     // std module source
diff --git a/src/toolchain/stdmod.cppm b/src/toolchain/stdmod.cppm
diff --git a/src/xlings.cppm b/src/xlings.cppm
diff --git a/tests/e2e/37_llvm_import_std.sh b/tests/e2e/37_llvm_import_std.sh
