fix: an indirect import is found whatever module map its importer has (GCC)

A GCC module map now names the BMI directory as its repository ($root) and
every path below it, so a BMI built with GCC's own mapper and one built with a
map record their imports at the same paths. The dyndep step reads $root.

Co-authored-by: speak-agent <248744407+speak-agent@users.noreply.github.com>

Author: Sunrisepeak

CHANGELOG.md

@@ -14,6 +14,16 @@
   `app.wasm`, the edge's implicit output was missing, and `mcpp pack` of a
   `wasm32-emscripten` program (mcpp-plugins' `dist-web`) found no stem family.
   A WebAssembly link is in place, as a PE link is.
+- **A module's indirect import is found whatever map its importer has (GCC).**
+  A unit that reaches another package's module is compiled with a module map,
+  and a unit that imports only the root's modules with GCC's own mapper. A BMI
+  records the paths of its imports as its compile's mapper spelt them, and the
+  map named no repository, so a unit with a map that imported a root module
+  compiled without one looked for that module's import beside the build
+  directory (`failed to read compiled module`, `Bad import dependency`). The
+  map now names the BMI directory as its repository (`$root gcm.cache`) and
+  every path below it, as GCC's own mapper does; the dyndep step reads the
+  same form.
 
 ## [2026.10.26.1] - 2026-10-26
 

modules/dyndep/src/dyndep.cppm

@@ -63,7 +63,8 @@ struct DyndepOptions {
 // The BMI path `name` takes under `opts`: the module map's, or the flat one.
 std::string bmi_path_for(std::string_view name, const DyndepOptions& opts);
 
-// Parse a module map: `<module name> <BMI path>` per line.
+// Parse a module map: `<module name> <BMI path>` per line. A `$root <dir>`
+// line (GCC's repository) puts every relative path after it below `<dir>`.
 std::map<std::string, std::string, std::less<>> parse_module_map(std::string_view body);
 
 // Parse a single .ddi JSON body to a UnitInfo. Returns unexpected on JSON error.
@@ -206,14 +207,21 @@ std::string bmi_path_for(std::string_view name, const DyndepOptions& opts) {
 
 std::map<std::string, std::string, std::less<>> parse_module_map(std::string_view body) {
     std::map<std::string, std::string, std::less<>> out;
+    std::string_view root;
     while (!body.empty()) {
         auto nl = body.find('\n');
         auto line = body.substr(0, nl);
         body.remove_prefix(nl == std::string_view::npos ? body.size() : nl + 1);
         while (!line.empty() && (line.back() == '\r' || line.back() == ' ')) line.remove_suffix(1);
         auto sp = line.find(' ');
         if (sp == std::string_view::npos || sp == 0) continue;
-        out.emplace(std::string(line.substr(0, sp)), std::string(line.substr(sp + 1)));
+        const auto name = line.substr(0, sp);
+        const auto path = line.substr(sp + 1);
+        if (name == "$root") { root = path; continue; }
+        if (root.empty() || path.starts_with('/') || std::filesystem::path(path).is_absolute())
+            out.emplace(std::string(name), std::string(path));
+        else
+            out.emplace(std::string(name), std::string(root) + "/" + std::string(path));
     }
     return out;
 }

src/build/plan.cppm

@@ -3553,8 +3553,20 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
                 for (auto const* std_name : {"std", "std.compat"})
                     entries.emplace(std_name, std::string(traits.bmiDir) + "/" + basename(std_name));
 
+            // GCC's map names the BMI directory as its repository (`$root`)
+            // and every path below it, as GCC's own mapper does for a unit
+            // given no map. A BMI records the paths of the modules it imports
+            // as its compile's mapper spelt them, and an importer finds an
+            // INDIRECT import at that recorded path below its own repository:
+            // a root unit compiled without a map, imported by one compiled with
+            // a repository other than the BMI directory, would send that
+            // importer to `<name>.gcm` beside the build directory.
             ModuleScope scope;
-            for (auto const& [name, path] : entries) scope.content += name + " " + path + "\n";
+            const std::string root = std::string(traits.bmiDir) + "/";
+            if (gcc) scope.content = "$root " + std::string(traits.bmiDir) + "\n";
+            for (auto const& [name, path] : entries)
+                scope.content += name + " "
+                    + (gcc && path.starts_with(root) ? path.substr(root.size()) : path) + "\n";
             if (!gcc && importsQualified) {
                 // `-fmodule-file=<name>=<path>` (clang) or `/reference
                 // <name>=<path>` (MSVC) for each module the unit imports that

tests/e2e/940_an_indirect_import_is_found_whatever_map_its_importer_has.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# requires:
+# 940 -- an indirect import is found whatever module map its importer has.
+#
+# A unit of the root package is given a module map only when it reaches a
+# module of another package (pack drive and selection design 2026-10-01, B1);
+# a unit that imports only the root's modules is compiled with the compiler's
+# own mapper. GCC records in a BMI the path of each module that BMI imports, as
+# its compile's mapper spelt it, and an importer finds an INDIRECT import at
+# that recorded path below its own repository. Until 2026.10.26.2 a map named
+# no repository, so a unit with a map that imported a root module compiled
+# without one looked for that module's import beside the build directory:
+#
+#   mcppide.platform.os: error: failed to read compiled module: No such file
+#   note: compiled module file is 'mcppide.platform.os.gcm'
+#
+# Criteria:
+#   A. `app.os` (imports nothing), `app.process` (imports app.os; no map),
+#      `app.jobs` (imports app.process and a path dependency's module; a map):
+#      the build succeeds and the program runs.
+#   B. The reverse: `app.view` (no map) imports `app.jobs` (a map), whose BMI
+#      records its own imports; the build succeeds.
+set -e
+
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+fail() { echo "FAIL: $1"; shift; for f in "$@"; do echo "--- $f ---"; cat "$f" 2>/dev/null; done; exit 1; }
+
+cd "$TMP"
+mkdir -p dep/src app/src
+cat > dep/mcpp.toml <<'TOML'
+[package]
+name    = "dep"
+version = "0.1.0"
+
+[targets.dep]
+kind = "lib"
+TOML
+printf 'export module dep.lib;\nexport int dep_value() { return 2; }\n' > dep/src/lib.cppm
+
+cat > app/mcpp.toml <<'TOML'
+[package]
+name    = "app"
+version = "0.1.0"
+
+[dependencies]
+dep = { path = "../dep" }
+TOML
+printf 'export module app.os;\nexport inline constexpr int os_value = 1;\n' > app/src/os.cppm
+printf 'export module app.process;\nimport app.os;\nexport int process_value() { return os_value; }\n' > app/src/process.cppm
+printf 'export module app.jobs;\nimport app.process;\nimport dep.lib;\nexport int jobs_value() { return process_value() + dep_value(); }\n' > app/src/jobs.cppm
+printf 'export module app.view;\nimport app.jobs;\nexport int view_value() { return jobs_value() * 10; }\n' > app/src/view.cppm
+printf '#include <cstdio>\nimport app.view;\nint main() { std::printf("%%d\\n", view_value()); }\n' > app/src/main.cpp
+
+cd app
+"$MCPP" build > build.log 2>&1 || fail "a unit with a map could not read a root BMI's import" build.log
+echo "ok: A, B the build succeeds"
+out=$("$MCPP" run 2>run.log | tr -d '\r' | tail -1)
+[ "$out" = "30" ] || fail "the program printed '$out', expected 30" run.log
+echo "ok: the program runs"
+
+echo "PASS: 940 an indirect import is found whatever map its importer has"

tests/unit/test_dyndep.cpp

@@ -203,3 +203,17 @@ TEST(VerifyUnitExpectations, ExpectNoneMatchesEmptyUnit) {
     auto err = mcpp::dyndep::verify_unit_expectations(u, std::nullopt, {});
     EXPECT_FALSE(err.has_value());
 }
+
+// GCC's map names its repository with `$root`, and every relative path after
+// it lies below that directory: the dyndep step must name the BMI the compiler
+// reads, or ninja orders the compile before the BMI exists.
+TEST(Dyndep, ParseModuleMapRootedAtTheBmiDirectory) {
+    auto m = parse_module_map("$root gcm.cache\na a.gcm\ndep.m dep/dep.m.gcm\nstd std.gcm\n");
+    EXPECT_EQ(m.size(), 3u);
+    EXPECT_FALSE(m.contains("$root"));
+    EXPECT_EQ(m.at("a"), "gcm.cache/a.gcm");
+    EXPECT_EQ(m.at("dep.m"), "gcm.cache/dep/dep.m.gcm");
+    // Without `$root` (clang's and MSVC's maps) a path is taken as written.
+    auto plain = parse_module_map("m pcm.cache/core/m.pcm\n");
+    EXPECT_EQ(plain.at("m"), "pcm.cache/core/m.pcm");
+}

tests/unit/test_module_address.cpp

@@ -199,9 +199,12 @@ TEST(ModuleAddress, MemberBmisAreQualifiedAndTheMapIsTheUnitsReach) {
     ASSERT_TRUE(gcc) << err;
     auto const& iface = gcc->core.at("core.cppm");
     EXPECT_EQ(iface.bmiFile, "core/corelib.gcm");
-    EXPECT_NE(iface.mapContent.find("corelib gcm.cache/core/corelib.gcm\n"), std::string::npos);
-    EXPECT_NE(iface.mapContent.find("m gcm.cache/core/m.gcm\n"), std::string::npos);
-    EXPECT_NE(iface.mapContent.find("std gcm.cache/std.gcm\n"), std::string::npos);
+    // GCC's map is rooted at the BMI directory, as its default mapper is, so
+    // a BMI records its imports at the same paths whichever mapper made it.
+    EXPECT_TRUE(iface.mapContent.starts_with("$root gcm.cache\n")) << iface.mapContent;
+    EXPECT_NE(iface.mapContent.find("corelib core/corelib.gcm\n"), std::string::npos);
+    EXPECT_NE(iface.mapContent.find("m core/m.gcm\n"), std::string::npos);
+    EXPECT_NE(iface.mapContent.find("std std.gcm\n"), std::string::npos);
     EXPECT_EQ(iface.mapContent.find("tool"), std::string::npos)
         << "the map names a module the unit does not reach:\n" << iface.mapContent;
     ASSERT_FALSE(iface.flags.empty());