test: config.toml's overrides are read by a function a test can call

The third place an override may be stated was parsed inside `load_or_init`,
which bootstraps a home, so no unit test could reach it. `parse_payload_overrides`
is now a pure function of the parsed document, and three cases cover the two
shapes it accepts, the key it refuses, and a config with no such table.

Author: speak-agent

src/config.cppm

@@ -315,6 +315,13 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
 // Pretty-print resolved config for `mcpp env` command.
 void print_env(const GlobalConfig& cfg);
 
+// `[xlings.overrides]` of a parsed config.toml, keyed by package identity
+// (`<ns>:<name>`, the namespace defaulted to `xim`): where a declared xlings
+// payload comes from on this machine (mcpp#755). A pure function of the
+// document, so a test reads it without a home to bootstrap.
+std::expected<std::map<std::string, GlobalConfig::PayloadOverride>, std::string>
+parse_payload_overrides(const mcpp::libs::toml::Document& doc);
+
 // Normalize legacy index naming in a loaded config (exported for tests):
 // org migration mcpp-community/mcpp-index -> mcpplibs/mcpp-index, index name
 // mcpp-index -> mcpplibs, then name+url dedup. Order matters: URL first, so
@@ -652,6 +659,43 @@ void canonicalize_legacy_index_names(GlobalConfig& cfg) {
     cfg.indexRepos = std::move(normalized);
 }
 
+std::expected<std::map<std::string, GlobalConfig::PayloadOverride>, std::string>
+parse_payload_overrides(const mcpp::libs::toml::Document& doc) {
+    std::map<std::string, GlobalConfig::PayloadOverride> out;
+    auto* ot = doc.get_table("xlings.overrides");
+    if (!ot) return out;
+    for (auto const& [key, val] : *ot) {
+        GlobalConfig::PayloadOverride o;
+        o.line = static_cast<int>(val.position.line);
+        if (val.is_string()) {
+            o.value = val.as_string();
+        } else if (val.is_table()) {
+            for (auto const& [k, v] : val.as_table()) {
+                if ((k != "program" && k != "root" && k != "version") || !v.is_string())
+                    return std::unexpected(std::format(
+                        "config.toml [xlings.overrides] {}: '{}' is not a key of an "
+                        "override; an override is a path, or a table of `program` "
+                        "or `root` and an optional `version`", key, k));
+                if (k == "version") o.version = v.as_string();
+                else { o.kind = k; o.value = v.as_string(); }
+            }
+        }
+        if (o.value.empty())
+            return std::unexpected(std::format(
+                "config.toml [xlings.overrides] {}: expected a path, or a table "
+                "naming `program` or `root`", key));
+        // The identity, as the manifest and the address set spell it: a key
+        // without a namespace names the `xim` package, and a version in the key
+        // is dropped -- an override states where a package comes from, not
+        // which version of it is wanted.
+        auto colon = key.find(':');
+        std::string ident = colon == std::string::npos ? "xim:" + key : key;
+        if (auto at = ident.find('@'); at != std::string::npos) ident.resize(at);
+        out.insert_or_assign(std::move(ident), std::move(o));
+    }
+    return out;
+}
+
 std::expected<GlobalConfig, ConfigError> load_or_init(
     bool quiet,
     BootstrapProgressCallback onBootstrapProgress,
@@ -731,36 +775,11 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
     cfg.defaultJobs    = doc->get_int("build.default_jobs").value_or(0);
     cfg.defaultToolchain = doc->get_string("toolchain.default").value_or("");
     cfg.defaultTarget    = doc->get_string("toolchain.default_target").value_or("");
-    // [xlings.overrides] (mcpp#755). Read in the manifest's two shapes -- a
-    // path, or a table of `program` or `root` and `version` -- and refused by
-    // name when it is neither, as a malformed config.toml key always is.
-    if (auto* ot = doc->get_table("xlings.overrides")) {
-        for (auto const& [key, val] : *ot) {
-            GlobalConfig::PayloadOverride o;
-            o.line = static_cast<int>(val.position.line);
-            if (val.is_string()) {
-                o.value = val.as_string();
-            } else if (val.is_table()) {
-                for (auto const& [k, v] : val.as_table()) {
-                    if ((k != "program" && k != "root" && k != "version") || !v.is_string())
-                        return std::unexpected(ConfigError{std::format(
-                            "config.toml [xlings.overrides] {}: '{}' is not a key of an "
-                            "override; an override is a path, or a table of `program` "
-                            "or `root` and an optional `version`", key, k)});
-                    if (k == "version") o.version = v.as_string();
-                    else { o.kind = k; o.value = v.as_string(); }
-                }
-            }
-            if (o.value.empty())
-                return std::unexpected(ConfigError{std::format(
-                    "config.toml [xlings.overrides] {}: expected a path, or a table "
-                    "naming `program` or `root`", key)});
-            auto colon = key.find(':');
-            std::string ident = colon == std::string::npos ? "xim:" + key : key;
-            if (auto at = ident.find('@'); at != std::string::npos) ident.resize(at);
-            cfg.payloadOverrides.insert_or_assign(std::move(ident), std::move(o));
-        }
-    }
+    // [xlings.overrides] (mcpp#755), read by the same function the tests read.
+    if (auto overrides = parse_payload_overrides(*doc); overrides)
+        cfg.payloadOverrides = std::move(*overrides);
+    else
+        return std::unexpected(ConfigError{overrides.error()});
 
     // [log] section — re-initialize logger with config values
     {

tests/unit/test_sources.cpp

@@ -6,6 +6,8 @@
 
 import std;
 import mcpp.manifest;
+import mcpp.config;
+import mcpp.libs.toml;
 import mcpp.build.directives;
 import mcpp.toolchain.dialect;
 import mcpp.toolchain.registry;
@@ -230,6 +232,47 @@ TEST(Sources, OverrideVersionIsCheckedAgainstRequirements) {
     EXPECT_EQ(reqs[0], ">=3.31 by mcpp:plugins");
 }
 
+// ── [xlings.overrides] in config.toml ───────────────────────────────────────
+
+TEST(Sources, ConfigOverridesParseWithTheManifestsTwoShapes) {
+    auto doc = mcpp::libs::toml::parse(R"(
+[xlings.overrides]
+"xim:cmake" = "/usr/bin/cmake"
+vcpkg       = { root = "/opt/vcpkg" }
+"xim:slang" = { program = "slangc", version = "2026.14.1" }
+)");
+    ASSERT_TRUE(doc.has_value());
+    auto o = mcpp::config::parse_payload_overrides(*doc);
+    ASSERT_TRUE(o.has_value()) << o.error();
+    ASSERT_EQ(o->size(), 3u);
+    EXPECT_EQ(o->at("xim:cmake").kind, "path");
+    EXPECT_EQ(o->at("xim:cmake").value, "/usr/bin/cmake");
+    // A key without a namespace names the `xim` package, as everywhere else.
+    EXPECT_EQ(o->at("xim:vcpkg").kind, "root");
+    EXPECT_EQ(o->at("xim:slang").kind, "program");
+    EXPECT_EQ(o->at("xim:slang").version, "2026.14.1");
+    EXPECT_GT(o->at("xim:cmake").line, 0);
+}
+
+TEST(Sources, ConfigOverrideWithAnUnknownKeyIsRefused) {
+    auto doc = mcpp::libs::toml::parse(R"(
+[xlings.overrides]
+cmake = { programme = "/usr/bin/cmake" }
+)");
+    ASSERT_TRUE(doc.has_value());
+    auto o = mcpp::config::parse_payload_overrides(*doc);
+    ASSERT_FALSE(o.has_value());
+    EXPECT_NE(o.error().find("programme"), std::string::npos) << o.error();
+}
+
+TEST(Sources, ConfigWithoutTheTableHasNoOverrides) {
+    auto doc = mcpp::libs::toml::parse("[toolchain]\ndefault = \"gcc@16.1.0\"\n");
+    ASSERT_TRUE(doc.has_value());
+    auto o = mcpp::config::parse_payload_overrides(*doc);
+    ASSERT_TRUE(o.has_value()) << o.error();
+    EXPECT_TRUE(o->empty());
+}
+
 // ── A toolchain named by path ───────────────────────────────────────────────
 
 TEST(Sources, PathSpecTakesTheFamilyFromTheDrivers) {