Try the MSVC debug postfix before the plain name when resolving a bundle library

Author: SineStriker

README.md

@@ -307,7 +307,7 @@ A plugin with compatibility version `C` and current version `V` satisfies a requ
 `PluginSystem` supports three filesystem layouts:
 
 - `Flat` is the default. It puts plugin libraries directly below each search path and reads their embedded metadata.
-- `Bundle` gives every plugin a child directory containing its library and a sidecar `plugin.json`. The metadata must contain a root `name` without a platform library prefix or suffix. For example, `"name": "editor"` can resolve to `editor.dll`, `libeditor.dll`, `libeditor.so`, or `libeditor.dylib`.
+- `Bundle` gives every plugin a child directory containing its library and a sidecar `plugin.json`. The metadata must contain a root `name` without a platform library prefix or suffix. For example, `"name": "editor"` can resolve to `editor.dll`, `libeditor.dll`, `libeditor.so`, or `libeditor.dylib`. A debug build of MSVC tries the debug postfix `d` first and resolves `editord.dll` before `editor.dll`, because a debug build and a release build of MSVC link different C runtimes and are not binary compatible. A release build does not try the postfix.
 - `CustomLayout` is reported when the constructor receives a user-provided `PluginFactory`. Its `scanPluginPaths()` and `resolvePluginPath()` overrides can implement recursive packages, another metadata path, or a separate library subdirectory. `PluginSystem` accepts only filesystem plugins returned by this factory.
 
 In Bundle layout, `name` belongs to `BundlePluginFactory`, while `displayName` belongs to `PluginSystem`. They happen to coexist in the same root metadata object and do not describe the same thing.

include/stdcorelib/plugin/pluginfactory.h

@@ -139,7 +139,8 @@ namespace stdc::plugin {
     ///
     /// Each bundle has external metadata and a plugin library. The metadata's root \c name
     /// field gives the library's platform-independent name. For example, \c editor can resolve to
-    /// \c editor.dll, \c libeditor.so, or \c libeditor.dylib.
+    /// \c editor.dll, \c libeditor.so, or \c libeditor.dylib. A debug build of MSVC tries the
+    /// name with the debug postfix \c d first, such as \c editord.dll, and then the name alone.
     class STDC_PLUGIN_EXPORT BundlePluginFactory : public PluginFactory {
     public:
         /// Creates a bundle factory with a configurable metadata path.
@@ -166,7 +167,8 @@ namespace stdc::plugin {
         /// Resolves the plugin library described by bundle metadata.
         ///
         /// The default implementation reads the root \c name field, searches the bundle root, and
-        /// accepts the platform's library prefix and suffix around that name.
+        /// accepts the platform's library prefix and suffix around that name. A debug build of
+        /// MSVC tries the name with the debug postfix \c d before the name alone.
         ///
         /// \param bundlePath The bundle directory returned by scanPluginPaths().
         /// \param metadata The complete root object read from the bundle metadata file.

src/plugin/pluginfactory.cpp

@@ -450,16 +450,27 @@ namespace stdc::plugin {
             ".so",
 #endif
         };
+        // Debug and release builds of MSVC use incompatible C runtimes and STL layouts. A debug
+        // build tries the postfix d first and then the plain name, because some plugins omit the
+        // postfix. A release build does not try the postfix.
+#if defined(_MSC_VER) && defined(_DEBUG)
+        constexpr std::array<std::string_view, 2> postfixes{"d", ""};
+#else
+        constexpr std::array<std::string_view, 1> postfixes{""};
+#endif
 
-        for (const auto prefix : prefixes) {
-            for (const auto suffix : suffixes) {
-                fs::path candidateName = std::string(prefix);
-                candidateName += requestedPath.native();
-                candidateName += std::string(suffix);
-                const auto candidate = bundlePath / candidateName;
-                std::error_code ec;
-                if (fs::is_regular_file(candidate, ec) && SharedLibrary::isLibrary(candidate)) {
-                    return candidate;
+        for (const auto postfix : postfixes) {
+            for (const auto prefix : prefixes) {
+                for (const auto suffix : suffixes) {
+                    fs::path candidateName = std::string(prefix);
+                    candidateName += requestedPath.native();
+                    candidateName += std::string(postfix);
+                    candidateName += std::string(suffix);
+                    const auto candidate = bundlePath / candidateName;
+                    std::error_code ec;
+                    if (fs::is_regular_file(candidate, ec) && SharedLibrary::isLibrary(candidate)) {
+                        return candidate;
+                    }
                 }
             }
         }

tests/auto/test_pluginfactory.cpp

@@ -11,6 +11,16 @@
 
 namespace {
 
+    // Returns the bundle name of a plugin library, which excludes the debug postfix of MSVC that
+    // BundlePluginFactory appends.
+    std::string bundleName(const std::filesystem::path &library) {
+        auto name = library.stem().string();
+#if defined(_MSC_VER) && defined(_DEBUG)
+        name.pop_back();
+#endif
+        return name;
+    }
+
     class RuntimePlugin : public stdc::plugin::Plugin {};
 
     class DefaultPluginFactoryProbe : public stdc::plugin::PluginFactory {
@@ -100,13 +110,19 @@ namespace {
         }
 
         std::filesystem::path addBundle() const {
+            const auto source = std::filesystem::path(TEST_PLUGINLOADER_PLUGIN_PATH);
+            return addBundle(source.filename());
+        }
+
+        // Adds a bundle whose library is the test plugin copied to fileName.
+        std::filesystem::path addBundle(const std::filesystem::path &fileName) const {
             const auto source = std::filesystem::path(TEST_PLUGINLOADER_PLUGIN_PATH);
             const auto bundle = _path / "bundle";
             std::filesystem::create_directory(bundle);
-            std::filesystem::copy_file(source, bundle / source.filename());
+            std::filesystem::copy_file(source, bundle / fileName);
 
             std::ofstream metadata(bundle / "plugin.json");
-            metadata << R"({"name":")" << source.stem().string() << R"(","answer":42})";
+            metadata << R"({"name":")" << bundleName(source) << R"(","answer":42})";
             return bundle;
         }
 
@@ -284,6 +300,45 @@ BOOST_AUTO_TEST_CASE(test_bundle_scan_and_resolve) {
     BOOST_CHECK_EQUAL(plugins.front()->metadata()["answer"].toInt(), 42);
 }
 
+#ifdef _MSC_VER
+BOOST_AUTO_TEST_CASE(test_bundle_debug_postfix) {
+    const auto source = std::filesystem::path(TEST_PLUGINLOADER_PLUGIN_PATH);
+    const auto name = bundleName(source);
+    const auto extension = source.extension().string();
+
+#  ifdef _DEBUG
+    // The name alone resolves if the library has no postfix.
+    {
+        TemporaryPluginDirectory directory;
+        directory.addBundle(name + extension);
+
+        stdc::plugin::BundlePluginFactory factory;
+        factory.addPluginPath("org.stdcorelib.LoaderTest", directory.path());
+        BOOST_CHECK_EQUAL(factory.plugins("org.stdcorelib.LoaderTest").size(), 1u);
+    }
+
+    // The postfix precedes the name alone, which is a library without plugin metadata here.
+    {
+        TemporaryPluginDirectory directory;
+        const auto bundle = directory.addBundle(name + "d" + extension);
+        std::filesystem::copy_file(TEST_PLUGINLOADER_LIBRARY_PATH, bundle / (name + extension));
+
+        stdc::plugin::BundlePluginFactory factory;
+        factory.addPluginPath("org.stdcorelib.LoaderTest", directory.path());
+        BOOST_CHECK_EQUAL(factory.plugins("org.stdcorelib.LoaderTest").size(), 1u);
+    }
+#  else
+    // A release build does not resolve a debug library.
+    TemporaryPluginDirectory directory;
+    directory.addBundle(name + "d" + extension);
+
+    stdc::plugin::BundlePluginFactory factory;
+    factory.addPluginPath("org.stdcorelib.LoaderTest", directory.path());
+    BOOST_CHECK(factory.plugins("org.stdcorelib.LoaderTest").empty());
+#  endif
+}
+#endif
+
 BOOST_AUTO_TEST_CASE(test_ignores_runtime_plugin_without_iid) {
     RuntimePlugin plugin;
     stdc::plugin::PluginFactory factory;

tests/auto/test_pluginsystem.cpp

@@ -10,12 +10,23 @@
 #include <chrono>
 #include <fstream>
 #include <functional>
+#include <string>
 #include <thread>
 
 #include <boost/test/unit_test.hpp>
 
 namespace {
 
+    // Returns the bundle name of a plugin library, which excludes the debug postfix of MSVC that
+    // BundlePluginFactory appends.
+    std::string bundleName(const std::filesystem::path &library) {
+        auto name = library.stem().string();
+#if defined(_MSC_VER) && defined(_DEBUG)
+        name.pop_back();
+#endif
+        return name;
+    }
+
     class TemporaryPluginSystemDirectory {
     public:
         explicit TemporaryPluginSystemDirectory(
@@ -54,7 +65,7 @@ namespace {
             std::filesystem::copy_file(source, pluginPath);
 
             std::ofstream metadataFile(pluginDirectory / "plugin.json");
-            metadataFile << R"({"name":")" << source.stem().string() << '"';
+            metadataFile << R"({"name":")" << bundleName(source) << '"';
             if (metadata.size() > 2) {
                 metadataFile << ',' << metadata.substr(1, metadata.size() - 2);
             }