refactor(build): L4 — split prepare_inputs out of the 6521-line prepare.cppm

`prepare.cppm` 6521 行、编译 16.4s,是本仓库关键路径上唯一的真离群点。
抽出 `mcpp.build.prepare_inputs`(341 行):cfg() 谓词求值 + 指纹的两个规范化函数
—— 它们对 prepare 的其余部分零依赖,是这个文件里唯一自足的部分。
prepare 6521 → 6186 行;两个函数 **re-export**,所以没有任何调用方需要改
(一次拆分如果唯一可见的效果是别的文件编不过,那不叫改进)。

⚠️ **实测:构建时间没有变化**(off 79.23s / on 34.54s,与拆分前一致)。
这与拆分前的分析一致,值得写下来而不是含糊过去:

**抽出来的东西成了 prepare 的依赖,链只会变长不会变短。**
`… → prepare_inputs → prepare → …` 仍然串行,prepare 少掉的成本正好由新模块付掉。
要缩短关键路径,抽出的部分必须是 prepare 的**兄弟** —— 被 prepare 的**导入者**
直接使用。调查过:configure 只用 `BuildContext`,execute 用 `BuildContext` +
`prepare_build`,doctor/pack/cli.cmd_build 只用 `prepare_build`;
而链上是 prepare → execute → configure,execute 需要 `prepare_build`,
所以把类型抽走也不会让谁离开这条链。真正有效的是拆 `prepare_build` 本身。

L2 落地之后这件事的收益又小了一截:一个接口现在只阻塞导入者约 22% 的编译时间,
而不是全部。所以这次拆分按**架构**理由留下(6500 行的模块本就该拆),
不按性能理由 —— 性能上它是零。

Author: speak-agent

src/build/prepare.cppm

@@ -9,6 +9,12 @@ module;
 
 export module mcpp.build.prepare;
 
+// The cfg() predicate evaluator and the fingerprint canonicalisers moved out —
+// see mcpp.build.prepare_inputs. Re-exported so every existing caller of
+// `target_dir` / `canonical_compile_flags` keeps working: a split whose only
+// visible effect is that other files stop compiling is not an improvement.
+export import mcpp.build.prepare_inputs;
+
 import std;
 import mcpp.diag;
 import mcpp.home;
@@ -98,347 +104,6 @@ inline void warn_unknown_xpkg_keys(const mcpp::manifest::Manifest& dm,
     }
 }
 
-// ── L1 platform-conditional config: cfg() predicate evaluation ──────────────
-// Context = the RESOLVED target's coordinates. A `[target.'cfg(...)'.build]`
-// predicate is evaluated against this (target triple for a cross build, host
-// for a native build), so conditional flags follow what the binary will run on
-// — not the build host. See the manifest design doc.
-namespace cfgpred {
-
-struct Ctx { std::string os, arch, family, env; };
-
-// Derive the cfg context from the resolved --target triple, falling back to
-// the host for a native build. Parsing goes through triple.cppm — the single
-// triple parser — so the cfg vocabulary IS the canonical triple vocabulary
-// (os: linux|macos|windows, arch: GNU spellings, env: gnu|musl|msvc), and
-// alias spellings ("x86_64-w64-mingw32") evaluate identically to canonical.
-inline Ctx context_for(std::string_view targetTriple) {
-    namespace triple = mcpp::toolchain::triple;
-    Ctx c;
-    auto t = targetTriple.empty()
-        ? std::optional<triple::Triple>(triple::host_triple())
-        : triple::parse(targetTriple);
-    if (t) {
-        c.os     = t->os;
-        c.arch   = t->arch;
-        c.env    = t->env;
-        c.family = t->family();
-    } else {
-        // Escape-hatch triple outside the language: only the leading arch
-        // segment is derivable; other dimensions stay empty (never match).
-        auto dash = targetTriple.find('-');
-        c.arch = std::string(dash == std::string_view::npos ? targetTriple
-                                                            : targetTriple.substr(0, dash));
-    }
-    return c;
-}
-
-// Recursive-descent evaluator over the inside of `cfg(...)`:
-//   expr := all(list) | any(list) | not(expr) | key="value" | bareword
-//   key  ∈ {os, arch, family, env}   bareword ∈ {windows, unix, linux, macos}
-struct Parser {
-    std::string_view s; std::size_t i = 0; const Ctx& c;
-    void ws() { while (i < s.size() && std::isspace((unsigned char)s[i])) ++i; }
-    bool eat(char ch) { ws(); if (i < s.size() && s[i] == ch) { ++i; return true; } return false; }
-    std::string ident() {
-        ws(); std::size_t b = i;
-        while (i < s.size() && (std::isalnum((unsigned char)s[i]) || s[i] == '_')) ++i;
-        return std::string(s.substr(b, i - b));
-    }
-    std::string str() {
-        ws(); if (i >= s.size() || s[i] != '"') return {};
-        ++i; std::size_t b = i; while (i < s.size() && s[i] != '"') ++i;
-        auto v = std::string(s.substr(b, i - b)); if (i < s.size()) ++i; return v;
-    }
-    bool match_alias(const std::string& a) {
-        if (a == "windows") return c.os == "windows";
-        if (a == "linux")   return c.os == "linux";
-        if (a == "macos")   return c.os == "macos";
-        if (a == "unix")    return c.family == "unix";
-        return false;  // unknown bareword → no match
-    }
-    bool match_kv(const std::string& k, const std::string& v) {
-        if (k == "os")     return c.os == v;
-        if (k == "arch")   return c.arch == v;
-        if (k == "family") return c.family == v;
-        if (k == "env")    return c.env == v;
-        return false;
-    }
-    bool expr() {
-        std::string id = ident();
-        if (id == "all" || id == "any") {
-            eat('(');
-            bool acc = (id == "all");
-            ws();
-            if (!(i < s.size() && s[i] == ')')) {
-                do { bool r = expr(); acc = (id == "all") ? (acc && r) : (acc || r); }
-                while (eat(','));
-            }
-            eat(')');
-            return acc;
-        }
-        if (id == "not") { eat('('); bool r = expr(); eat(')'); return !r; }
-        ws();
-        if (i < s.size() && s[i] == '=') { ++i; return match_kv(id, str()); }
-        return match_alias(id);
-    }
-};
-
-// Evaluate a `[target.<predicate>]` key. Returns the cfg() result, or — for a
-// non-cfg key (a bare triple) — an exact match against the resolved triple.
-inline bool matches(const std::string& predicate, const Ctx& c, std::string_view triple) {
-    std::string_view k = predicate;
-    if (k.starts_with("cfg(") && k.ends_with(")")) {
-        Parser p{ k.substr(4, k.size() - 5), 0, c };
-        return p.expr();
-    }
-    // Bare OS/family alias sugar: `[target.linux]` ≡ `[target.'cfg(linux)']`.
-    // These aliases are never valid triples (no dash), so there is no ambiguity
-    // with the exact-triple namespace. Evaluated as the cfg bareword.
-    if (predicate == "windows" || predicate == "linux" ||
-        predicate == "macos"   || predicate == "unix") {
-        Parser p{ predicate, 0, c };
-        return p.expr();
-    }
-    // Bare-triple match, spelling-independent: a `[target.x86_64-w64-mingw32]`
-    // key matches a resolved `x86_64-windows-gnu` build (and vice versa) —
-    // both normalize through triple::parse. Unparseable keys (the explicit-
-    // section escape hatch) fall back to exact string comparison.
-    if (triple.empty()) return false;
-    if (auto p = mcpp::toolchain::triple::parse(predicate)) {
-        if (auto rt = mcpp::toolchain::triple::parse(triple))
-            return p->str() == rt->str();
-    }
-    return predicate == triple;
-}
-
-}  // namespace cfgpred
-
-export std::filesystem::path target_dir(const mcpp::toolchain::Toolchain& tc,
-                                 const mcpp::toolchain::Fingerprint& fp,
-                                 const std::filesystem::path& root)
-{
-    // Canonical triple names the output directory (D1: `target/
-    // x86_64-windows-gnu/`, not the GNU spelling the compiler reports via
-    // -dumpmachine) — alias inputs land in the same directory. Triples
-    // outside the language keep their raw spelling.
-    auto triple = tc.targetTriple.empty() ? std::string{"unknown"} : tc.targetTriple;
-    if (auto t = mcpp::toolchain::triple::parse(triple)) triple = t->str();
-    return root / "target" / triple / fp.hex;
-}
-
-
-// Compose a stable canonical compile-flags string for fingerprinting.
-// Exported so the "every build-variant knob is in here" invariant is machine-
-// checkable: the profile knobs were absent for a long time precisely because
-// nothing could assert on this string.
-export std::string canonical_compile_flags(const mcpp::manifest::Manifest& m) {
-    std::string s;
-    s += "-std="; s += m.package.standard;
-    s += " -fmodules";
-    // macOS deployment target changes the effective compile triple
-    // (arm64-apple-macosxNN) — a std.pcm built for one target cannot be
-    // loaded by a TU compiled for another. Fold the resolved value
-    // (env override > [build] macos_deployment_target manifest default)
-    // into the fingerprint so switching targets rebuilds the BMI cache
-    // instead of dying with a module config mismatch.
-    //
-    // The built-in default floor (rustc-style) lives in the single
-    // resolver (platform::macos::deployment_target), so this rule, the
-    // flags and the std-module prebuild always agree — the 0.0.50-era
-    // attempt to inject a default here alone left the test build's
-    // std.pcm unstaged (import std failed wholesale on macos CI).
-    if constexpr (mcpp::platform::is_macos) {
-        auto dtv = mcpp::platform::macos::deployment_target(
-            m.buildConfig.macosDeploymentTarget);
-        if (!dtv.empty()) {
-            s += " macos_deployment_target=";
-            s += dtv;
-        }
-    }
-    if (!m.buildConfig.cStandard.empty()) {
-        s += " c_standard=";
-        s += m.buildConfig.cStandard;
-    }
-    for (auto const& flag : m.buildConfig.cflags) {
-        s += " cflag:";
-        s += flag;
-    }
-    for (auto const& flag : m.buildConfig.cxxflags) {
-        s += " cxxflag:";
-        s += flag;
-    }
-    // Explicit [build] dialect_cxxflags (auto-promoted ones are already in
-    // cxxflags above) — they change every BMI in the graph.
-    for (auto const& flag : m.buildConfig.dialectCxxflags) {
-        s += " dialect:";
-        s += flag;
-    }
-    for (auto const& flag : m.buildConfig.ldflags) {
-        s += " ldflag:";
-        s += flag;
-    }
-    // Per-glob flags (G4): full ordered serialization — glob + every list —
-    // so editing any entry (or reordering) re-fingerprints the output dir.
-    for (auto const& gf : m.buildConfig.globFlags) {
-        s += " globflags:"; s += gf.glob;
-        for (auto const& f : gf.cflags)   { s += " gc:";  s += f; }
-        for (auto const& f : gf.cxxflags) { s += " gxx:"; s += f; }
-        for (auto const& f : gf.asmflags) { s += " gas:"; s += f; }
-        for (auto const& f : gf.defines)  { s += " gd:";  s += f; }
-    }
-    // [build] module_extensions changes WHICH FILES ARE MODULE INTERFACES,
-    // i.e. the shape of the graph: which units emit a BMI, which objects link
-    // unconditionally, which ninja rule each unit gets. That is a build
-    // variant, so it belongs in the fingerprint — mcpp.toml's mtime alone only
-    // protects the fast path within one output dir, not the BMI cache.
-    //
-    // Contrast [build] build_program_timeout, which is deliberately absent:
-    // it changes no edge. See BuildConfig::buildProgramTimeoutSecs.
-    for (auto const& e : m.buildConfig.moduleExtensions) {
-        s += " modext:";
-        s += e;
-    }
-    // The resolved [profile] knobs. These are NOT in cflags/cxxflags: the
-    // profile block (see the profile resolution below) lands them in
-    // buildConfig.optLevel/debug/lto/strip and flags.cppm turns them into
-    // -O<n>/-g/-flto at command-construction time. Leaving them out made
-    // `--dev`, `--release` and `--profile dist` share ONE fingerprint, hence
-    // one target/<triple>/<fp>/ directory AND one global cache entry — so a
-    // release build could be served -O0 -g dependency objects. They are
-    // build-variant by definition; they belong here.
-    s += " opt=";   s += m.buildConfig.optLevel;
-    s += " debug="; s += m.buildConfig.debug ? "1" : "0";
-    s += " lto=";   s += m.buildConfig.lto   ? "1" : "0";
-    s += " strip="; s += m.buildConfig.strip ? "1" : "0";
-    return s;
-}
-
-std::string canonical_package_build_metadata(
-    const std::vector<mcpp::modgraph::PackageRoot>& packages)
-{
-    std::string s;
-    for (auto const& pkg : packages) {
-        s += "\npackage:";
-        s += pkg.manifest.package.namespace_;
-        s += "/";
-        s += pkg.manifest.package.name;
-        s += "@";
-        s += pkg.manifest.package.version;
-        s += " source=";
-        s += pkg.manifest.package.sourceProvenance;
-        auto const& runtime = pkg.manifest.runtimeConfig;
-        for (auto const& requirement : runtime.requirements) {
-            s += " runtime-need:";
-            s += requirement.kind;
-            s += ':';
-            s += requirement.value;
-            s += ':';
-            s += requirement.phase;
-            s += requirement.required ? ":required" : ":optional";
-        }
-        for (auto const& artifact : runtime.artifacts) {
-            s += " runtime-artifact:";
-            s += artifact.role;
-            s += ':';
-            s += artifact.path.generic_string();
-            s += ':';
-            s += artifact.provenance;
-            s += ':';
-            s += artifact.abi;
-            s += ':';
-            s += artifact.digest;
-            s += ':';
-            s += artifact.hostFingerprint;
-        }
-        for (auto const& value : runtime.linkIntent.libraries)
-            s += " link-library:" + value;
-        for (auto const& value : runtime.linkIntent.linkLibraryDirs)
-            s += " link-dir:" + value.generic_string();
-        for (auto const& value : runtime.linkIntent.transitiveNeededDirs)
-            s += " needed-dir:" + value.generic_string();
-        for (auto const& value : runtime.linkIntent.runtimeSearchDirs)
-            s += " runtime-dir:" + value.generic_string();
-        for (auto const& value : runtime.linkIntent.frameworks)
-            s += " framework:" + value;
-        for (auto const& value : runtime.linkIntent.deployFiles)
-            s += " deploy:" + value.generic_string();
-        // Legacy fields remain fingerprinted while they are readable.
-        for (auto const& value : runtime.libraryDirs)
-            s += " legacy-runtime-dir:" + value.generic_string();
-        for (auto const& value : runtime.dlopenLibs)
-            s += " legacy-soname:" + value;
-        for (auto const& value : runtime.capabilities)
-            s += " legacy-capability:" + value;
-        for (auto const& value : runtime.provides)
-            s += " legacy-provides:" + value;
-        for (auto const& [capability, provider] : runtime.providerOverrides)
-            s += " provider-override:" + capability + '=' + provider;
-        if (!pkg.manifest.buildConfig.cStandard.empty()) {
-            s += " c_standard=";
-            s += pkg.manifest.buildConfig.cStandard;
-        }
-        for (auto const& flag : pkg.manifest.buildConfig.cflags) {
-            s += " cflag:";
-            s += flag;
-        }
-        for (auto const& flag : pkg.manifest.buildConfig.cxxflags) {
-            s += " cxxflag:";
-            s += flag;
-        }
-        for (auto const& flag : pkg.manifest.buildConfig.ldflags) {
-            s += " ldflag:";
-            s += flag;
-        }
-        // Per-glob flags — same full ordered serialization as the root-side
-        // block above. Until #253 dependency globFlags were unfingerprinted
-        // (held only by "descriptor frozen per version" + "feature toggles
-        // always change cflags via -DMCPP_FEATURE_*"); feature-folded entries
-        // make the vector build-variant, so fingerprint it directly.
-        // featureOrigin is diagnostic-only and deliberately NOT serialized
-        // (the active feature set is already in cflags above).
-        for (auto const& gf : pkg.manifest.buildConfig.globFlags) {
-            s += " globflags:"; s += gf.glob;
-            for (auto const& f : gf.cflags)   { s += " gc:";  s += f; }
-            for (auto const& f : gf.cxxflags) { s += " gxx:"; s += f; }
-            for (auto const& f : gf.asmflags) { s += " gas:"; s += f; }
-            for (auto const& f : gf.defines)  { s += " gd:";  s += f; }
-        }
-        // Same reason as the root block, and it cannot be skipped on the
-        // grounds that "a descriptor is frozen per version": path and git
-        // dependencies are not frozen, and this key changes their products.
-        for (auto const& e : pkg.manifest.buildConfig.moduleExtensions) {
-            s += " modext:";
-            s += e;
-        }
-        if (pkg.usageResolved) {
-            for (auto const& dir : pkg.privateBuild.includeDirs) {
-                s += " private_include:";
-                s += dir.generic_string();
-            }
-            for (auto const& dir : pkg.publicUsage.includeDirs) {
-                s += " public_include:";
-                s += dir.generic_string();
-            }
-            for (auto const& dir : pkg.privateBuild.includeDirsAfter) {
-                s += " private_include_after:";
-                s += dir.generic_string();
-            }
-            for (auto const& dir : pkg.publicUsage.includeDirsAfter) {
-                s += " public_include_after:";
-                s += dir.generic_string();
-            }
-        }
-        for (auto const& [path, content] : pkg.manifest.buildConfig.generatedFiles) {
-            s += " genfile:";
-            s += path.generic_string();
-            s += "=";
-            s += content;
-        }
-    }
-    return s;
-}
-
 std::expected<void, std::string>
 materialize_generated_files(const std::filesystem::path& root,
                             const mcpp::manifest::Manifest& manifest)