two defects found reviewing this branch: the wrong provider, and a name that is a prefix of another

The interface list was read from the first package in the graph that stated
one. A graph may carry more than one candidate for a layer --- a workspace
member beside a dependency, a second implementation behind a feature that did
not activate --- and only one of them is the provider this build resolved.
Comparing a consumer's requirements against an implementation the build is not
using is a wrong answer rather than a missing one. It now reads the resolved
layer.

`c_abi_absent_facility_advice` matched the symbol as a substring, and
`undefined symbol: open` is a prefix of `undefined symbol: opendir`. A link
failure would have been explained by a row with nothing to do with it, and an
explanation that is confidently wrong is worse than the linker's own message.
The name must now end where the diagnostic's name ends.

Co-authored-by: Claude Code <noreply@anthropic.com>

Author: speak-agent

src/build/ninja_backend.cppm

@@ -697,10 +697,27 @@ std::string c_abi_absent_facility_advice(
         // program at run time by construction, so matching them against a
         // link diagnostic would report a coincidence of spelling.
         if (e.form != mcpp::targetside::CAbiAbsentForm::Link) continue;
-        const std::string lld = std::format("undefined symbol: {}", e.name);
+        // THE NAME MUST END WHERE THE DIAGNOSTIC'S NAME ENDS. `undefined
+        // symbol: open` is a prefix of `undefined symbol: opendir`, so a
+        // plain substring search explains a link failure with a row that has
+        // nothing to do with it — and an explanation that is confidently
+        // wrong is worse than the linker's own message. lld ends the name at
+        // the line; GNU ld closes it with a quote.
         const std::string gnu = std::format("undefined reference to `{}'", e.name);
-        if (output.find(lld) == std::string_view::npos
-            && output.find(gnu) == std::string_view::npos) continue;
+        bool matched = output.find(gnu) != std::string_view::npos;
+        if (!matched) {
+            const std::string lld = std::format("undefined symbol: {}", e.name);
+            for (std::size_t at = output.find(lld); at != std::string_view::npos;
+                 at = output.find(lld, at + 1)) {
+                const auto after = at + lld.size();
+                if (after >= output.size() || output[after] == '\n'
+                    || output[after] == '\r' || output[after] == ' ') {
+                    matched = true;
+                    break;
+                }
+            }
+        }
+        if (!matched) continue;
         named += std::format("\n        {:<20} {}", e.name,
                              e.note.empty() ? "declared absent" : e.note);
     }

src/build/prepare.cppm

@@ -11181,10 +11181,23 @@ prepare_build(bool print_fingerprint,
         // changes no command line and no diagnostic for every project built
         // before it.
         {
+            // THE LIST COMES FROM THE PACKAGE THAT RESOLVED AS THE LAYER, NOT
+            // FROM THE FIRST ONE IN THE GRAPH THAT STATED ONE. A graph may
+            // carry more than one candidate for a layer — a workspace member
+            // beside a dependency, a second implementation reached through a
+            // feature that did not activate — and only one of them is the
+            // provider this build resolved. Reading whichever came first in
+            // `packages` would compare a consumer's requirements against an
+            // implementation the build is not using, which is a wrong answer
+            // rather than a missing one.
             std::vector<std::string> providedInterfaces;
             std::string providerId;
             for (auto& pkg : packages) {
                 if (pkg.manifest.kernelAbiProvidesInterfaces.empty()) continue;
+                if (!resolvedTargetSide.kernelAbi.impl.empty()
+                    && resolvedTargetSide.kernelAbi.impl.find(
+                           pkg.manifest.package.name) == std::string::npos)
+                    continue;
                 providedInterfaces = pkg.manifest.kernelAbiProvidesInterfaces;
                 providerId = pkg.manifest.package.name;
                 break;

tests/unit/test_build_flags.cpp

@@ -267,3 +267,17 @@ TEST(CAbiAbsentAdvice, ALibraryThatEnumeratedNothingProducesNoNote) {
     EXPECT_TRUE(mcpp::build::c_abi_absent_facility_advice(
         "ld.lld: error: undefined symbol: fork\n", "musl", {}).empty());
 }
+
+TEST(CAbiAbsentAdvice, ALongerSymbolWithTheSamePrefixIsNotExplained) {
+    // `undefined symbol: open` is a prefix of `undefined symbol: opendir`.
+    // A substring search would answer a link failure with a row that has
+    // nothing to do with it, and an explanation that is confidently wrong is
+    // worse than the linker's own message.
+    std::vector<mcpp::targetside::CAbiAbsentEntry> absent{
+        {"open", mcpp::targetside::CAbiAbsentForm::Link, "not supplied"},
+    };
+    EXPECT_TRUE(mcpp::build::c_abi_absent_facility_advice(
+        "ld.lld: error: undefined symbol: opendir\n", "musl", absent).empty());
+    EXPECT_FALSE(mcpp::build::c_abi_absent_facility_advice(
+        "ld.lld: error: undefined symbol: open\n", "musl", absent).empty());
+}