Rework Vst3MessageHandler::receive_messages

This now takes a regular overloaded function and the visiting is done in
`receive_messages()` itself. This way we can use templates to ensure
that the return type is correct. Otherwise auto will cause issues in the
future when we want to return multiple concrete types from a function
that takes a single variant. The alternative would be both receiving a
variant as a parameter and then returning another variant as a result,
but that is much less type safe.

src/common/communication/vst3.h

@@ -152,11 +152,9 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
      * @param callback The function used to generate a response out of the
      *   request.  See the definition of `F` for more information.
      *
-     * @tparam F A function type in the form of `T::Response(Request(T))`. C++
-     *   doesn't have syntax for this, but the function receives a `Request`
-     *   variant containing a `T`, and the function should return a `T::Reponse`
-     *   object. This way we can directly deserialize into a `T::Reponse` on the
-     *   side that called `send_object(T)`.
+     * @tparam F A function type in the form of `T::Response(T)` for every `T`
+     * in `Request`. This way we can directly deserialize into a `T::Response`
+     * on the side that called `receive_into(T, T::Response&)`.
      *
      * @relates Vst3MessageHandler::send_event
      */
@@ -178,7 +176,14 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
                         request);
                 }
 
-                const auto& response = callback(request);
+                // We do the visiting here using a templated lambda. This way we
+                // always know for sure that the function returns the correct
+                // type, and we can scrap a lot of boilerplate elsewhere.
+                const auto& response = std::visit(
+                    [&]<typename T>(const T object) ->
+                    typename T::Response { return callback(object); },
+                    request);
+
                 if (logging) {
                     auto [logger, is_host_vst] = *logging;
                     logger.log_response(!is_host_vst, response);

src/common/serialization/vst3.h

@@ -58,7 +58,7 @@ struct WantsPluginFactory {
 /**
  * When we send a control message from the plugin to the Wine VST host, this
  * encodes the information we request or the operation we want to perform. A
- * request of type `ControlRequest(T)` should send back a `T::Reponse`.
+ * request of type `ControlRequest(T)` should send back a `T::Response`.
  */
 using ControlRequest = std::variant<WantsPluginFactory>;
 
@@ -70,7 +70,7 @@ void serialize(S& s, ControlRequest& payload) {
 /**
  * When we do a callback from the Wine VST host to the plugin, this encodes the
  * information we want or the operation we want to perform. A request of type
- * `CallbackRequest(T)` should send back a `T::Reponse`.
+ * `CallbackRequest(T)` should send back a `T::Response`.
  */
 using CallbackRequest = std::variant<WantsConfiguration>;
 

src/plugin/bridges/vst3.cpp

@@ -78,13 +78,8 @@ Vst3PluginBridge::Vst3PluginBridge()
     host_callback_handler = std::jthread([&]() {
         sockets.vst_host_callback.receive_messages(
             std::pair<Vst3Logger&, bool>(logger, false),
-            [&](CallbackRequest request) -> auto {
-                return std::visit(overload{[&](const WantsConfiguration&)
-                                               -> WantsConfiguration::Response {
-                                      return config;
-                                  }},
-                                  request);
-            });
+            overload{[&](const WantsConfiguration&)
+                         -> WantsConfiguration::Response { return config; }});
     });
 
     // Set up the plugin factory, since this is the first thing the host will

src/wine-host/bridges/vst3.cpp

@@ -49,11 +49,9 @@ Vst3Bridge::Vst3Bridge(MainContext& main_context,
 
 void Vst3Bridge::run() {
     sockets.host_vst_control.receive_messages(
-        std::nullopt, [&](ControlRequest request) -> auto& {
-            return std::visit(overload{[&](const WantsPluginFactory&)
-                                           -> WantsPluginFactory::Response {
-                                  return *plugin_factory;
-                              }},
-                              request);
-        });
+        std::nullopt,
+        overload{
+            [&](const WantsPluginFactory&) -> WantsPluginFactory::Response {
+                return *plugin_factory;
+            }});
 }