tool: a stated program path resolves whichever executable suffix the file carries

A build program writes the path a shell gave it, and on Windows `command -v cmake`
answers `C:/Program Files/CMake/bin/cmake` for a `cmake.exe`. The resolver
insisted on the exact spelling and refused a program the host itself would have
run -- measured in CI, where the cmake consumer reported
`options::cmake = "C:/Program Files/CMake/bin/cmake" (not found)` on a runner
carrying cmake, and then failed to compile because the subproject it configures
never built. A stated path now follows the same suffix rule as a discovered one,
which `program_in` has always applied, and a case states it on a Linux row
because the rule is the same on every host.

Author: speak-agent

src/tool.cppm

@@ -73,6 +73,26 @@ inline std::string program_in(const std::filesystem::path& dir, std::string_view
     return {};
 }
 
+// A STATED PATH, WITH THE SAME SUFFIX RULE AS A DISCOVERED ONE. A build program
+// writes the path a shell gave it, and on Windows `command -v cmake` answers
+// `C:/Program Files/CMake/bin/cmake` for a `cmake.exe`; process creation there
+// appends the suffix itself, so a resolver that insisted on the exact spelling
+// refused a program the host would have run (measured in CI: the cmake consumer
+// reported `options::cmake = "C:/Program Files/CMake/bin/cmake" (not found)` on a
+// runner carrying cmake). Empty when neither spelling is a file.
+inline std::string program_at(const std::filesystem::path& p) {
+    if (is_file(p)) return generic(p);
+    auto with = p;
+    with += ".exe";
+    if (is_file(with)) return generic(with);
+    if (p.extension() == ".exe") {
+        auto without = p;
+        without.replace_extension();
+        if (is_file(without)) return generic(without);
+    }
+    return {};
+}
+
 inline std::string find_on_path(std::string_view name) {
     const char* path = std::getenv("PATH");
     if (!path) return {};
@@ -226,9 +246,9 @@ inline found resolve(const spec& s, const choice& c = {}) {
                         record(from::choice, file, line);
                         return out;
                     }
-                } else if (detail::is_file(p)) {
-                    out.program = detail::generic(p);
-                    out.root = detail::root_of(p);
+                } else if (auto hit = detail::program_at(p); !hit.empty()) {
+                    out.program = std::move(hit);
+                    out.root = detail::root_of(out.program);
                     record(from::choice, file, line);
                     return out;
                 }

tests/plugin-logic/build.mcpp

@@ -479,6 +479,27 @@ int main(int argc, char** argv) {
                        "the decision names the choice and the program");
           } },
 
+        { "tool: a stated path resolves whichever executable suffix the file carries",
+          // What a shell hands a build program on Windows: `command -v cmake`
+          // answers a path with no `.exe`, for a `cmake.exe`. Process creation
+          // there appends the suffix, so the resolver does too -- stated on a
+          // Linux row, because the rule is the same on every host.
+          t::row::linux_libcxx().file("pkg/opt/bin/cmake.exe")
+              .xpkg_source("xim", "cmake", "pending"),
+          [] {
+              const auto f = tool_resolve(mcpp::plugins::tool::program(
+                  std::string(mcpp::manifest_dir()) + "/opt/bin/cmake"));
+              std::printf("source=%s program=%s\n",
+                          std::string(mcpp::plugins::tool::name(f.source)).c_str(),
+                          f.program.c_str());
+              return f ? 0 : 1;
+          },
+          [](const t::result& r, t::checker& c) {
+              c.expect(r.has_line("source=choice", "opt/bin/cmake.exe"),
+                       "the file beside the stated path answers");
+              c.expect(!r.has_line("mcpp:xpkg-request="), "a choice requests no payload");
+          } },
+
         { "tool: an override answers, and the payload is not consulted",
           t::row::linux_libcxx().file("opt/bin/cmake")
               .xpkg("xim", "cmake", "{root}/opt")