ninja_backend.cppm

// mcpp.build.ninja — Ninja-backed implementation of Backend.
//
// Layout produced under plan.outputDir = target/<triple>/<fp>/:
//   build.ninja
//   gcm.cache/std.gcm           (symlink/copy of plan.stdBmiPath)
//   gcm.cache/<module>.gcm      (created by GCC during compile)
//   obj/<unit>.o
//   obj/std.o                   (symlink/copy of plan.stdObjectPath)
//   bin/<target>
//
// All compile commands are run with cwd = plan.outputDir, so GCC's implicit
// gcm.cache/ lookup finds both std and our package modules.

module;
#include <cstdio>
#include <cstdlib>
#if defined(_WIN32)
#include <windows.h>
#define popen  _popen
#define pclose _pclose
#elif defined(__APPLE__)
#include <mach-o/dyld.h>  // _NSGetExecutablePath
#endif

export module mcpp.build.ninja;

import std;
import mcpp.build.backend;
import mcpp.build.plan;
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 {

class NinjaBackend final : public Backend {
public:
    std::string_view name() const override {
        return "ninja";
    }

    std::expected<BuildResult, BuildError> build(const BuildPlan& plan,
                                                 const BuildOptions& opts) override;
};

// Factory for this backend implementation.
std::unique_ptr<Backend> make_ninja_backend();

// Helper exposed for testing / debugging
std::string emit_ninja_string(const BuildPlan& plan);

}  // namespace mcpp::build

namespace mcpp::build {

namespace {

std::string escape_ninja_path(const std::filesystem::path& p) {
    // Ninja escapes: $ → $$, : → $:, space → $ (with leading space).
    // For simplicity we wrap in case-by-case.
    std::string s = p.string();
    std::string out;
    for (char c : s) {
        if (c == '$')
            out += "$$";
        else if (c == ':')
            out += "$:";
        else if (c == ' ')
            out += "$ ";
        else
            out.push_back(c);
    }
    return out;
}

std::string escape_ninja_variable_value(std::string_view s) {
    std::string out;
    out.reserve(s.size());
    for (char c : s) {
        if (c == '$') out += "$$";
        else          out.push_back(c);
    }
    return out;
}

void write_file(const std::filesystem::path& p, std::string_view content) {
    std::filesystem::create_directories(p.parent_path());
    std::ofstream os(p);
    os << content;
}

bool run(const std::string& cmd, std::string& output_capture, bool capture = true) {
    std::array<char, 8192> buf{};
    output_capture.clear();
    std::FILE* fp = ::popen(cmd.c_str(), "r");
    if (!fp)
        return false;
    while (std::fgets(buf.data(), buf.size(), fp) != nullptr) {
        if (capture)
            output_capture += buf.data();
        else
            std::fputs(buf.data(), stdout);
    }
    int rc = ::pclose(fp);
    return rc == 0;
}

bool dyndep_mode_enabled() {
    // M4 #7: dyndep is now the default. Set MCPP_NINJA_DYNDEP=0 to opt
    // OUT and fall back to the static-deps emission path.
    const char* v = std::getenv("MCPP_NINJA_DYNDEP");
    if (!v)
        return true;
    std::string_view sv(v);
    return !(sv == "0" || sv == "off" || sv == "false");
}

std::filesystem::path mcpp_exe_path() {
    std::error_code ec;
#if defined(_WIN32)
    char buf[MAX_PATH];
    DWORD len = GetModuleFileNameA(NULL, buf, MAX_PATH);
    if (len > 0 && len < MAX_PATH) {
        auto p = std::filesystem::canonical(buf, ec);
        if (!ec) return p;
    }
#elif defined(__APPLE__)
    char buf[4096];
    uint32_t size = sizeof(buf);
    if (_NSGetExecutablePath(buf, &size) == 0) {
        auto p = std::filesystem::canonical(buf, ec);
        if (!ec) return p;
    }
#else
    auto p = std::filesystem::read_symlink("/proc/self/exe", ec);
    if (!ec)
        return p;
#endif
    return "mcpp";  // fall back to PATH lookup
}

bool is_c_source(const std::filesystem::path& src) {
    return src.extension() == ".c";
}

}  // namespace

std::string emit_ninja_string(const BuildPlan& plan) {
    // dyndep requires P1689 scanning capability:
    //   GCC: built-in -fdeps-format=p1689r5
    //   Clang: external clang-scan-deps tool (same P1689 output format)
    bool has_scanner = mcpp::toolchain::is_gcc(plan.toolchain)
                    || !plan.scanDepsPath.empty();
    bool dyndep = dyndep_mode_enabled() && has_scanner;
    auto traits = mcpp::toolchain::bmi_traits(plan.toolchain);
    std::string out;
    auto append = [&](std::string s) { out += std::move(s); };

    append("# Auto-generated by mcpp v0.0.1. Do not edit by hand.\n");
    append("ninja_required_version = 1.11\n\n");

    // All compile/link flags are computed once via flags.cppm.
    auto flags = compute_flags(plan);

    bool need_c_rule = false;
    for (auto& cu : plan.compileUnits) {
        if (is_c_source(cu.source)) {
            need_c_rule = true;
            break;
        }
    }

    append(std::format("cxx       = {}\n", escape_ninja_path(flags.cxxBinary)));
    append(std::format("cxxflags  = {}\n", flags.cxx));
    append(std::format("toolenv   = {}\n", escape_ninja_variable_value(flags.toolEnv)));
    if (need_c_rule) {
        append(std::format("cc        = {}\n", escape_ninja_path(flags.ccBinary)));
        append(std::format("cflags    = {}\n", flags.cc));
    }
    append(std::format("ldflags   ={}\n", flags.ld));

    // `ar` for cxx_archive.
    if (!flags.arBinary.empty()) {
        append(std::format("ar        = {}\n", escape_ninja_path(flags.arBinary)));
    } else {
        append("ar        = ar\n");
    }
    if (dyndep) {
        append(std::format("mcpp      = {}\n", escape_ninja_path(mcpp_exe_path())));
        if (!plan.scanDepsPath.empty()) {
            append(std::format("scan_deps = {}\n", escape_ninja_path(plan.scanDepsPath)));
        }
    }
    append("\n");

    append("rule cp_bmi\n");
#if defined(_WIN32)
    // Use PowerShell Copy-Item which handles both forward and back slashes.
    // cmd.exe `copy` breaks on forward-slash paths from ninja.
    append("  command = powershell -NoProfile -Command \"Copy-Item -Force '$in' -Destination '$out'\"\n");
#else
    append("  command = mkdir -p $$(dirname $out) && cp -f $in $out\n");
#endif
    append("  description = STAGE $out\n\n");

    // P1: per-file dyndep rule. Converts one .ddi → .dd independently.
    append(std::format(
        "rule cxx_dyndep\n"
        "  command = $mcpp dyndep --single --bmi-dir {} --bmi-ext {} --output $out $in\n"
        "  description = DYNDEP $out\n"
        "  restat = 1\n\n",
        traits.bmiDir, traits.bmiExt));

    // P2: cxx_module preserves BMI timestamps when interface is unchanged.
    // GCC always updates the .gcm timestamp even if content is identical.
    // We backup the BMI before compilation, compile, then restore the old
    // file if content is byte-identical. Combined with restat = 1 in the
    // dyndep file, this prevents cascading rebuilds when only the module
    // implementation changed (not the interface).
    //
    // $bmi_out is set per build edge to the BMI path (gcm.cache/<module>.gcm).
    // If $bmi_out is empty (no module provided), we just compile normally.
    std::string module_output_flag = traits.needsExplicitModuleOutput
        ? " -fmodule-output=$bmi_out" : "";
    append("rule cxx_module\n");
#if defined(_WIN32)
    // Windows: skip BMI restat optimization (requires POSIX shell).
    // No $toolenv (empty on Windows; its leading space breaks CreateProcess).
    append(std::format("  command = "
           "$cxx $cxxflags{} -c $in -o $out\n", module_output_flag));
#else
    append(std::format("  command = "
           "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out\" ]; then "
             "cp -p \"$bmi_out\" \"$bmi_out.bak\"; "
           "fi && "
           "$toolenv $cxx $cxxflags{} -c $in -o $out && "
           "if [ -n \"$bmi_out\" ] && [ -f \"$bmi_out.bak\" ] && "
              "cmp -s \"$bmi_out\" \"$bmi_out.bak\"; then "
             "mv \"$bmi_out.bak\" \"$bmi_out\"; "
           "else "
             "rm -f \"$bmi_out.bak\"; "
           "fi\n", module_output_flag));
#endif
    append("  description = MOD $out\n");
    if (dyndep)
        append("  restat = 1\n");
    append("\n");

    append("rule cxx_object\n");
#if defined(_WIN32)
    append("  command = $cxx $cxxflags -c $in -o $out\n");
#else
    append("  command = $toolenv $cxx $cxxflags -c $in -o $out\n");
#endif
    append("  description = OBJ $out\n");
    if (dyndep)
        append("  restat = 1\n");
    append("\n");

    if (need_c_rule) {
        append("rule c_object\n");
#if defined(_WIN32)
        append("  command = $cc $cflags -c $in -o $out\n");
#else
        append("  command = $toolenv $cc $cflags -c $in -o $out\n");
#endif
        append("  description = CC $out\n");
        if (dyndep)
            append("  restat = 1\n");
        append("\n");
    }

#if defined(_WIN32)
    append("rule cxx_link\n");
    append("  command = $cxx $in -o $out $ldflags\n");
    append("  description = LINK $out\n\n");

    append("rule cxx_archive\n");
    append("  command = $ar rcs $out $in\n");
    append("  description = AR $out\n\n");

    append("rule cxx_shared\n");
    append("  command = $cxx -shared $in -o $out $ldflags\n");
    append("  description = SHARED $out\n\n");
#else
    append("rule cxx_link\n");
    append("  command = $toolenv $cxx $in -o $out $ldflags\n");
    append("  description = LINK $out\n\n");

    append("rule cxx_archive\n");
    append("  command = $toolenv $ar rcs $out $in\n");
    append("  description = AR $out\n\n");

    append("rule cxx_shared\n");
    append("  command = $toolenv $cxx -shared $in -o $out $ldflags\n");
    append("  description = SHARED $out\n\n");
#endif

    if (dyndep) {
        // Scan rule: produce P1689 .ddi for one TU.
        // GCC: built-in -fdeps-format=p1689r5 flags during preprocessing.
        // Clang: external clang-scan-deps tool with -format=p1689.
        append("rule cxx_scan\n");
        if (plan.scanDepsPath.empty()) {
            // GCC path: compiler-integrated P1689 scanning.
#if defined(_WIN32)
            append("  command = $cxx $cxxflags -fmodules "
#else
            append("  command = $toolenv $cxx $cxxflags -fmodules "
#endif
                   "-fdeps-format=p1689r5 "
                   "-fdeps-file=$out -fdeps-target=$compile_target "
                   "-M -MM -MF $out.dep -E $in -o $compile_target\n");
        } else {
            // Clang path: clang-scan-deps produces P1689 JSON to stdout.
#if defined(_WIN32)
            // Wrap in cmd /c for shell redirection (ninja on Windows uses
            // CreateProcess which doesn't interpret > as redirect).
            append("  command = cmd /c \"$scan_deps -format=p1689 -- "
                   "$cxx $cxxflags -c $in -o $compile_target > $out\"\n");
#else
            append("  command = $toolenv $scan_deps -format=p1689 -- "
                   "$cxx $cxxflags -c $in -o $compile_target > $out\n");
#endif
        }
        append("  description = SCAN $out\n\n");

        // Aggregate .ddi files into a Ninja dyndep file.
        append(std::format(
            "rule cxx_collect\n"
            "  command = $mcpp dyndep --bmi-dir {} --bmi-ext {} --output $out $in\n"
            "  description = COLLECT $out\n"
            "  restat = 1\n\n",
            traits.bmiDir, traits.bmiExt));
    }

    // Stage prebuilt std artifacts into the compiler-specific BMI cache.
    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();
    if (has_std_artifacts) {
        append(std::format("build {} : cp_bmi {}\n", escape_ninja_path(std_bmi_dst),
                           escape_ninja_path(plan.stdBmiPath)));
        append(std::format("build {} : cp_bmi {}\n\n", escape_ninja_path(std_o_dst),
                           escape_ninja_path(plan.stdObjectPath)));
    }

    bool has_std_compat = !plan.stdCompatBmiPath.empty() && !plan.stdCompatObjectPath.empty();
    auto compat_bmi_dst = std::filesystem::path("pcm.cache") / "std.compat.pcm";
    auto compat_o_dst = std::filesystem::path("obj") / "std.compat.o";
    if (has_std_compat) {
        // std.compat.pcm depends on std.pcm — ensure std.pcm is staged first
        // so clang can resolve the transitive dependency when loading std.compat.pcm.
        append(std::format("build {} : cp_bmi {} | {}\n", escape_ninja_path(compat_bmi_dst),
                           escape_ninja_path(plan.stdCompatBmiPath),
                           escape_ninja_path(std_bmi_dst)));
        append(std::format("build {} : cp_bmi {}\n\n", escape_ninja_path(compat_o_dst),
                           escape_ninja_path(plan.stdCompatObjectPath)));
    }

    auto bmi_path = [&traits](std::string_view name) {
        std::string s(traits.bmiDir);
        s += '/';
        for (char c : name)
            s.push_back(c == ':' ? '-' : c);
        s += traits.bmiExt;
        return s;
    };

    auto pick_rule = [](const std::filesystem::path& src) -> std::string {
        auto ext = src.extension();
        if (ext == ".cppm")
            return "cxx_module";
        if (ext == ".c")
            return "c_object";
        return "cxx_object";
    };

    if (dyndep) {
        // ── Phase 1: scan edges (one .ddi per TU). ──────────────────────
        // .ddi is placed beside the object so multi-version mangling can
        // namespace by package without producing two `build` rules with
        // the same `.ddi` output (plan.cppm switches `cu.object` from
        // `obj/<file>.o` to `obj/<pkg>/<file>.o` whenever a basename
        // collides across packages — `.ddi` follows that placement).
        // Skip .c files: they have no `import`s and don't need P1689 scan;
        // running them through cxx_scan would route them through g++ /
        // -fmodules which is exactly what C support is here to avoid.
        std::vector<std::string> ddi_paths;
        ddi_paths.reserve(plan.compileUnits.size());
        for (auto& cu : plan.compileUnits) {
            if (is_c_source(cu.source))
                continue;
            auto ddi = (cu.object.parent_path() / cu.source.filename()).string() + ".ddi";
            ddi_paths.push_back(ddi);
            append(std::format("build {} : cxx_scan {}\n", escape_ninja_path(ddi),
                               escape_ninja_path(cu.source)));
            append(std::format("  compile_target = {}\n", escape_ninja_path(cu.object)));
        }
        append("\n");

        // ── Phase 2: per-file dyndep (P1 optimization). ────────────────
        // Each .ddi → .dd independently, so modifying one source file only
        // invalidates that file's .dd and its compile edge, not all edges.
        // Map ddi path → dd path for Phase 3 reference.
        std::map<std::string, std::string> ddi_to_dd;
        for (auto& ddi : ddi_paths) {
            auto dd = ddi + ".dd";   // e.g. obj/cli.cppm.ddi.dd
            ddi_to_dd[ddi] = dd;
            append(std::format("build {} : cxx_dyndep {}\n", dd, ddi));
        }
        append("\n");

        // ── Phase 3: compile edges with per-file dyndep. ────────────────
        // Each compile edge references its OWN .dd file instead of a global one.
        // P2: module compile edges get a $bmi_out variable for BMI preservation.
        for (auto& cu : plan.compileUnits) {
            std::string rule = pick_rule(cu.source);

            std::string out_line = "build " + escape_ninja_path(cu.object);
            if (cu.providesModule) {
                out_line += " | " + bmi_path(*cu.providesModule);
            }
            out_line += std::format(" : {} {}", rule, escape_ninja_path(cu.source));
            if (rule != "c_object") {
                auto ddi = (cu.object.parent_path() / cu.source.filename()).string() + ".ddi";
                auto it = ddi_to_dd.find(ddi);
                if (it != ddi_to_dd.end()) {
                    out_line += " | " + it->second;
                    out_line += "\n  dyndep = " + it->second;
                    // P2: set bmi_out for the copy_if_different logic in cxx_module.
                    if (cu.providesModule) {
                        out_line += "\n  bmi_out = " + bmi_path(*cu.providesModule);
                    }
                    out_line += "\n";
                } else {
                    out_line += "\n";
                }
            } else {
                out_line += "\n";
            }
            append(std::move(out_line));
        }
        append("\n");
    } else {
        // ── Static-deps mode (M3.2 and earlier). ────────────────────────
        for (auto& cu : plan.compileUnits) {
            std::string rule = pick_rule(cu.source);

            std::string implicit;
            // .c files don't `import` modules; skip BMI implicit inputs.
            if (rule != "c_object") {
                for (auto& imp : cu.imports) {
                    if (imp == "std") {
                        if (has_std_artifacts)
                            implicit += " " + escape_ninja_path(std_bmi_dst);
                        continue;
                    }
                    if (imp == "std.compat") {
                        if (has_std_compat)
                            implicit += " " + escape_ninja_path(compat_bmi_dst);
                        else if (has_std_artifacts)
                            implicit += " " + escape_ninja_path(std_bmi_dst);
                        continue;
                    }
                    implicit += " " + bmi_path(imp);
                }
            }

            std::string out_line = "build " + escape_ninja_path(cu.object);
            if (cu.providesModule) {
                // Use implicit output (|) so $out only contains the .o file.
                // GCC writes BMI implicitly; Clang uses -fmodule-output=$bmi_out.
                out_line += " | " + bmi_path(*cu.providesModule);
            }
            out_line += std::format(" : {} {}", rule, escape_ninja_path(cu.source));
            if (!implicit.empty())
                out_line += " |" + implicit;
            out_line += "\n";
            // Clang needs $bmi_out to emit -fmodule-output=$bmi_out
            if (cu.providesModule) {
                out_line += "  bmi_out = " + bmi_path(*cu.providesModule) + "\n";
            }
            append(std::move(out_line));
        }
        append("\n");
    }

    // Link units
    for (auto& lu : plan.linkUnits) {
        std::string ins;
        for (auto& o : lu.objects) {
            ins += " " + escape_ninja_path(o);
        }

        std::string rule;
        switch (lu.kind) {
            case LinkUnit::Binary:
            case LinkUnit::TestBinary:
                if (has_std_artifacts)
                    ins += " " + escape_ninja_path(std_o_dst);
                if (has_std_compat)
                    ins += " " + escape_ninja_path(compat_o_dst);
                rule = "cxx_link";
                break;
            case LinkUnit::StaticLibrary:
                rule = "cxx_archive";
                break;
            case LinkUnit::SharedLibrary:
                if (has_std_artifacts)
                    ins += " " + escape_ninja_path(std_o_dst);
                if (has_std_compat)
                    ins += " " + escape_ninja_path(compat_o_dst);
                rule = "cxx_shared";
                break;
        }
        append(std::format("build {} : {}{}\n", escape_ninja_path(lu.output), rule, ins));
    }
    append("\n");

    if (!plan.linkUnits.empty()) {
        std::string defaults;
        for (auto& lu : plan.linkUnits) {
            defaults += " " + escape_ninja_path(lu.output);
        }
        append("default" + defaults + "\n");
    }

    return out;
}

std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan,
                                                           const BuildOptions& opts) {
    auto t0 = std::chrono::steady_clock::now();

    std::error_code ec;
    std::filesystem::create_directories(plan.outputDir, ec);
    if (ec)
        return std::unexpected(BuildError{std::format("cannot create output dir '{}': {}",
                                                      plan.outputDir.string(), ec.message()),
                                          plan.outputDir});

    auto ninja_path = plan.outputDir / "build.ninja";
    write_file(ninja_path, emit_ninja_string(plan));

    // compile_commands.json — via the dedicated module.
    auto flags = compute_flags(plan);
    write_compile_commands(plan, flags);

    if (opts.dryRun) {
        BuildResult r;
        r.exitCode = 0;
        r.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::steady_clock::now() - t0);
        return r;
    }

    // When the toolchain comes from mcpp's private sandbox, use the
    // sandbox-local ninja absolute path (skip the system xlings ninja
    // shim which requires per-tool version pin activation).
    //
    // The compiler's internal `as`/`ld` lookup is handled via the
    // -B<binutils-bin> flag we emit into cxxflags/ldflags (see
    // emit_ninja_string). No PATH injection needed here.
    std::filesystem::path ninjaBin;
#if defined(_WIN32)
    if (auto nb = mcpp::xlings::paths::find_sibling_binary(
            plan.toolchain.binaryPath, "ninja", "ninja.exe")) {
        ninjaBin = *nb;
    }
#else
    if (auto nb = mcpp::xlings::paths::find_sibling_binary(
            plan.toolchain.binaryPath, "ninja", "ninja")) {
        ninjaBin = *nb;
    }
#endif

#if defined(_WIN32)
    // Windows: no quotes on first token (cmd.exe strips leading quotes),
    // use shq only for the -C argument which may contain spaces.
    std::string ninjaProgram =
        !ninjaBin.empty() ? ninjaBin.string() : std::string{"ninja"};
#else
    std::string ninjaProgram =
        !ninjaBin.empty() ? mcpp::xlings::shq(ninjaBin.string()) : std::string{"ninja"};
#endif

    // Record ninja binary for P0 fast-path cache.
    BuildResult r;
    r.ninjaProgram = ninjaProgram;

    std::string cmd = std::format("{} -C {}", ninjaProgram, mcpp::xlings::shq(plan.outputDir.string()));
    if (opts.verbose)
        cmd += " -v";
    if (opts.parallelJobs)
        cmd += std::format(" -j{}", opts.parallelJobs);
    cmd += " 2>&1";

    std::string out;
    bool ok = run(cmd, out, /*capture=*/true);
    if (opts.verbose || !ok) {
        std::fputs(out.c_str(), stdout);
    }

    r.exitCode = ok ? 0 : 1;
    r.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::steady_clock::now() - t0);

    if (ok) {
        for (auto& lu : plan.linkUnits) {
            r.producedArtifacts.push_back(plan.outputDir / lu.output);
        }
    } else {
        return std::unexpected(BuildError{std::format("ninja failed (exit non-zero):\n{}", out),
                                          plan.outputDir / "build.ninja"});
    }
    return r;
}

std::unique_ptr<Backend> make_ninja_backend() {
    return std::make_unique<NinjaBackend>();
}

}  // namespace mcpp::build