Shorthand for trailing return type, noexcept, and single-return-statement

Author: vector-of-bool

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp

@@ -67,6 +67,9 @@
 #undef BSONCXX_UNREACHABLE
 #pragma pop_macro("BSONCXX_UNREACHABLE")
 
+#pragma pop_macro("mongo_cxx14_constexpr")
+#pragma pop_macro("bsoncxx_returns")
+
 // CXX-2769: out-of-place, but remains for backward compatibility.
 #ifdef BSONCXX_ENUM
 static_assert(false, "BSONCXX_ENUM must be undef'ed");

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp

@@ -90,3 +90,20 @@
 /// @namespace bsoncxx::v_noabi::stdx
 /// Declares polyfills for C++17 forward compatibility.
 ///
+
+#pragma push_macro("mongo_cxx14_constexpr")
+#if __cplusplus >= 201402L
+#define mongo_cxx14_constexpr constexpr
+#else
+#define mongo_cxx14_constexpr inline
+#endif
+
+#pragma push_macro("bsoncxx_returns")
+/**
+ * @brief Add a trailing noexcept, decltype-return, and return-body to a function definition.
+ */
+#define bsoncxx_returns(...)                                 \
+    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
+        return __VA_ARGS__;                                  \
+    }                                                        \
+    static_assert(true, "")

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp

@@ -344,31 +344,25 @@ using requires_not_t = requires_t<Type, negation<disjunction<Traits...>>>;
 // Impl: invoke/is_invocable
 namespace impl_invoke {
 
-#pragma push_macro("RETURNS")
-#define RETURNS(...)                                         \
-    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
-        return __VA_ARGS__;                                  \
-    }                                                        \
-    static_assert(true, "")
-
 template <bool IsMemberObject, bool IsMemberFunction>
 struct invoker {
     template <typename F, typename... Args>
     constexpr static auto apply(F&& fun, Args&&... args)
-        RETURNS(static_cast<F&&>(fun)(static_cast<Args&&>(args)...));
+        bsoncxx_returns(static_cast<F&&>(fun)(static_cast<Args&&>(args)...));
 };
 
 template <>
 struct invoker<false, true> {
     template <typename F, typename Self, typename... Args>
     constexpr static auto apply(F&& fun, Self&& self, Args&&... args)
-        RETURNS((static_cast<Self&&>(self).*fun)(static_cast<Args&&>(args)...));
+        bsoncxx_returns((static_cast<Self&&>(self).*fun)(static_cast<Args&&>(args)...));
 };
 
 template <>
 struct invoker<true, false> {
     template <typename F, typename Self>
-    constexpr static auto apply(F&& fun, Self&& self) RETURNS(static_cast<Self&&>(self).*fun);
+    constexpr static auto apply(F&& fun, Self&& self)
+        bsoncxx_returns(static_cast<Self&&>(self).*fun);
 };
 
 }  // namespace impl_invoke
@@ -383,13 +377,11 @@ static constexpr struct invoke_fn {
 
     template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
     constexpr auto operator()(F&& fn, Args&&... args) const
-        RETURNS(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value,
-                                     std::is_member_function_pointer<Fd>::value>  //
-                ::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));
+        bsoncxx_returns(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value,
+                                             std::is_member_function_pointer<Fd>::value>  //
+                        ::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));
 } invoke;
 
-#pragma pop_macro("RETURNS")
-
 /**
  * @brief Yields the type that would result from invoking F with the given arguments.
  *