Implement support for noexcept overridable methods (#910)

sylveon · web-flow · commit 464e59198c20 · 2021-04-01T05:57:58.000-07:00
diff --git a/cppwinrt/code_writers.h b/cppwinrt/code_writers.h
@@ -1905,7 +1905,7 @@ namespace cppwinrt
 
     static void write_dispatch_overridable_method(writer& w, MethodDef const& method)
     {
-        auto format = R"(    auto %(%)
+        auto format = R"(    auto %(%)%
     {
         if (auto overridable = this->shim_overridable())
         {
@@ -1921,6 +1921,7 @@ namespace cppwinrt
         w.write(format,
             get_name(method),
             bind<write_implementation_params>(signature),
+            is_noexcept(method) ? " noexcept" : "",
             get_name(method),
             bind<write_consume_args>(signature),
             get_name(method),
@@ -1950,7 +1951,7 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>
 
     static void write_interface_override_method(writer& w, MethodDef const& method, std::string_view const& interface_name)
     {
-        auto format = R"(    template <typename D> WINRT_IMPL_AUTO(%) %T<D>::%(%) const
+        auto format = R"(    template <typename D> WINRT_IMPL_AUTO(%) %T<D>::%(%) const%
     {
         return shim().template try_as<%>().%(%);
     }
@@ -1964,6 +1965,7 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>
             interface_name,
             method_name,
             bind<write_consume_params>(signature),
+            is_noexcept(method) ? " noexcept" : "",
             interface_name,
             method_name,
             bind<write_consume_args>(signature));
diff --git a/test/old_tests/Composable/Base.cpp b/test/old_tests/Composable/Base.cpp
@@ -21,6 +21,11 @@ namespace winrt::Composable::implementation
         return overridable().OverridableVirtualMethod();
     }
 
+    int32_t Base::CallOverridableNoexceptMethod() noexcept
+    {
+        return overridable().OverridableNoexceptMethod();
+    }
+
     hstring Base::OverridableMethod()
     {
         return L"Base::OverridableMethod";
@@ -31,6 +36,11 @@ namespace winrt::Composable::implementation
         return L"Base::OverridableVirtualMethod";
     }
 
+    int32_t Base::OverridableNoexceptMethod() noexcept
+    {
+        return 42;
+    }
+
     hstring Base::Name() const
     {
         return m_name;
diff --git a/test/old_tests/Composable/Base.h b/test/old_tests/Composable/Base.h
@@ -14,8 +14,10 @@ namespace winrt::Composable::implementation
         virtual hstring VirtualMethod();
         hstring CallOverridableMethod();
         hstring CallOverridableVirtualMethod();
+        int32_t CallOverridableNoexceptMethod() noexcept;
         hstring OverridableMethod() ;
         virtual hstring OverridableVirtualMethod();
+        int32_t OverridableNoexceptMethod() noexcept;
 
         hstring Name() const;
 
diff --git a/test/old_tests/Composable/Composable.idl b/test/old_tests/Composable/Composable.idl
@@ -1,5 +1,14 @@
 import "Windows.Foundation.idl";
 
+namespace Windows.Foundation.Metadata
+{
+    [attributeusage(target_method, target_property)]
+    [attributename("noexcept2")]
+    attribute NoExceptionAttribute
+    {
+    }
+}
+
 namespace Composable
 {
     runtimeclass Base;
@@ -11,6 +20,7 @@ namespace Composable
         HRESULT VirtualMethod([out, retval] HSTRING* value);
         HRESULT CallOverridableMethod([out, retval] HSTRING* value);
         HRESULT CallOverridableVirtualMethod([out, retval] HSTRING* value);
+        [noexcept2] HRESULT CallOverridableNoexceptMethod([out, retval] int* value);
 
         [propget] HRESULT Name([out, retval] HSTRING* value);
     };
@@ -27,6 +37,7 @@ namespace Composable
     {
         HRESULT OverridableMethod([out, retval] HSTRING* value);
         HRESULT OverridableVirtualMethod([out, retval] HSTRING* value);
+        [noexcept2] HRESULT OverridableNoexceptMethod([out, retval] int* value);
     };
     
     [version(1.0), uuid(5f3996e1-3cf7-4716-9a3d-11eb5d32caff), exclusiveto(Derived)]
diff --git a/test/old_tests/UnitTests/Composable.cpp b/test/old_tests/UnitTests/Composable.cpp
@@ -13,12 +13,14 @@ namespace
     constexpr auto Base_VirtualMethod{ L"Base::VirtualMethod"sv };
     constexpr auto Base_OverridableMethod{ L"Base::OverridableMethod"sv };
     constexpr auto Base_OverridableVirtualMethod{ L"Base::OverridableVirtualMethod"sv };
+    constexpr auto Base_OverridableNoexceptMethod{ 42 };
 
     constexpr auto Derived_VirtualMethod{ L"Derived::VirtualMethod"sv };
     constexpr auto Derived_OverridableVirtualMethod{ L"Derived::OverridableVirtualMethod"sv };
 
     constexpr auto OverriddenBase_OverridableMethod{ L"OverriddenBase::OverridableMethod"sv };
     constexpr auto OverriddenBase_OverridableVirtualMethod{ L"OverriddenBase::OverridableVirtualMethod"sv };
+    constexpr auto OverriddenBase_OverridableNoexceptMethod{ 1337 };
 }
 
 TEST_CASE("Composable.Base")
@@ -27,6 +29,7 @@ TEST_CASE("Composable.Base")
     REQUIRE(base.VirtualMethod() == Base_VirtualMethod);
     REQUIRE(base.CallOverridableMethod() == Base_OverridableMethod);
     REQUIRE(base.CallOverridableVirtualMethod() == Base_OverridableVirtualMethod);
+    REQUIRE(base.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);
 }
 
 TEST_CASE("Composable.OverriddenBase")
@@ -39,6 +42,7 @@ TEST_CASE("Composable.OverriddenBase")
         REQUIRE(object.VirtualMethod() == Base_VirtualMethod);
         REQUIRE(object.CallOverridableMethod() == Base_OverridableMethod);
         REQUIRE(object.CallOverridableVirtualMethod() == Base_OverridableVirtualMethod);
+        REQUIRE(object.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);
     }
     {
         struct OverriddenBase : BaseT<OverriddenBase>
@@ -52,15 +56,22 @@ TEST_CASE("Composable.OverriddenBase")
             {
                 return hstring(OverriddenBase_OverridableVirtualMethod);
             }
+
+            int32_t OverridableNoexceptMethod() const noexcept
+            {
+                return OverriddenBase_OverridableNoexceptMethod;
+            }
         };
         auto object = make<OverriddenBase>();
         REQUIRE(object.VirtualMethod() == Base_VirtualMethod);
         REQUIRE(object.CallOverridableMethod() == OverriddenBase_OverridableMethod);
         REQUIRE(object.CallOverridableVirtualMethod() == OverriddenBase_OverridableVirtualMethod);
+        REQUIRE(object.CallOverridableNoexceptMethod() == OverriddenBase_OverridableNoexceptMethod);
     }
     {
         const std::wstring OverridableMethodResult = std::wstring(OverriddenBase_OverridableMethod) + L"=>" + Base_OverridableMethod.data();
         const std::wstring OverridableVirtualMethodResult = std::wstring(OverriddenBase_OverridableVirtualMethod) + L"=>" + Base_OverridableVirtualMethod.data();
+        const int32_t OverridableNoexceptMethodResult = OverriddenBase_OverridableNoexceptMethod + Base_OverridableNoexceptMethod;
 
         struct OverriddenBase : BaseT<OverriddenBase>
         {
@@ -73,11 +84,17 @@ TEST_CASE("Composable.OverriddenBase")
             {
                 return OverriddenBase_OverridableVirtualMethod + L"=>" + BaseT<OverriddenBase>::OverridableVirtualMethod();
             }
+
+            int32_t OverridableNoexceptMethod() const noexcept
+            {
+                return OverriddenBase_OverridableNoexceptMethod + BaseT<OverriddenBase>::OverridableNoexceptMethod();
+            }
         };
         auto object = make<OverriddenBase>();
         REQUIRE(object.VirtualMethod() == Base_VirtualMethod);
         REQUIRE(object.CallOverridableMethod() == OverridableMethodResult);
         REQUIRE(object.CallOverridableVirtualMethod() == OverridableVirtualMethodResult);
+        REQUIRE(object.CallOverridableNoexceptMethod() == OverridableNoexceptMethodResult);
     }
 }
 
@@ -88,6 +105,7 @@ TEST_CASE("Composable.Derived")
     REQUIRE(obj.VirtualMethod() == Derived_VirtualMethod);
     REQUIRE(obj.CallOverridableMethod() == Base_OverridableMethod);
     REQUIRE(obj.CallOverridableVirtualMethod() == Derived_OverridableVirtualMethod);
+    REQUIRE(obj.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);
 }
 
 namespace

Original file line number	Diff line number	Diff line change
`@@ -1905,7 +1905,7 @@ namespace cppwinrt`
`1905`	`1905`
`1906`	`1906`	`static void write_dispatch_overridable_method(writer& w, MethodDef const& method)`
`1907`	`1907`	`{`
`1908`		`- auto format = R"( auto %(%)`
	`1908`	`+ auto format = R"( auto %(%)%`
`1909`	`1909`	`{`
`1910`	`1910`	`if (auto overridable = this->shim_overridable())`
`1911`	`1911`	`{`
`@@ -1921,6 +1921,7 @@ namespace cppwinrt`
`1921`	`1921`	`w.write(format,`
`1922`	`1922`	`get_name(method),`
`1923`	`1923`	`bind<write_implementation_params>(signature),`
	`1924`	`+ is_noexcept(method) ? " noexcept" : "",`
`1924`	`1925`	`get_name(method),`
`1925`	`1926`	`bind<write_consume_args>(signature),`
`1926`	`1927`	`get_name(method),`
`@@ -1950,7 +1951,7 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>`
`1950`	`1951`
`1951`	`1952`	`static void write_interface_override_method(writer& w, MethodDef const& method, std::string_view const& interface_name)`
`1952`	`1953`	`{`
`1953`		`- auto format = R"( template <typename D> WINRT_IMPL_AUTO(%) %T<D>::%(%) const`
	`1954`	`+ auto format = R"( template <typename D> WINRT_IMPL_AUTO(%) %T<D>::%(%) const%`
`1954`	`1955`	`{`
`1955`	`1956`	`return shim().template try_as<%>().%(%);`
`1956`	`1957`	`}`
`@@ -1964,6 +1965,7 @@ struct __declspec(empty_bases) produce_dispatch_to_overridable<T, D, %>`
`1964`	`1965`	`interface_name,`
`1965`	`1966`	`method_name,`
`1966`	`1967`	`bind<write_consume_params>(signature),`
	`1968`	`+ is_noexcept(method) ? " noexcept" : "",`
`1967`	`1969`	`interface_name,`
`1968`	`1970`	`method_name,`
`1969`	`1971`	`bind<write_consume_args>(signature));`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,11 @@ namespace winrt::Composable::implementation`
`21`	`21`	`return overridable().OverridableVirtualMethod();`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ int32_t Base::CallOverridableNoexceptMethod() noexcept`
	`25`	`+ {`
	`26`	`+ return overridable().OverridableNoexceptMethod();`
	`27`	`+ }`
	`28`	`+`
`24`	`29`	`hstring Base::OverridableMethod()`
`25`	`30`	`{`
`26`	`31`	`return L"Base::OverridableMethod";`
`@@ -31,6 +36,11 @@ namespace winrt::Composable::implementation`
`31`	`36`	`return L"Base::OverridableVirtualMethod";`
`32`	`37`	`}`
`33`	`38`
	`39`	`+ int32_t Base::OverridableNoexceptMethod() noexcept`
	`40`	`+ {`
	`41`	`+ return 42;`
	`42`	`+ }`
	`43`	`+`
`34`	`44`	`hstring Base::Name() const`
`35`	`45`	`{`
`36`	`46`	`return m_name;`
Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,14 @@ namespace`
`13`	`13`	`constexpr auto Base_VirtualMethod{ L"Base::VirtualMethod"sv };`
`14`	`14`	`constexpr auto Base_OverridableMethod{ L"Base::OverridableMethod"sv };`
`15`	`15`	`constexpr auto Base_OverridableVirtualMethod{ L"Base::OverridableVirtualMethod"sv };`
	`16`	`+ constexpr auto Base_OverridableNoexceptMethod{ 42 };`
`16`	`17`
`17`	`18`	`constexpr auto Derived_VirtualMethod{ L"Derived::VirtualMethod"sv };`
`18`	`19`	`constexpr auto Derived_OverridableVirtualMethod{ L"Derived::OverridableVirtualMethod"sv };`
`19`	`20`
`20`	`21`	`constexpr auto OverriddenBase_OverridableMethod{ L"OverriddenBase::OverridableMethod"sv };`
`21`	`22`	`constexpr auto OverriddenBase_OverridableVirtualMethod{ L"OverriddenBase::OverridableVirtualMethod"sv };`
	`23`	`+ constexpr auto OverriddenBase_OverridableNoexceptMethod{ 1337 };`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`TEST_CASE("Composable.Base")`
`@@ -27,6 +29,7 @@ TEST_CASE("Composable.Base")`
`27`	`29`	`REQUIRE(base.VirtualMethod() == Base_VirtualMethod);`
`28`	`30`	`REQUIRE(base.CallOverridableMethod() == Base_OverridableMethod);`
`29`	`31`	`REQUIRE(base.CallOverridableVirtualMethod() == Base_OverridableVirtualMethod);`
	`32`	`+ REQUIRE(base.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);`
`30`	`33`	`}`
`31`	`34`
`32`	`35`	`TEST_CASE("Composable.OverriddenBase")`
`@@ -39,6 +42,7 @@ TEST_CASE("Composable.OverriddenBase")`
`39`	`42`	`REQUIRE(object.VirtualMethod() == Base_VirtualMethod);`
`40`	`43`	`REQUIRE(object.CallOverridableMethod() == Base_OverridableMethod);`
`41`	`44`	`REQUIRE(object.CallOverridableVirtualMethod() == Base_OverridableVirtualMethod);`
	`45`	`+ REQUIRE(object.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);`
`42`	`46`	`}`
`43`	`47`	`{`
`44`	`48`	`struct OverriddenBase : BaseT<OverriddenBase>`
`@@ -52,15 +56,22 @@ TEST_CASE("Composable.OverriddenBase")`
`52`	`56`	`{`
`53`	`57`	`return hstring(OverriddenBase_OverridableVirtualMethod);`
`54`	`58`	`}`
	`59`	`+`
	`60`	`+ int32_t OverridableNoexceptMethod() const noexcept`
	`61`	`+ {`
	`62`	`+ return OverriddenBase_OverridableNoexceptMethod;`
	`63`	`+ }`
`55`	`64`	`};`
`56`	`65`	`auto object = make<OverriddenBase>();`
`57`	`66`	`REQUIRE(object.VirtualMethod() == Base_VirtualMethod);`
`58`	`67`	`REQUIRE(object.CallOverridableMethod() == OverriddenBase_OverridableMethod);`
`59`	`68`	`REQUIRE(object.CallOverridableVirtualMethod() == OverriddenBase_OverridableVirtualMethod);`
	`69`	`+ REQUIRE(object.CallOverridableNoexceptMethod() == OverriddenBase_OverridableNoexceptMethod);`
`60`	`70`	`}`
`61`	`71`	`{`
`62`	`72`	`const std::wstring OverridableMethodResult = std::wstring(OverriddenBase_OverridableMethod) + L"=>" + Base_OverridableMethod.data();`
`63`	`73`	`const std::wstring OverridableVirtualMethodResult = std::wstring(OverriddenBase_OverridableVirtualMethod) + L"=>" + Base_OverridableVirtualMethod.data();`
	`74`	`+ const int32_t OverridableNoexceptMethodResult = OverriddenBase_OverridableNoexceptMethod + Base_OverridableNoexceptMethod;`
`64`	`75`
`65`	`76`	`struct OverriddenBase : BaseT<OverriddenBase>`
`66`	`77`	`{`
`@@ -73,11 +84,17 @@ TEST_CASE("Composable.OverriddenBase")`
`73`	`84`	`{`
`74`	`85`	`return OverriddenBase_OverridableVirtualMethod + L"=>" + BaseT<OverriddenBase>::OverridableVirtualMethod();`
`75`	`86`	`}`
	`87`	`+`
	`88`	`+ int32_t OverridableNoexceptMethod() const noexcept`
	`89`	`+ {`
	`90`	`+ return OverriddenBase_OverridableNoexceptMethod + BaseT<OverriddenBase>::OverridableNoexceptMethod();`
	`91`	`+ }`
`76`	`92`	`};`
`77`	`93`	`auto object = make<OverriddenBase>();`
`78`	`94`	`REQUIRE(object.VirtualMethod() == Base_VirtualMethod);`
`79`	`95`	`REQUIRE(object.CallOverridableMethod() == OverridableMethodResult);`
`80`	`96`	`REQUIRE(object.CallOverridableVirtualMethod() == OverridableVirtualMethodResult);`
	`97`	`+ REQUIRE(object.CallOverridableNoexceptMethod() == OverridableNoexceptMethodResult);`
`81`	`98`	`}`
`82`	`99`	`}`
`83`	`100`
`@@ -88,6 +105,7 @@ TEST_CASE("Composable.Derived")`
`88`	`105`	`REQUIRE(obj.VirtualMethod() == Derived_VirtualMethod);`
`89`	`106`	`REQUIRE(obj.CallOverridableMethod() == Base_OverridableMethod);`
`90`	`107`	`REQUIRE(obj.CallOverridableVirtualMethod() == Derived_OverridableVirtualMethod);`
	`108`	`+ REQUIRE(obj.CallOverridableNoexceptMethod() == Base_OverridableNoexceptMethod);`
`91`	`109`	`}`
`92`	`110`
`93`	`111`	`namespace`