[libc++] Remove redundant __invoke_constexpr functions

[philnik]

Summary

There are constexpr versions for the different __invoke functions, which seem to be identical other than begin constexpr since C++11 instead of being constexpr since C++20.

[philnik]

• Make them all _LIBCPP_CONSTEXPR

[philnik]

• Replace _LIBCPP_CONSTEXPR with constexpr

[Mordante]

Looks like a nice cleanup to me, thanks!

libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp

274

Can we test this function as constexpr or is there other test coverage?

[ldionne]

This looks correct to me if CI is green, but I would like to see Mark's suggestion addressed.

[philnik]

• Address comments

[philnik]

• Try to fix CI

[philnik]

• Make test constexpr

[philnik]

Poke CI

libcxx/include/tuple

 
 #define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
 
 template <class _Fn, class _Tuple, size_t ..._Id>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
                                             __tuple_indices<_Id...>)
 _LIBCPP_NOEXCEPT_RETURN(
-    _VSTD::__invoke_constexpr(
+    _VSTD::__invoke(
         _VSTD::forward<_Fn>(__f),
         _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
 )
 
 template <class _Fn, class _Tuple>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
 _LIBCPP_NOEXCEPT_RETURN(

libcxx/include/type_traits

 
 // __invoke forward declarations
 
 // fall back - none of the bullets
 
 template <class ..._Args>
 auto __invoke(__any, _Args&& ...__args) -> __nat;
 
-template <class ..._Args>
-auto __invoke_constexpr(__any, _Args&& ...__args) -> __nat;
-
 // bullets 1, 2 and 3
 
 template <class _Fp, class _A0, class ..._Args,
           class = __enable_if_bullet1<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     noexcept(noexcept((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)))
     -> decltype(      (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...))
     { return          (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
 
 template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet1<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    noexcept(noexcept((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)))
-    -> decltype(      (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...))
-    { return          (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
-
-template <class _Fp, class _A0, class ..._Args,
           class = __enable_if_bullet2<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     noexcept(noexcept((__a0.get().*__f)(static_cast<_Args&&>(__args)...)))
     -> decltype(      (__a0.get().*__f)(static_cast<_Args&&>(__args)...))
     { return          (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
 
 template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet2<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    noexcept(noexcept((__a0.get().*__f)(static_cast<_Args&&>(__args)...)))
-    -> decltype(      (__a0.get().*__f)(static_cast<_Args&&>(__args)...))
-    { return          (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
-
-template <class _Fp, class _A0, class ..._Args,
           class = __enable_if_bullet3<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
     noexcept(noexcept(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)))
     -> decltype(      ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...))
     { return          ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
 
-template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet3<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
-    noexcept(noexcept(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)))
-    -> decltype(      ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...))
-    { return          ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
-
 // bullets 4, 5 and 6
 
 template <class _Fp, class _A0,
           class = __enable_if_bullet4<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0)
     noexcept(noexcept(static_cast<_A0&&>(__a0).*__f))
     -> decltype(      static_cast<_A0&&>(__a0).*__f)
     { return          static_cast<_A0&&>(__a0).*__f; }
 
 template <class _Fp, class _A0,
-          class = __enable_if_bullet4<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0)
-    noexcept(noexcept(static_cast<_A0&&>(__a0).*__f))
-    -> decltype(      static_cast<_A0&&>(__a0).*__f)
-    { return          static_cast<_A0&&>(__a0).*__f; }
-
-template <class _Fp, class _A0,
           class = __enable_if_bullet5<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0)
     noexcept(noexcept(__a0.get().*__f))
     -> decltype(      __a0.get().*__f)
     { return          __a0.get().*__f; }
 
 template <class _Fp, class _A0,
-          class = __enable_if_bullet5<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0)
-    noexcept(noexcept(__a0.get().*__f))
-    -> decltype(      __a0.get().*__f)
-    { return          __a0.get().*__f; }
-
-template <class _Fp, class _A0,
           class = __enable_if_bullet6<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _A0&& __a0)
     noexcept(noexcept((*static_cast<_A0&&>(__a0)).*__f))
     -> decltype(      (*static_cast<_A0&&>(__a0)).*__f)
     { return          (*static_cast<_A0&&>(__a0)).*__f; }
 
-template <class _Fp, class _A0,
-          class = __enable_if_bullet6<_Fp, _A0>>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _A0&& __a0)
-    noexcept(noexcept((*static_cast<_A0&&>(__a0)).*__f))
-    -> decltype(      (*static_cast<_A0&&>(__a0)).*__f)
-    { return          (*static_cast<_A0&&>(__a0)).*__f; }
-
 // bullet 7
 
 template <class _Fp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
+constexpr auto
 __invoke(_Fp&& __f, _Args&& ...__args)
     noexcept(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
     -> decltype(      static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...))
     { return          static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
 
-template <class _Fp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR auto
-__invoke_constexpr(_Fp&& __f, _Args&& ...__args)
-    noexcept(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
-    -> decltype(      static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...))
-    { return          static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
-
 // __invokable
 template <class _Ret, class _Fp, class ..._Args>
 struct __invokable_r
 {
   template <class _XFp, class ..._XArgs>
   static auto __try_call(int) -> decltype(
     _VSTD::__invoke(declval<_XFp>(), declval<_XArgs>()...));
   template <class _XFp, class ..._XArgs>

libcxx/include/variant

static constexpr auto __make_farray(_Fs&&... __fs) {
     return __result{{_VSTD::forward<_Fs>(__fs)...}};
   }
 
   template <size_t... _Is>
   struct __dispatcher {
     template <class _Fp, class... _Vs>
     inline _LIBCPP_INLINE_VISIBILITY
     static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
-        return _VSTD::__invoke_constexpr(
+        return _VSTD::__invoke(
             static_cast<_Fp>(__f),
             __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
     }
   };
 
   template <class _Fp, class... _Vs, size_t... _Is>
   inline _LIBCPP_INLINE_VISIBILITY
   static constexpr auto __make_dispatch(index_sequence<_Is...>) {
private:
   template <class _Visitor>
   struct __value_visitor {
     template <class... _Alts>
     inline _LIBCPP_INLINE_VISIBILITY
     constexpr decltype(auto) operator()(_Alts&&... __alts) const {
       __std_visit_exhaustive_visitor_check<
           _Visitor,
           decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
-      return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
-                                _VSTD::forward<_Alts>(__alts).__value...);
+      return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
     }
     _Visitor&& __visitor;
   };
 
 #if _LIBCPP_STD_VER > 17
   template <class _Rp, class _Visitor>
   struct __value_visitor_return_type {
     template <class... _Alts>
     inline _LIBCPP_INLINE_VISIBILITY
     constexpr _Rp operator()(_Alts&&... __alts) const {
       __std_visit_exhaustive_visitor_check<
           _Visitor,
           decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
       if constexpr (is_void_v<_Rp>) {
-        _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
-                                  _VSTD::forward<_Alts>(__alts).__value...);
+        _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
       }
       else {
-        return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
-                                         _VSTD::forward<_Alts>(__alts).__value...);
+        return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
       }
     }
 
     _Visitor&& __visitor;
   };
 #endif
 
   template <class _Visitor>

libcxx/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp

 };
 
 template <class Sig, int Arity, class CV>
 struct TestCase : public TestCaseImp<MemFun03, Sig, Arity, CV> {};
 
 #if TEST_STD_VER >= 11
 template <class Sig, int Arity, class CV, bool RValue = false>
 struct TestCase11 : public TestCaseImp<MemFun11, Sig, Arity, CV, RValue, true> {};
-#endif
+
+template <class Type>
+struct ReferenceWrapper {
+    using type = Type;
+    Type* ptr;
+
+    static void fun(Type&) noexcept;
+    static void fun(Type&&) = delete;
+
+    template <class Type2,
+              class = typename std::enable_if<!std::__is_same_uncvref<Type2, ReferenceWrapper>::value>::type>
+    constexpr ReferenceWrapper(Type2&& t) noexcept : ptr(&t) {}
+
+    constexpr Type& get() const noexcept { return *ptr; }
+    constexpr operator Type&() const noexcept { return *ptr; }
+
+    template <class... _ArgTypes>
+    constexpr typename std::__invoke_of<Type&, _ArgTypes...>::type operator() (_ArgTypes&&... __args) const {
+        return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
+    }
+};
 
 template <class Tp>
-struct DerivedFromRefWrap : public std::reference_wrapper<Tp> {
-  DerivedFromRefWrap(Tp& tp) : std::reference_wrapper<Tp>(tp) {}
+struct DerivedFromRefWrap : public ReferenceWrapper<Tp> {
+  constexpr DerivedFromRefWrap(Tp& tp) : ReferenceWrapper<Tp>(tp) {}
 };
 
-#if TEST_STD_VER >= 11
-void test_derived_from_ref_wrap() {
+TEST_CONSTEXPR_CXX14 bool test_derived_from_ref_wrap() {
     int x = 42;
-    std::reference_wrapper<int> r(x);
-    std::reference_wrapper<std::reference_wrapper<int>> r2(r);
+    ReferenceWrapper<int> r(x);
     DerivedFromRefWrap<int> d(x);
-    auto get_fn = &std::reference_wrapper<int>::get;
+    auto get_fn = &ReferenceWrapper<int>::get;
     auto& ret = std::__invoke(get_fn, r);
-    auto& cret = std::__invoke_constexpr(get_fn, r);
     assert(&ret == &x);
-    assert(&cret == &x);
     auto& ret2 = std::__invoke(get_fn, d);
-    auto& cret2 = std::__invoke_constexpr(get_fn, d);
     assert(&ret2 == &x);
-    assert(&cret2 == &x);
+
+    return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test_reference_wrapper_reference_wrapper() {
+    int x = 42;
+    auto get_fn = &std::reference_wrapper<int>::get;
+    std::reference_wrapper<int> r(x);
+    std::reference_wrapper<std::reference_wrapper<int>> r2(r);
     auto& ret3 = std::__invoke(get_fn, r2);
     assert(&ret3 == &x);
+
+    return true;
 }
 #endif
 
 int main(int, char**) {
     typedef void*& R;
     typedef ArgType A;
     TestCase<R(),                                   0, Q_None>::run();
     TestCase<R() const,                             0, Q_Const>::run();
#if TEST_STD_VER >= 11
     TestCase11<R(A&&, A&&, A&&) volatile &&,        3, Q_Volatile, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&) const volatile &&,  3, Q_CV, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  &&,                 3, Q_None, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  const &&,           3, Q_Const, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  volatile &&,        3, Q_Volatile, /* RValue */ true>::run();
     TestCase11<R(A&&, A&&, A&&, ...)  const volatile &&,  3, Q_CV, /* RValue */ true>::run();
 
     test_derived_from_ref_wrap();
+    test_reference_wrapper_reference_wrapper();
+#if TEST_STD_VER > 11
+    static_assert(test_derived_from_ref_wrap(), "");
 #endif
+#if TEST_STD_VER > 17
+    static_assert(test_reference_wrapper_reference_wrapper(), "");
+#endif
+#endif // TEST_STD_VER >= 11
 
   return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp

 #endif
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(M, std::forward<T>(obj))), Expect
               >::value), "");
             Expect e = std::__invoke(M, std::forward<T>(obj));
             assert(&e == expect);
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(M, std::forward<T>(obj))), Expect
-              >::value), "");
-            Expect e = std::__invoke_constexpr(M, std::forward<T>(obj));
-            assert(&e == expect);
-        }
-#endif
     }
 };
 
-
-
-
 int main(int, char**) {
     TestCase<ArgType>::run();
     TestCase<ArgType const>::run();
     TestCase<ArgType volatile>::run();
     TestCase<ArgType const volatile>::run();
     TestCase<ArgType*>::run();
 
   return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h

void runTestImp(Int<0>, MethodPtr ptr, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(ptr, object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(ptr, object_cast(object)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<1>, MethodPtr ptr, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<2>, MethodPtr ptr, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class MethodPtr, class ObjectT>
     void runTestImp(Int<3>, MethodPtr ptr, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     //==========================================================================
     //                       BULLET 7 TEST METHODS
     //==========================================================================
     template <class ObjectT>
     void runTestImp(Int<0>, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(object_cast(object));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(object_cast(object)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(object_cast(object));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<1>, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<2>, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 
     template <class ObjectT>
     void runTestImp(Int<3>, ObjectT& object) {
         {
             static_assert((std::is_same<
                 decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
               , CallRet>::value), "");
             assert(ID::unchecked_call == false);
             CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
             assert(ID::checkCalled(ret));
         }
-#if TEST_STD_VER >= 11
-        {
-            static_assert((std::is_same<
-                decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
-              , CallRet>::value), "");
-            assert(ID::unchecked_call == false);
-            CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
-            assert(ID::checkCalled(ret));
-        }
-#endif
     }
 };
 
 #endif // INVOKE_HELPERS_H