fix(build): support xlings mcpp build dependencies

Sunrisepeak · Sunrisepeak · commit 9e8ed16e44ae · 2026-05-30T06:52:47.000+08:00
diff --git a/src/build/compile_commands.cppm b/src/build/compile_commands.cppm
@@ -81,6 +81,15 @@ std::vector<std::string> split_flags(std::string_view s) {
     return out;
 }
 
+std::vector<std::string> local_include_args(const CompileUnit& cu) {
+    std::vector<std::string> args;
+    args.reserve(cu.localIncludeDirs.size());
+    for (auto const& inc : cu.localIncludeDirs) {
+        args.push_back("-I" + inc.string());
+    }
+    return args;
+}
+
 }  // namespace
 
 std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& flags) {
@@ -96,6 +105,8 @@ std::string emit_compile_commands(const BuildPlan& plan, const CompileFlags& fla
         // Build arguments array.
         nlohmann::json args = nlohmann::json::array();
         args.push_back(compiler.string());
+        for (auto& f : local_include_args(cu))
+            args.push_back(std::move(f));
         for (auto& f : split_flags(flagStr))
             args.push_back(std::move(f));
         args.push_back("-c");
diff --git a/src/build/ninja_backend.cppm b/src/build/ninja_backend.cppm
@@ -72,6 +72,27 @@ std::string escape_ninja_path(const std::filesystem::path& p) {
     return out;
 }
 
+std::string escape_flag_path(const std::filesystem::path& p) {
+    auto s = p.string();
+    std::string out;
+    out.reserve(s.size());
+    for (char c : s) {
+        if (c == ' ' || c == '$' || c == ':')
+            out.push_back('$');
+        out.push_back(c);
+    }
+    return out;
+}
+
+std::string local_include_flags(const CompileUnit& cu) {
+    std::string flags;
+    for (auto const& inc : cu.localIncludeDirs) {
+        flags += " -I";
+        flags += escape_flag_path(inc);
+    }
+    return flags;
+}
+
 void write_file(const std::filesystem::path& p, std::string_view content) {
     std::filesystem::create_directories(p.parent_path());
     std::ofstream os(p);
@@ -294,13 +315,13 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     if constexpr (mcpp::platform::is_windows) {
         // Windows: skip BMI restat optimization (requires POSIX shell).
         append(std::format("  command = "
-               "$cxx $cxxflags{} -c $in -o $out\n", module_output_flag));
+               "$cxx $local_includes $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 && "
-               "$cxx $cxxflags{} -c $in -o $out && "
+               "$cxx $local_includes $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\"; "
@@ -314,15 +335,15 @@ std::string emit_ninja_string(const BuildPlan& plan) {
     append("\n");
 
     append("rule cxx_object\n");
-    append("  command = $cxx $cxxflags -c $in -o $out\n");
+    append("  command = $cxx $local_includes $cxxflags -c $in -o $out\n");
     append("  description = OBJ $out\n");
     if (dyndep)
         append("  restat = 1\n");
     append("\n");
 
     if (need_c_rule) {
         append("rule c_object\n");
-        append("  command = $cc $cflags -c $in -o $out\n");
+        append("  command = $cc $local_includes $cflags -c $in -o $out\n");
         append("  description = CC $out\n");
         if (dyndep)
             append("  restat = 1\n");
@@ -348,7 +369,7 @@ std::string emit_ninja_string(const BuildPlan& plan) {
         append("rule cxx_scan\n");
         if (plan.scanDepsPath.empty()) {
             // GCC path: compiler-integrated P1689 scanning.
-            append("  command = $cxx $cxxflags -fmodules "
+            append("  command = $cxx $local_includes $cxxflags -fmodules "
                    "-fdeps-format=p1689r5 "
                    "-fdeps-file=$out -fdeps-target=$compile_target "
                    "-M -MM -MF $out.dep -E $in -o $compile_target\n");
@@ -358,10 +379,10 @@ std::string emit_ninja_string(const BuildPlan& plan) {
                 // 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");
+                       "$cxx $local_includes $cxxflags -c $in -o $compile_target > $out\"\n");
             } else {
                 append("  command = $scan_deps -format=p1689 -- "
-                       "$cxx $cxxflags -c $in -o $compile_target > $out\n");
+                       "$cxx $local_includes $cxxflags -c $in -o $compile_target > $out\n");
             }
         }
         append("  description = SCAN $out\n\n");
@@ -438,6 +459,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             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)));
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                append(std::format("  local_includes ={}\n", includes));
         }
         append("\n");
 
@@ -481,6 +504,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             } else {
                 out_line += "\n";
             }
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                out_line += "  local_includes =" + includes + "\n";
             append(std::move(out_line));
         }
         append("\n");
@@ -519,6 +544,8 @@ std::string emit_ninja_string(const BuildPlan& plan) {
             if (!implicit.empty())
                 out_line += " |" + implicit;
             out_line += "\n";
+            if (auto includes = local_include_flags(cu); !includes.empty())
+                out_line += "  local_includes =" + includes + "\n";
             // Clang needs $bmi_out to emit -fmodule-output=$bmi_out
             if (cu.providesModule) {
                 out_line += "  bmi_out = " + bmi_path(*cu.providesModule) + "\n";
diff --git a/src/build/plan.cppm b/src/build/plan.cppm
@@ -17,6 +17,7 @@ export namespace mcpp::build {
 struct CompileUnit {
     std::filesystem::path           source;
     std::filesystem::path           object;            // relative to plan.outputDir
+    std::vector<std::filesystem::path> localIncludeDirs;
     std::optional<std::string>      providesModule;   // logical name, if .cppm export
     std::vector<std::string>        imports;           // logical names imported
 };
@@ -119,6 +120,7 @@ BuildPlan make_plan(const mcpp::manifest::Manifest&         manifest,
         auto& u = graph.units[idx];
         CompileUnit cu;
         cu.source = u.path;
+        cu.localIncludeDirs = u.localIncludeDirs;
         const auto fname = object_filename_for(u.path);
         if (basenameCount[fname] > 1) {
             // Use <sanitized-pkg>/<parent-dir-name> as prefix to handle
diff --git a/src/cli.cppm b/src/cli.cppm
@@ -1375,19 +1375,19 @@ prepare_build(bool print_fingerprint,
         if (cfg2) {
             mcpp::config::ensure_project_index_dir(**cfg2, *root, m->indices);
 
-            // Gap 1: On first build, .mcpp/data/ may be empty because
+            // On first build, .mcpp/data/ may be empty because
             // ensure_project_index_dir only writes .xlings.json but doesn't
-            // trigger the actual clone. Check if there are any non-local,
-            // non-builtin indices and whether .mcpp/data/ exists with content.
-            // If not, run xlings update to clone them before dependency resolution.
-            bool hasCustomGitIndices = false;
+            // trigger clone/link creation. Check whether there are any custom
+            // non-builtin indices and whether .mcpp/data/ has index content.
+            // If not, run xlings update before dependency resolution.
+            bool hasCustomIndices = false;
             for (auto& [idxName, spec] : m->indices) {
-                if (!spec.is_local() && !spec.is_builtin()) {
-                    hasCustomGitIndices = true;
+                if (!spec.is_builtin()) {
+                    hasCustomIndices = true;
                     break;
                 }
             }
-            if (hasCustomGitIndices) {
+            if (hasCustomIndices) {
                 auto dataDir = *root / ".mcpp" / "data";
                 bool needsClone = !std::filesystem::exists(dataDir);
                 if (!needsClone) {
@@ -1521,9 +1521,11 @@ prepare_build(bool print_fingerprint,
             // lua found — fall through to normal install path resolution.
         }
 
-        // For custom git indices, try project-level .mcpp/data/ first.
+        const bool useProjectEnv = idxSpec && !idxSpec->is_builtin();
+
+        // For custom indices, try project-level .mcpp/data/ first.
         std::optional<std::filesystem::path> installed;
-        if (idxSpec && !idxSpec->is_local() && !idxSpec->is_builtin()) {
+        if (useProjectEnv) {
             installed = mcpp::fetcher::Fetcher::install_path_from_project_data(
                 *root, ns, shortName, version);
         }
@@ -1539,11 +1541,6 @@ prepare_build(bool print_fingerprint,
                 : std::format("{}.{}", ns, shortName);
             mcpp::ui::info("Downloading", std::format("{} v{}", fqname, version));
 
-            // Gap 2: For custom git indices, install using the project-level
-            // xlings env so packages land in .mcpp/data/xpkgs/ and the custom
-            // index clone is visible to xlings during resolution.
-            bool useProjectEnv = idxSpec && !idxSpec->is_local() && !idxSpec->is_builtin();
-
             auto install_one = [&](std::string target) -> std::expected<mcpp::xlings::CallResult, mcpp::pm::CallError> {
                 if (useProjectEnv) {
                     auto projEnv = mcpp::config::make_project_xlings_env(**cfg, *root);
@@ -1559,7 +1556,7 @@ prepare_build(bool print_fingerprint,
                 return fetcher.install(targets, &progress);
             };
             auto target = std::format("{}@{}", fqname, version);
-            // For custom git indices, use indexName:shortName@version format
+            // For custom indices, use indexName:shortName@version format
             // so xlings knows which index to resolve from.
             if (useProjectEnv) {
                 target = std::format("{}:{}@{}", ns, shortName, version);
@@ -1800,6 +1797,9 @@ prepare_build(bool print_fingerprint,
         const auto& name = item.name;
         auto& spec = item.spec;
 
+        mcpp::pm::compat::normalize_nested_namespace(
+            spec.namespace_, spec.shortName);
+
         // Pin SemVer constraint before dedup/fetch.
         if (auto r = resolveSemver(spec, name); !r) {
             return std::unexpected(r.error());
diff --git a/src/config.cppm b/src/config.cppm
@@ -613,11 +613,18 @@ bool ensure_project_index_dir(
     const std::filesystem::path& projectDir,
     const std::map<std::string, mcpp::pm::IndexSpec>& indices)
 {
-    // Collect custom (non-builtin, non-local) indices that need xlings cloning.
+    // Collect custom non-builtin indices that need xlings project-scope data.
+    // Local path indices are also seeded so xlings can create its own
+    // project-local repo link and install packages from that index.
     std::vector<std::pair<std::string,std::string>> customRepos;
     for (auto& [name, spec] : indices) {
         if (spec.is_builtin()) continue;
-        if (spec.is_local())   continue;   // local path, mcpp reads directly
+        if (spec.is_local()) {
+            auto source = spec.path;
+            if (source.is_relative()) source = projectDir / source;
+            customRepos.emplace_back(name, source.lexically_normal().string());
+            continue;
+        }
         customRepos.emplace_back(name, spec.url);
     }
 
diff --git a/src/libs/toml.cppm b/src/libs/toml.cppm
@@ -224,7 +224,12 @@ inline std::expected<Value, ParseError> read_array(Lexer& L) {
         if (!v) return std::unexpected(v.error());
         out.push_back(std::move(*v));
         L.skip_whitespace_and_comments();
-        if (L.peek() == ',') { L.advance(); continue; }
+        if (L.peek() == ',') {
+            L.advance();
+            L.skip_whitespace_and_comments();
+            if (L.peek() == ']') { L.advance(); break; }
+            continue;
+        }
         if (L.peek() == ']') { L.advance(); break; }
         return std::unexpected(ParseError{"expected ',' or ']' in array", L.position()});
     }
diff --git a/src/modgraph/graph.cppm b/src/modgraph/graph.cppm
@@ -15,6 +15,7 @@ struct ModuleId {
 struct SourceUnit {
     std::filesystem::path           path;
     std::string                     packageName;
+    std::vector<std::filesystem::path> localIncludeDirs;
     std::optional<ModuleId>         provides;
     std::vector<ModuleId>           requires_;
     bool                            isModuleInterface = false;   // .cppm with export module
diff --git a/src/modgraph/scanner.cppm b/src/modgraph/scanner.cppm
@@ -314,6 +314,23 @@ std::expected<SourceUnit, ScanError> scan_file(const std::filesystem::path& file
 
 namespace {
 
+std::vector<std::filesystem::path>
+local_include_dirs_for(const std::filesystem::path& root,
+                       const mcpp::manifest::Manifest& manifest)
+{
+    std::vector<std::filesystem::path> dirs;
+    for (auto const& inc : manifest.buildConfig.includeDirs) {
+        if (inc.is_absolute()) {
+            dirs.push_back(inc);
+            continue;
+        }
+        for (auto& d : expand_dir_glob(root, inc.generic_string())) {
+            dirs.push_back(std::move(d));
+        }
+    }
+    return dirs;
+}
+
 // Phase 1: scan a single package, append units to result.graph.units;
 // errors go straight into result.errors. producerOf/edges are NOT built
 // here — the caller does that after all packages are scanned.
@@ -348,13 +365,15 @@ void scan_one_into(ScanResult& result,
         manifest.package.namespace_.empty()
             ? manifest.package.name
             : manifest.package.namespace_ + "." + manifest.package.name;
+    const auto localIncludeDirs = local_include_dirs_for(root, manifest);
 
     for (auto const& f : all_files) {
         auto r = scan_file(f, qualifiedName);
         if (!r) {
             result.errors.push_back(r.error());
             continue;
         }
+        r->localIncludeDirs = localIncludeDirs;
         result.graph.units.push_back(std::move(*r));
     }
 }
@@ -422,13 +441,15 @@ ScanResult scan_packages_p1689(const std::vector<PackageRoot>&     packages,
         for (auto const& g : p.manifest.modules.sources) {
             for (auto& f : expand_glob(p.root, g)) all_files.insert(f);
         }
+        const auto localIncludeDirs = local_include_dirs_for(p.root, p.manifest);
         for (auto const& f : all_files) {
             auto r = mcpp::modgraph::p1689::scan_file(
                 f, p.manifest.package.name, tc, tmpDir);
             if (!r) {
                 result.errors.push_back(ScanError{ f, 0, r.error() });
                 continue;
             }
+            r->localIncludeDirs = localIncludeDirs;
             result.graph.units.push_back(std::move(*r));
         }
     }
diff --git a/src/pm/compat.cppm b/src/pm/compat.cppm
@@ -82,6 +82,22 @@ inline std::string qualified_name(std::string_view ns,
     return std::format("{}.{}", ns, shortName);
 }
 
+// Normalize legacy nested names after the first-dot split:
+//   ns="mcpplibs", shortName="capi.lua" → ns="mcpplibs.capi", shortName="lua".
+//
+// This preserves the fully qualified name while making dependency de-dup use
+// the same structured key as TOML-native [dependencies."mcpplibs.capi"].
+inline void normalize_nested_namespace(std::string& ns, std::string& shortName)
+{
+    if (ns.empty()) return;
+    auto dot = shortName.rfind('.');
+    if (dot == std::string::npos || dot + 1 >= shortName.size()) return;
+
+    ns += ".";
+    ns += shortName.substr(0, dot);
+    shortName = shortName.substr(dot + 1);
+}
+
 // ─── Index directory naming ──────────────────────────────────────────
 //
 // Maps (indexName, namespace, shortName) → the xpkgs subdirectory name
@@ -201,6 +217,17 @@ inline std::vector<std::string> install_dir_candidates(std::string_view ns,
         candidates.push_back(std::format("{}-x-{}", indexName, shortName));
     }
 
+    // Legacy dotted dependency keys such as "mcpplibs.capi.lua" are parsed as
+    // ns="mcpplibs", shortName="capi.lua". Some xlings indices store these as
+    // nested namespaces: mcpplibs.capi-x-mcpplibs.capi.lua.
+    if (!ns.empty()) {
+        auto dot = shortName.rfind('.');
+        if (dot != std::string_view::npos) {
+            auto nestedNs = std::format("{}.{}", ns, shortName.substr(0, dot));
+            candidates.push_back(std::format("{}-x-{}", nestedNs, fqname));
+        }
+    }
+
     return candidates;
 }
 
diff --git a/src/pm/package_fetcher.cppm b/src/pm/package_fetcher.cppm
diff --git a/tests/unit/test_modgraph.cpp b/tests/unit/test_modgraph.cpp
diff --git a/tests/unit/test_pm_compat.cpp b/tests/unit/test_pm_compat.cpp
diff --git a/tests/unit/test_toml.cpp b/tests/unit/test_toml.cpp
