Use auto trick to catch missing header files for auto_revoke (#1136)

Author: oldnewthing

cppwinrt/code_writers.h

@@ -1001,7 +1001,7 @@ namespace cppwinrt
         if (is_add_overload(method))
         {
             auto format = R"(        using %_revoker = impl::event_revoker<%, &impl::abi_t<%>::remove_%>;
-        [[nodiscard]] %_revoker %(auto_revoke_t, %) const;
+        [[nodiscard]] auto %(auto_revoke_t, %) const;
 )";
 
             w.write(format,
@@ -1010,7 +1010,6 @@ namespace cppwinrt
                 type,
                 method_name,
                 method_name,
-                method_name,
                 bind<write_consume_params>(signature));
         }
     }
@@ -1170,7 +1169,7 @@ namespace cppwinrt
 
         if (is_add_overload(method))
         {
-            format = R"(    template <typename D%> typename consume_%<D%>::%_revoker consume_%<D%>::%(auto_revoke_t, %) const
+            format = R"(    template <typename D%> auto consume_%<D%>::%(auto_revoke_t, %) const
     {
         return impl::make_event_revoker<D, %_revoker>(this, %(%));
     }
@@ -1181,9 +1180,6 @@ namespace cppwinrt
                 type_impl_name,
                 bind<write_comma_generic_types>(generics),
                 method_name,
-                type_impl_name,
-                bind<write_comma_generic_types>(generics),
-                method_name,
                 bind<write_consume_params>(signature),
                 method_name,
                 method_name,
@@ -1214,15 +1210,13 @@ namespace cppwinrt
 
         if (is_add_overload(method))
         {
-            format = R"(    inline %::%_revoker %::%(auto_revoke_t, %) const
+            format = R"(    inline auto %::%(auto_revoke_t, %) const
     {
         return impl::make_event_revoker<D, %_revoker>(this, %(%));
     }
 )";
 
             w.write(format,
-                class_type.TypeName(),
-                method_name,
                 class_type.TypeName(),
                 method_name,
                 bind<write_consume_params>(signature),
@@ -3017,7 +3011,7 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>
             if (is_add_overload(method))
             {
                 auto format = R"(        using %_revoker = impl::factory_event_revoker<%, &impl::abi_t<%>::remove_%>;
-        [[nodiscard]] static %_revoker %(auto_revoke_t, %);
+        [[nodiscard]] static auto %(auto_revoke_t, %);
 )";
 
                 w.write(format,
@@ -3026,7 +3020,6 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>
                     factory.second.type,
                     method_name,
                     method_name,
-                    method_name,
                     bind<write_consume_params>(signature));
             }
         }
@@ -3056,21 +3049,21 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>
 
         if (is_add_overload(method))
         {
-            auto format = R"(    inline %::%_revoker %::%(auto_revoke_t, %)
+            auto format = R"(    inline auto %::%(auto_revoke_t, %)
     {
         auto f = get_activation_factory<%, %>();
-        return { f, f.%(%) };
+        return %::%_revoker{ f, f.%(%) };
     }
 )";
 
             w.write(format,
-                type_name,
-                method_name,
                 type_name,
                 method_name,
                 bind<write_consume_params>(signature),
                 type_name,
                 factory,
+                type_name,
+                method_name,
                 method_name,
                 bind<write_consume_args>(signature));
         }

cppwinrt/component_writers.h

@@ -518,22 +518,22 @@ catch (...) { return winrt::to_hresult(); }
 
                     if (is_add_overload(method))
                     {
-                        auto format = R"(    %::%_revoker %::%(auto_revoke_t, %)
+                        auto format = R"(    auto %::%(auto_revoke_t, %)
     {
         auto f = make<winrt::@::factory_implementation::%>().as<%>();
-        return { f, f.%(%) };
+        return %::%_revoker{ f, f.%(%) };
     }
 )";
 
                         w.write(format,
-                            type_name,
-                            method_name,
                             type_name,
                             method_name,
                             bind<write_consume_params>(signature),
                             type_namespace,
                             type_name,
                             factory_name,
+                            type_name,
+                            method_name,
                             method_name,
                             bind<write_consume_args>(signature));
                     }