feat: enable dyndep for Clang via clang-scan-deps

Clang lacks GCC's -fdeps-format=p1689r5 compiler flag but ships
clang-scan-deps which produces identical P1689 JSON output per-file.

Changes:
  - plan.cppm: add scanDepsPath field to BuildPlan
  - clang.cppm: add find_scan_deps() helper
  - cli.cppm: discover clang-scan-deps in compiler's bin/ directory
  - ninja_backend.cppm: enable dyndep when scanDepsPath is available,
    emit Clang-specific cxx_scan rule using clang-scan-deps with
    -format=p1689 and stdout redirection to .ddi file

This gives Clang the same per-file incremental rebuild capability
that GCC has had via the dyndep pipeline.

Author: Sunrisepeak

src/build/ninja_backend.cppm

@@ -126,11 +126,12 @@ bool is_c_source(const std::filesystem::path& src) {
 }  // namespace
 
 std::string emit_ninja_string(const BuildPlan& plan) {
-    // Clang uses clang-scan-deps (not -fdeps-format=p1689r5) for P1689
-    // scanning, so dyndep is GCC-only for now. Clang falls through to the
-    // static-deps path which uses BmiTraits for correct pcm.cache/ paths.
-    bool dyndep = dyndep_mode_enabled()
-               && mcpp::toolchain::is_gcc(plan.toolchain);
+    // 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); };
@@ -166,6 +167,9 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     }
     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");
 
@@ -239,12 +243,22 @@ std::string emit_ninja_string(const BuildPlan& plan) {
 
     if (dyndep) {
         // Scan rule: produce P1689 .ddi for one TU.
-        // -E -M -MM -MF gives us the dep file; -fdeps-* gives us the .ddi.
-        std::string scan_modules_flag = traits.scanNeedsFModules ? "-fmodules " : "";
+        // GCC: built-in -fdeps-format=p1689r5 flags during preprocessing.
+        // Clang: external clang-scan-deps tool with -format=p1689.
         append("rule cxx_scan\n");
-        append(std::format("  command = $toolenv $cxx $cxxflags {}-fdeps-format=p1689r5 "
-               "-fdeps-file=$out -fdeps-target=$compile_target "
-               "-M -MM -MF $out.dep -E $in -o $compile_target\n", scan_modules_flag));
+        if (plan.scanDepsPath.empty()) {
+            // GCC path: compiler-integrated P1689 scanning.
+            append("  command = $toolenv $cxx $cxxflags -fmodules "
+                   "-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,
+            // then we redirect to $out. The -- separator passes the full
+            // compile command so clang-scan-deps knows the flags/sysroot.
+            append("  command = $toolenv $scan_deps -format=p1689 -- "
+                   "$cxx $cxxflags -c $in -o $compile_target > $out\n");
+        }
         append("  description = SCAN $out\n\n");
 
         // Aggregate .ddi files into a Ninja dyndep file.

src/build/plan.cppm

@@ -37,6 +37,7 @@ struct BuildPlan {
     std::filesystem::path           outputDir;        // target/<triple>/<fp>/
     std::filesystem::path           stdBmiPath;      // absolute path to prebuilt std.gcm
     std::filesystem::path           stdObjectPath;   // absolute path to prebuilt std.o
+    std::filesystem::path           scanDepsPath;    // clang-scan-deps binary (Clang only)
 
     std::vector<CompileUnit>        compileUnits;     // topologically sorted
     std::vector<LinkUnit>           linkUnits;

src/cli.cppm

@@ -1991,6 +1991,14 @@ prepare_build(bool print_fingerprint,
     ctx.plan        = mcpp::build::make_plan(*m, *tc, fp, scan.graph, report.topoOrder,
                                              *root, ctx.outputDir, stdBmiPath, stdObjectPath);
 
+    // Clang: discover clang-scan-deps for P1689 dyndep scanning.
+    if (mcpp::toolchain::is_clang(*tc)) {
+        auto sd = tc->binaryPath.parent_path() / "clang-scan-deps";
+        if (std::filesystem::exists(sd)) {
+            ctx.plan.scanDepsPath = sd;
+        }
+    }
+
     // ─── M3.2: BMI cache stage / populate-task collection ─────────────
     // For each version-based dep package (i.e. fetched from a registry,
     // not a path dep), check the global BMI cache. If cached → stage into

src/toolchain/clang.cppm

@@ -28,6 +28,9 @@ std::vector<std::string> std_module_build_commands(const Toolchain& tc,
 
 std::filesystem::path archive_tool(const Toolchain& tc);
 
+// Locate clang-scan-deps in the same bin/ directory as clang++.
+std::optional<std::filesystem::path> find_scan_deps(const Toolchain& tc);
+
 } // namespace mcpp::toolchain::clang
 
 namespace mcpp::toolchain::clang {
@@ -164,4 +167,10 @@ std::filesystem::path archive_tool(const Toolchain& tc) {
     return {};
 }
 
+std::optional<std::filesystem::path> find_scan_deps(const Toolchain& tc) {
+    auto p = tc.binaryPath.parent_path() / "clang-scan-deps";
+    if (std::filesystem::exists(p)) return p;
+    return std::nullopt;
+}
+
 } // namespace mcpp::toolchain::clang