[libc++] [P1065] Constexpr invoke, reference_wrapper, mem_fn, not_fn.

[• Quuxplusone]

Summary

I believe this is a complete implementation of P1065R2 "Constexpr INVOKE" (Tomasz Kamiński, Barry Revzin), which was adopted for C++20.
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1065r2.html

This could use more constexpr tests for std::reference_wrapper<T>, but the existing tests are extremely constexpr-unfriendly and so I don't want to get into that rabbit-hole today.

I plan to push the refactoring of ForwardingCallObject as a separate preliminary commit:

[libc++] Constexpr-proof some machinery in not_fn.pass.cpp. NFCI.

[• Quuxplusone]

Complete the implementation of __cpp_lib_constexpr_functional and set that feature macro. This involves constexprifying std::default_searcher from P1032 "Misc constexpr bits". There's more "misc" stuff in P1032, which I have not attempted to do in this PR because it doesn't affect the __cpp_lib_constexpr_functional feature macro.

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations#library-feature-test-macros

[zoecarver]

This LGTM. Thanks. Looking forward to using this in my bind_front patch ;)

libcxx/test/std/utilities/function.objects/func.invoke/invoke_constexpr.pass.cpp

269

I assume it didn't make sense to merge these with the existing tests because of functions like foo which would only work in one mode or the other?

Is there any test coverage here that isn't in the non-constexpr version? If so, would it make sense to run these tests outside of a constexpr context as well (it very well might not)?

libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

548

This is just because std::string isn't constexpr?

[• Quuxplusone]

libcxx/test/std/utilities/function.objects/func.invoke/invoke_constexpr.pass.cpp

269

A mix of that reason, and the reason that I wanted to make sure constexprifying things didn't somehow break the non-constexpr codepath. One thing we haven't been worrying about much with these patches, and which I suddenly decided to worry about for this patch (why? I don't know) is that when we mark all the helper/component functions like foo with TEST_CONSTEXPR_CXX20, we are losing test coverage of how the thing works with non-constexpr functions. For invoke, that suddenly seemed important to test.

There is no test coverage here that isn't in the non-constexpr version. I suppose it wouldn't hurt to run these tests also outside of constexpr; I'll add that.

libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

548

Correct. The obj it's calling is actually callable with auto..., so it doesn't matter what types we pass to it. I don't know the original author's motivation for using std::string here; probably just it seemed convenient at the time.

I considered removing all this file's usage of <string>, but it seemed like an unnecessary rabbit hole at the moment.

[• Quuxplusone]

Run constexpr tests also in non-constexpr mode. Rebase on main.

[• Quuxplusone]

Poke the buildbot. (It's been stuck in "pre-merge checks" for 10 hours.)

[• Quuxplusone]

Fix a failing test (don't put constexpr on non-const methods in C++11).
If buildkite is green after this, imma push it.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P0553 <https://wg21.link/P0553>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631 <https://wg21.link/P0631>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645 <https://wg21.link/P0645>`__","LWG","Text Formatting","Cologne","",""
 "`P0660 <https://wg21.link/P0660>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784 <https://wg21.link/P0784>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980 <https://wg21.link/P0980>`__","LWG","Making std::string constexpr","Cologne","",""
 "`P1004 <https://wg21.link/P1004>`__","LWG","Making std::vector constexpr","Cologne","",""
 "`P1035 <https://wg21.link/P1035>`__","LWG","Input Range Adaptors","Cologne","",""
-"`P1065 <https://wg21.link/P1065>`__","LWG","Constexpr INVOKE","Cologne","",""
+"`P1065 <https://wg21.link/P1065>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135 <https://wg21.link/P1135>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207 <https://wg21.link/P1207>`__","LWG","Movability of Single-pass Iterators","Cologne","",""
 "`P1208 <https://wg21.link/P1208>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355 <https://wg21.link/P1355>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361 <https://wg21.link/P1361>`__","LWG","Integration of chrono with text formatting","Cologne","",""
 "`P1423 <https://wg21.link/P1423>`__","LWG","char8_t backward compatibility remediation","Cologne","|In Progress|",""
 "`P1424 <https://wg21.link/P1424>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""
 "`P1466 <https://wg21.link/P1466>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_bit_cast``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_misc``                      *unimplemented*
+    ``__cpp_lib_constexpr_functional``                ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_numeric``                   ``201911L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_utility``                   ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_destroying_delete``                   ``201806L``

libcxx/include/__functional_base

 public:
     // types
     typedef _Tp type;
 private:
     type* __f_;
 
 public:
     // construct/copy/destroy
-    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    reference_wrapper(type& __f) _NOEXCEPT
         : __f_(_VSTD::addressof(__f)) {}
 #ifndef _LIBCPP_CXX03_LANG
     private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
 #endif
 
     // access
-    _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
-    _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    operator type&    () const _NOEXCEPT {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    type& get() const _NOEXCEPT {return *__f_;}
 
 #ifndef _LIBCPP_CXX03_LANG
     // invoke
     template <class... _ArgTypes>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     typename __invoke_of<type&, _ArgTypes...>::type
     operator() (_ArgTypes&&... __args) const {
         return _VSTD::__invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
     }
 #else
 
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return<type>::type
#else
     operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
         return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 #endif // _LIBCPP_CXX03_LANG
 };
 
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 reference_wrapper<_Tp>
 ref(_Tp& __t) _NOEXCEPT
 {
     return reference_wrapper<_Tp>(__t);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 reference_wrapper<_Tp>
 ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 {
     return _VSTD::ref(__t.get());
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 reference_wrapper<const _Tp>
 cref(const _Tp& __t) _NOEXCEPT
 {
     return reference_wrapper<const _Tp>(__t);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 reference_wrapper<const _Tp>
 cref(reference_wrapper<_Tp> __t) _NOEXCEPT
 {
     return _VSTD::cref(__t.get());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp> void ref(const _Tp&&) = delete;

libcxx/include/functional

public:
     explicit binary_negate(const Predicate& pred);
     bool operator()(const typename Predicate::first_argument_type& x,
                     const typename Predicate::second_argument_type& y) const;
 };
 
 template <class Predicate> // deprecated in C++17
 binary_negate<Predicate> not2(const Predicate& pred);
 
-template <class F> unspecified not_fn(F&& f); // C++17
+template <class F>
+constexpr unspecified not_fn(F&& f); // C++17, constexpr in C++20
 
 template<class T> struct is_bind_expression;
 template<class T> struct is_placeholder;
 
     // See C++14 20.9.9, Function object binders
 template <class T> inline constexpr bool is_bind_expression_v
   = is_bind_expression<T>::value; // C++17
 template <class T> inline constexpr int is_placeholder_v
   = is_placeholder<T>::value; // C++17
 
 
 template<class Fn, class... BoundArgs>
-  unspecified bind(Fn&&, BoundArgs&&...);
+  constexpr unspecified bind(Fn&&, BoundArgs&&...);  // constexpr in C++20
 template<class R, class Fn, class... BoundArgs>
-  unspecified bind(Fn&&, BoundArgs&&...);
+  constexpr unspecified bind(Fn&&, BoundArgs&&...);  // constexpr in C++20
 
 template<class F, class... Args>
+ constexpr // constexpr in C++20
  invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) // C++17
     noexcept(is_nothrow_invocable_v<F, Args...>);
 
 namespace placeholders {
   // M is the implementation-defined number of placeholders
   extern unspecified _1;
   extern unspecified _2;
   .

 public:
     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
     S operator()(const T& p, A x) const;
 };
 
 template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);   // deprecated in C++11, removed in C++17
 template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);  // deprecated in C++11, removed in C++17
 
-template<class R, class T> unspecified mem_fn(R T::*);
+template<class R, class T>
+constexpr unspecified mem_fn(R T::*); // constexpr in C++20
 
 class bad_function_call
     : public exception
 {
 };
 
 template<class> class function; // undefined
 

 {
 public:
     // types
     typedef _Tp type;
 private:
     type __f_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
 
 #ifndef _LIBCPP_CXX03_LANG
     // invoke
     template <class... _ArgTypes>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     typename __invoke_return<type, _ArgTypes...>::type
     operator() (_ArgTypes&&... __args) const {
         return _VSTD::__invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
     }
 #else
 
     template <class _A0>
     _LIBCPP_INLINE_VISIBILITY
#else
     typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
     operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
         return _VSTD::__invoke(__f_, __a0, __a1, __a2);
     }
 #endif
 };
 
 template<class _Rp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __mem_fn<_Rp _Tp::*>
 mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
 {
     return __mem_fn<_Rp _Tp::*>(__pm);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                FUNCTION

 public:
     template <class _Gp, class ..._BA,
               class = typename enable_if
                                <
                                   is_constructible<_Fd, _Gp>::value &&
                                   !is_same<typename remove_reference<_Gp>::type,
                                            __bind>::value
                                >::type>
-      _LIBCPP_INLINE_VISIBILITY
+      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
         : __f_(_VSTD::forward<_Gp>(__f)),
           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
         operator()(_Args&& ...__args)
         {
             return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 
     template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
         operator()(_Args&& ...__args) const
         {
             return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 };
 
public:
 
     template <class _Gp, class ..._BA,
               class = typename enable_if
                                <
                                   is_constructible<_Fd, _Gp>::value &&
                                   !is_same<typename remove_reference<_Gp>::type,
                                            __bind_r>::value
                                >::type>
-      _LIBCPP_INLINE_VISIBILITY
+      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
         : base(_VSTD::forward<_Gp>(__f),
                _VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
                            result_type>::value || is_void<_Rp>::value,
             result_type
         >::type
         operator()(_Args&& ...__args)
         {
             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
             return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 
     template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         typename enable_if
         <
             is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
                            result_type>::value || is_void<_Rp>::value,
             result_type
         >::type
         operator()(_Args&& ...__args) const
         {
             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
             return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 };
 
 template<class _Rp, class _Fp, class ..._BoundArgs>
 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 
 template<class _Fp, class ..._BoundArgs>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __bind<_Fp, _BoundArgs...>
 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind<_Fp, _BoundArgs...> type;
     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 
 template<class _Rp, class _Fp, class ..._BoundArgs>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __bind_r<_Rp, _Fp, _BoundArgs...>
 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Fn, class ..._Args>
-invoke_result_t<_Fn, _Args...>
+_LIBCPP_CONSTEXPR_AFTER_CXX17 invoke_result_t<_Fn, _Args...>
 invoke(_Fn&& __f, _Args&&... __args)
     noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
 {
     return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
 }
 
 template <class _DecayFunc>
 class _LIBCPP_TEMPLATE_VIS __not_fn_imp {
   _DecayFunc __fd;
 
 public:
     __not_fn_imp() = delete;
 
     template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     auto operator()(_Args&& ...__args) &
             noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
         -> decltype(          !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
         { return              !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
 
     template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     auto operator()(_Args&& ...__args) &&
             noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
         -> decltype(          !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
         { return              !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
 
     template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     auto operator()(_Args&& ...__args) const&
             noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
         -> decltype(          !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
         { return              !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
 
 
     template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     auto operator()(_Args&& ...__args) const&&
             noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
         -> decltype(          !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
         { return              !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
 
 private:
     template <class _RawFunc,
               class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit __not_fn_imp(_RawFunc&& __rf)
         : __fd(_VSTD::forward<_RawFunc>(__rf)) {}
 
     template <class _RawFunc>
-    friend inline _LIBCPP_INLINE_VISIBILITY
+    friend inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     __not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
 };
 
 template <class _RawFunc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 __not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
     return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
 }
 
 #endif
 
 // struct hash<T*> in <memory>
 

 }
 
 #if _LIBCPP_STD_VER > 14
 
 // default searcher
 template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 class _LIBCPP_TYPE_VIS default_searcher {
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     default_searcher(_ForwardIterator __f, _ForwardIterator __l,
                        _BinaryPredicate __p = _BinaryPredicate())
         : __first_(__f), __last_(__l), __pred_(__p) {}
 
     template <typename _ForwardIterator2>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair<_ForwardIterator2, _ForwardIterator2>
     operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
     {
         return _VSTD::__search(__f, __l, __first_, __last_, __pred_,
             typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
             typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
     }
 

libcxx/include/type_traits

 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
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
 _LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_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)
 _LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
 
 template <class _Fp, class _A0, class ..._Args,
           class = __enable_if_bullet2<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
 _LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_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)
 _LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...))
 
 template <class _Fp, class _A0, class ..._Args,
           class = __enable_if_bullet3<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
 _LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_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)
 _LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
 
 // bullets 4, 5 and 6
 
 template <class _Fp, class _A0,
           class = __enable_if_bullet4<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0)
 _LIBCPP_INVOKE_RETURN(_VSTD::forward<_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)
 _LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f)
 
 template <class _Fp, class _A0,
           class = __enable_if_bullet5<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0)
 _LIBCPP_INVOKE_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)
 _LIBCPP_INVOKE_RETURN(__a0.get().*__f)
 
 template <class _Fp, class _A0,
           class = __enable_if_bullet6<_Fp, _A0>>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _A0&& __a0)
 _LIBCPP_INVOKE_RETURN((*_VSTD::forward<_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)
 _LIBCPP_INVOKE_RETURN((*_VSTD::forward<_A0>(__a0)).*__f)
 
 // bullet 7
 
 template <class _Fp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
-auto
+_LIBCPP_CONSTEXPR_AFTER_CXX17 auto
 __invoke(_Fp&& __f, _Args&& ...__args)
 _LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
 
 template <class _Fp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR auto
 __invoke_constexpr(_Fp&& __f, _Args&& ...__args)
 _LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))

libcxx/include/version

__cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
                                                                 <limits> <locale> <ostream>
                                                                 <string> <string_view>
 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      201806L <concepts>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
-__cpp_lib_constexpr_misc                                201811L <array> <functional> <iterator>
-                                                                <string_view> <tuple> <utility>
+__cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_numeric                             201911L <numeric>
 __cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>
 __cpp_lib_erase_if                                      202002L <string> <deque> <forward_list>
                                                                 <list> <vector> <map>

 # endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
-// # define __cpp_lib_constexpr_misc                       201811L
+# define __cpp_lib_constexpr_functional                 201907L
 # define __cpp_lib_constexpr_numeric                    201911L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L

libcxx/test/std/language.support/support.limits/support.limits.general/array.version.pass.cpp

 
 // <array>
 
 // Test the feature test macros defined by <array>
 
 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
                                             201811L [C++2a]
-    __cpp_lib_constexpr_misc                201811L [C++2a]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_to_array                      201907L [C++2a]
 */
 
 #include <array>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_to_array
 #   error "__cpp_lib_to_array should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_to_array
 #   error "__cpp_lib_to_array should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER == 17
 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++17"
 # endif
 # if __cpp_lib_array_constexpr != 201603L
 #   error "__cpp_lib_array_constexpr should have the value 201603L in c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++17"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++17"
 # endif
 
 # ifdef __cpp_lib_to_array
 #   error "__cpp_lib_to_array should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER > 17
 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2a"
 # endif
 # if __cpp_lib_array_constexpr != 201811L
 #   error "__cpp_lib_array_constexpr should have the value 201811L in c++2a"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
-
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_to_array

libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.pass.cpp

 
 // <functional>
 
 // Test the feature test macros defined by <functional>
 
 /*  Constant                           Value
     __cpp_lib_bind_front               201811L [C++2a]
     __cpp_lib_boyer_moore_searcher     201603L [C++17]
-    __cpp_lib_constexpr_misc           201811L [C++2a]
+    __cpp_lib_constexpr_functional     201907L [C++2a]
     __cpp_lib_invoke                   201411L [C++17]
     __cpp_lib_not_fn                   201603L [C++17]
     __cpp_lib_ranges                   201811L [C++2a]
     __cpp_lib_result_of_sfinae         201210L [C++14]
     __cpp_lib_transparent_operators    201210L [C++14]
                                        201510L [C++17]
 */
 
 #include <functional>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_boyer_moore_searcher
 #   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_invoke
 #   error "__cpp_lib_invoke should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_not_fn
 #   error "__cpp_lib_not_fn should not be defined before c++17"

 # ifdef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_boyer_moore_searcher
 #   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_invoke
 #   error "__cpp_lib_invoke should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_not_fn
 #   error "__cpp_lib_not_fn should not be defined before c++17"

 #     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++17"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_boyer_moore_searcher
 #     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifndef __cpp_lib_invoke
 #   error "__cpp_lib_invoke should be defined in c++17"
 # endif
 # if __cpp_lib_invoke != 201411L
 #   error "__cpp_lib_invoke should have the value 201411L in c++17"
 # endif

 #     error "__cpp_lib_boyer_moore_searcher should have the value 201603L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_boyer_moore_searcher
 #     error "__cpp_lib_boyer_moore_searcher should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_functional != 201907L
+#   error "__cpp_lib_constexpr_functional should have the value 201907L in c++2a"
 # endif
 
 # ifndef __cpp_lib_invoke
 #   error "__cpp_lib_invoke should be defined in c++2a"
 # endif
 # if __cpp_lib_invoke != 201411L
 #   error "__cpp_lib_invoke should have the value 201411L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp

 
 // <iterator>
 
 // Test the feature test macros defined by <iterator>
 
 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
                                             201811L [C++2a]
-    __cpp_lib_constexpr_misc                201811L [C++2a]
     __cpp_lib_make_reverse_iterator         201402L [C++14]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_null_iterators                201304L [C++14]
     __cpp_lib_ranges                        201811L [C++2a]
 */
 
 #include <iterator>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_null_iterators
 #   error "__cpp_lib_null_iterators should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++14"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++14"
 # endif
 
 # ifdef __cpp_lib_nonmember_container_access

 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++17"
 # endif
 # if __cpp_lib_array_constexpr != 201603L
 #   error "__cpp_lib_array_constexpr should have the value 201603L in c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++17"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++17"
 # endif
 
 # ifndef __cpp_lib_nonmember_container_access

 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2a"
 # endif
 # if __cpp_lib_array_constexpr != 201811L
 #   error "__cpp_lib_array_constexpr should have the value 201811L in c++2a"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
-
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++2a"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++2a"
 # endif
 
 # ifndef __cpp_lib_nonmember_container_access

libcxx/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
 // <string_view>
 
 // Test the feature test macros defined by <string_view>
 
-/*  Constant                    Value
-    __cpp_lib_char8_t           201811L [C++2a]
-    __cpp_lib_constexpr_misc    201811L [C++2a]
-    __cpp_lib_string_view       201606L [C++17]
+/*  Constant                 Value
+    __cpp_lib_char8_t        201811L [C++2a]
+    __cpp_lib_string_view    201606L [C++17]
 */
 
 #include <string_view>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifndef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should be defined in c++17"
 # endif
 # if __cpp_lib_string_view != 201606L
 #   error "__cpp_lib_string_view should have the value 201606L in c++17"
 # endif
 
 #elif TEST_STD_VER > 17
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2a"
 #   endif
 #   if __cpp_lib_char8_t != 201811L
 #     error "__cpp_lib_char8_t should have the value 201811L in c++2a"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
-
 # ifndef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should be defined in c++2a"
 # endif
 # if __cpp_lib_string_view != 201606L
 #   error "__cpp_lib_string_view should have the value 201606L in c++2a"
 # endif
 
 #endif // TEST_STD_VER > 17
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp

 // and should not be edited manually.
 
 // <tuple>
 
 // Test the feature test macros defined by <tuple>
 
 /*  Constant                     Value
     __cpp_lib_apply              201603L [C++17]
-    __cpp_lib_constexpr_misc     201811L [C++2a]
     __cpp_lib_make_from_tuple    201606L [C++17]
     __cpp_lib_tuple_element_t    201402L [C++14]
     __cpp_lib_tuples_by_type     201304L [C++14]
 */
 
 #include <tuple>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_apply
 #   error "__cpp_lib_apply should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_tuples_by_type
 #   error "__cpp_lib_tuples_by_type should not be defined before c++14"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_apply
 #   error "__cpp_lib_apply should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should not be defined before c++17"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should be defined in c++14"
 # endif
 # if __cpp_lib_tuple_element_t != 201402L

 
 # ifndef __cpp_lib_apply
 #   error "__cpp_lib_apply should be defined in c++17"
 # endif
 # if __cpp_lib_apply != 201603L
 #   error "__cpp_lib_apply should have the value 201603L in c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++17"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++17"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t

 
 # ifndef __cpp_lib_apply
 #   error "__cpp_lib_apply should be defined in c++2a"
 # endif
 # if __cpp_lib_apply != 201603L
 #   error "__cpp_lib_apply should have the value 201603L in c++2a"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
-
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++2a"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++2a"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t

libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp

 // and should not be edited manually.
 
 // <utility>
 
 // Test the feature test macros defined by <utility>
 
 /*  Constant                       Value
     __cpp_lib_as_const             201510L [C++17]
-    __cpp_lib_constexpr_misc       201811L [C++2a]
     __cpp_lib_constexpr_utility    201811L [C++2a]
     __cpp_lib_exchange_function    201304L [C++14]
     __cpp_lib_integer_sequence     201304L [C++14]
     __cpp_lib_to_chars             201611L [C++17]
     __cpp_lib_tuples_by_type       201304L [C++14]
 */
 
 #include <utility>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should not be defined before c++14"
 # endif
 

 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++14"
 # endif
 # if __cpp_lib_exchange_function != 201304L

 
 # ifndef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should be defined in c++17"
 # endif
 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++17"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
-# endif
-
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++17"
 # endif
 # if __cpp_lib_exchange_function != 201304L

 
 # ifndef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should be defined in c++2a"
 # endif
 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++2a"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
-
 # ifndef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should be defined in c++2a"
 # endif
 # if __cpp_lib_constexpr_utility != 201811L
 #   error "__cpp_lib_constexpr_utility should have the value 201811L in c++2a"
 # endif
 
 # ifndef __cpp_lib_exchange_function

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_byte                                 201603L [C++17]
     __cpp_lib_char8_t                              201811L [C++2a]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             201806L [C++2a]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++2a]
-    __cpp_lib_constexpr_misc                       201811L [C++2a]
+    __cpp_lib_constexpr_functional                 201907L [C++2a]
     __cpp_lib_constexpr_numeric                    201911L [C++2a]
     __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
     __cpp_lib_constexpr_utility                    201811L [C++2a]
     __cpp_lib_destroying_delete                    201806L [C++2a]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++2a]
     __cpp_lib_erase_if                             202002L [C++2a]
     __cpp_lib_exchange_function                    201304L [C++14]

 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"

 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"

 # ifdef __cpp_lib_concepts
 #   error "__cpp_lib_concepts should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
-# ifdef __cpp_lib_constexpr_misc
-#   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
+# ifdef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"

 
 # ifndef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
 # endif
 # if __cpp_lib_constexpr_dynamic_alloc != 201907L
 #   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should be defined in c++2a"
-#   endif
-#   if __cpp_lib_constexpr_misc != 201811L
-#     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_misc
-#     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_functional
+#   error "__cpp_lib_constexpr_functional should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_functional != 201907L
+#   error "__cpp_lib_constexpr_functional should have the value 201907L in c++2a"
 # endif
 
 # ifndef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should be defined in c++2a"
 # endif
 # if __cpp_lib_constexpr_numeric != 201911L
 #   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++2a"
 # endif

libcxx/test/std/utilities/function.objects/func.invoke/invoke_constexpr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <functional>
+
+// template<class F, class... Args>
+// constexpr  // constexpr in C++20
+// invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
+//     noexcept(is_nothrow_invocable_v<_Fn, _Args...>);
+
+/// C++14 [func.def] 20.9.0
+/// (1) The following definitions apply to this Clause:
+/// (2) A call signature is the name of a return type followed by a parenthesized
+///     comma-separated list of zero or more argument types.
+/// (3) A callable type is a function object type (20.9) or a pointer to member.
+/// (4) A callable object is an object of a callable type.
+/// (5) A call wrapper type is a type that holds a callable object and supports
+///     a call operation that forwards to that object.
+/// (6) A call wrapper is an object of a call wrapper type.
+/// (7) A target object is the callable object held by a call wrapper.
+
+/// C++14 [func.require] 20.9.1
+///
+/// Define INVOKE (f, t1, t2, ..., tN) as follows:
+///   (1.1) - (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of
+///   type T or a reference to an object of type T or a reference to an object of a type derived from T;
+///   (1.2) - ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of
+///   the types described in the previous item;
+///   (1.3) - t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a
+///   reference to an object of type T or a reference to an object of a type derived from T;
+///   (1.4) - (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 is not one of the types
+///   described in the previous item;
+///   (1.5) - f(t1, t2, ..., tN) in all other cases.
+
+#include <functional>
+#include <type_traits>
+#include <utility> // for std::move
+#include <cassert>
+
+#include "test_macros.h"
+
+struct NonCopyable {
+    constexpr NonCopyable() {}
+private:
+    NonCopyable(NonCopyable const&) = delete;
+    NonCopyable& operator=(NonCopyable const&) = delete;
+};
+
+struct TestClass {
+    constexpr explicit TestClass(int x) : data(x) {}
+
+    constexpr int& operator()(NonCopyable&&) & { return data; }
+    constexpr int const& operator()(NonCopyable&&) const & { return data; }
+
+    constexpr int&& operator()(NonCopyable&&) && { return std::move(data); }
+    constexpr int const&& operator()(NonCopyable&&) const && { return std::move(data); }
+
+    int data;
+private:
+    TestClass(TestClass const&) = delete;
+    TestClass& operator=(TestClass const&) = delete;
+};
+
+struct DerivedFromTestClass : public TestClass {
+    constexpr explicit DerivedFromTestClass(int x) : TestClass(x) {}
+};
+
+static constexpr int data = 42;
+constexpr const int& foo(NonCopyable&&) {
+    return data;
+}
+
+template <class Signature,  class Expect, class Functor>
+constexpr void test_b12(Functor&& f) {
+    // Create the callable object.
+    typedef Signature TestClass::*ClassFunc;
+    ClassFunc func_ptr = &TestClass::operator();
+
+    // Create the dummy arg.
+    NonCopyable arg;
+
+    // Check that the deduced return type of invoke is what is expected.
+    typedef decltype(
+        std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg))
+    ) DeducedReturnType;
+    static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
+
+    // Check that result_of_t matches Expect.
+    typedef typename std::result_of<ClassFunc&&(Functor&&, NonCopyable&&)>::type
+      ResultOfReturnType;
+    static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
+
+    // Run invoke and check the return value.
+    DeducedReturnType ret =
+            std::invoke(func_ptr, std::forward<Functor>(f), std::move(arg));
+    assert(ret == 42);
+}
+
+template <class Expect, class Functor>
+constexpr void test_b34(Functor&& f) {
+    // Create the callable object.
+    typedef int TestClass::*ClassFunc;
+    ClassFunc func_ptr = &TestClass::data;
+
+    // Check that the deduced return type of invoke is what is expected.
+    typedef decltype(
+        std::invoke(func_ptr, std::forward<Functor>(f))
+    ) DeducedReturnType;
+    static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
+
+    // Check that result_of_t matches Expect.
+    typedef typename std::result_of<ClassFunc&&(Functor&&)>::type
+            ResultOfReturnType;
+    static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
+
+    // Run invoke and check the return value.
+    DeducedReturnType ret =
+            std::invoke(func_ptr, std::forward<Functor>(f));
+    assert(ret == 42);
+}
+
+template <class Expect, class Functor>
+constexpr void test_b5(Functor&& f) {
+    NonCopyable arg;
+
+    // Check that the deduced return type of invoke is what is expected.
+    typedef decltype(
+        std::invoke(std::forward<Functor>(f), std::move(arg))
+    ) DeducedReturnType;
+    static_assert((std::is_same<DeducedReturnType, Expect>::value), "");
+
+    // Check that result_of_t matches Expect.
+    typedef typename std::result_of<Functor&&(NonCopyable&&)>::type
+            ResultOfReturnType;
+    static_assert((std::is_same<ResultOfReturnType, Expect>::value), "");
+
+    // Run invoke and check the return value.
+    DeducedReturnType ret = std::invoke(std::forward<Functor>(f), std::move(arg));
+    assert(ret == 42);
+}
+
+constexpr bool bullet_one_two_tests() {
+    {
+        TestClass cl(42);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+
+        test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
+        test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
+    }
+    {
+        DerivedFromTestClass cl(42);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+
+        test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
+        test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
+    }
+    {
+        TestClass cl_obj(42);
+        std::reference_wrapper<TestClass> cl(cl_obj);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+
+        test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
+        test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
+    }
+    {
+        DerivedFromTestClass cl_obj(42);
+        std::reference_wrapper<DerivedFromTestClass> cl(cl_obj);
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+
+        test_b12<int&(NonCopyable&&) &, int&>(std::move(cl));
+        test_b12<int const&(NonCopyable&&) const &, int const&>(std::move(cl));
+    }
+    {
+        TestClass cl_obj(42);
+        TestClass *cl = &cl_obj;
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+    }
+    {
+        DerivedFromTestClass cl_obj(42);
+        DerivedFromTestClass *cl = &cl_obj;
+        test_b12<int&(NonCopyable&&) &, int&>(cl);
+        test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
+    }
+    return true;
+}
+
+constexpr bool bullet_three_four_tests() {
+    {
+        typedef TestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(cl);
+        test_b34<int const&>(static_cast<Fn const&>(cl));
+
+        test_b34<int&&>(static_cast<Fn &&>(cl));
+        test_b34<int const&&>(static_cast<Fn const&&>(cl));
+    }
+    {
+        typedef DerivedFromTestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(cl);
+        test_b34<int const&>(static_cast<Fn const&>(cl));
+
+        test_b34<int&&>(static_cast<Fn &&>(cl));
+        test_b34<int const&&>(static_cast<Fn const&&>(cl));
+    }
+    {
+        typedef TestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(std::reference_wrapper<Fn>(cl));
+        test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
+    }
+    {
+        typedef DerivedFromTestClass Fn;
+        Fn cl(42);
+        test_b34<int&>(std::reference_wrapper<Fn>(cl));
+        test_b34<int const&>(std::reference_wrapper<Fn const>(cl));
+    }
+    {
+        typedef TestClass Fn;
+        Fn cl_obj(42);
+        Fn* cl = &cl_obj;
+        test_b34<int&>(cl);
+        test_b34<int const&>(static_cast<Fn const*>(cl));
+    }
+    {
+        typedef DerivedFromTestClass Fn;
+        Fn cl_obj(42);
+        Fn* cl = &cl_obj;
+        test_b34<int&>(cl);
+        test_b34<int const&>(static_cast<Fn const*>(cl));
+    }
+    return true;
+}
+
+constexpr bool bullet_five_tests() {
+    using FooType = const int&(NonCopyable&&);
+    {
+        FooType& fn = foo;
+        test_b5<const int &>(fn);
+    }
+    {
+        FooType* fn = foo;
+        test_b5<const int &>(fn);
+    }
+    {
+        typedef TestClass Fn;
+        Fn cl(42);
+        test_b5<int&>(cl);
+        test_b5<int const&>(static_cast<Fn const&>(cl));
+
+        test_b5<int&&>(static_cast<Fn &&>(cl));
+        test_b5<int const&&>(static_cast<Fn const&&>(cl));
+    }
+    return true;
+}
+
+int main(int, char**) {
+    static_assert(bullet_one_two_tests());
+    static_assert(bullet_three_four_tests());
+    static_assert(bullet_five_tests());
+
+    return 0;
+}

libcxx/test/std/utilities/function.objects/func.memfn/member_data.pass.cpp

 #include "test_macros.h"
 
 struct A
 {
     double data_;
 };
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(F f)
 {
     {
     A a;
     f(a) = 5;
     assert(a.data_ == 5);
     A* ap = &a;
     f(ap) = 6;
     assert(a.data_ == 6);
     const A* cap = ap;
     assert(f(cap) == f(ap));
     const F& cf = f;
     assert(cf(ap) == f(ap));
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::mem_fn(&A::data_));
 
+#if TEST_STD_VER >= 20
+    static_assert(test(std::mem_fn(&A::data_)));
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.memfn/member_function.pass.cpp

 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
-    char test0() {return 'a';}
-    char test1(int) {return 'b';}
-    char test2(int, double) {return 'c';}
+    TEST_CONSTEXPR char test0() {return 'a';}
+    TEST_CONSTEXPR char test1(int) {return 'b';}
+    TEST_CONSTEXPR char test2(int, double) {return 'c';}
 };
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test0(F f)
 {
     {
     A a;
     assert(f(a) == 'a');
     A* ap = &a;
     assert(f(ap) == 'a');
     const F& cf = f;
     assert(cf(ap) == 'a');
     }
+    return true;
 }
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test1(F f)
 {
     {
     A a;
     assert(f(a, 1) == 'b');
     A* ap = &a;
     assert(f(ap, 2) == 'b');
     const F& cf = f;
     assert(cf(ap, 2) == 'b');
     }
+    return true;
 }
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test2(F f)
 {
     {
     A a;
     assert(f(a, 1, 2) == 'c');
     A* ap = &a;
     assert(f(ap, 2, 3.5) == 'c');
     const F& cf = f;
     assert(cf(ap, 2, 3.5) == 'c');
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
 #if TEST_STD_VER >= 11
     static_assert((noexcept(std::mem_fn(&A::test0))), ""); // LWG#2489
 #endif
 
+#if TEST_STD_VER >= 20
+    static_assert(test0(std::mem_fn(&A::test0)));
+    static_assert(test1(std::mem_fn(&A::test1)));
+    static_assert(test2(std::mem_fn(&A::test2)));
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp

 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
-    char test0() const {return 'a';}
-    char test1(int) const {return 'b';}
-    char test2(int, double) const {return 'c';}
+    TEST_CONSTEXPR char test0() const {return 'a';}
+    TEST_CONSTEXPR char test1(int) const {return 'b';}
+    TEST_CONSTEXPR char test2(int, double) const {return 'c';}
 };
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test0(F f)
 {
     {
     A a;
     assert(f(a) == 'a');
     A* ap = &a;
     assert(f(ap) == 'a');
     const A* cap = &a;
     assert(f(cap) == 'a');
     const F& cf = f;
     assert(cf(ap) == 'a');
     }
+    return true;
 }
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test1(F f)
 {
     {
     A a;
     assert(f(a, 1) == 'b');
     A* ap = &a;
     assert(f(ap, 2) == 'b');
     const A* cap = &a;
     assert(f(cap, 2) == 'b');
     const F& cf = f;
     assert(cf(ap, 2) == 'b');
     }
+    return true;
 }
 
 template <class F>
-void
+TEST_CONSTEXPR_CXX20 bool
 test2(F f)
 {
     {
     A a;
     assert(f(a, 1, 2) == 'c');
     A* ap = &a;
     assert(f(ap, 2, 3.5) == 'c');
     const A* cap = &a;
     assert(f(cap, 2, 3.5) == 'c');
     const F& cf = f;
     assert(cf(ap, 2, 3.5) == 'c');
     }
+    return true;
 }
 
 int main(int, char**)
 {
     test0(std::mem_fn(&A::test0));
     test1(std::mem_fn(&A::test1));
     test2(std::mem_fn(&A::test2));
 
+#if TEST_STD_VER >= 20
+    static_assert(test0(std::mem_fn(&A::test0)));
+    static_assert(test1(std::mem_fn(&A::test1)));
+    static_assert(test2(std::mem_fn(&A::test2)));
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

 #include "test_macros.h"
 #include "type_id.h"
 
 
 ///////////////////////////////////////////////////////////////////////////////
 //                       CALLABLE TEST TYPES
 ///////////////////////////////////////////////////////////////////////////////
 
-bool returns_true() { return true; }
+constexpr bool returns_true() { return true; }
 
 template <class Ret = bool>
 struct MoveOnlyCallable {
   MoveOnlyCallable(MoveOnlyCallable const&) = delete;
-  MoveOnlyCallable(MoveOnlyCallable&& other)
+  constexpr MoveOnlyCallable(MoveOnlyCallable&& other)
       : value(other.value)
   { other.value = !other.value; }
 
   template <class ...Args>
-  Ret operator()(Args&&...) { return Ret{value}; }
+  constexpr Ret operator()(Args&&...) { return Ret{value}; }
 
-  explicit MoveOnlyCallable(bool x) : value(x) {}
+  constexpr explicit MoveOnlyCallable(bool x) : value(x) {}
   Ret value;
 };
 
 template <class Ret = bool>
 struct CopyCallable {
-  CopyCallable(CopyCallable const& other)
+  constexpr CopyCallable(CopyCallable const& other)
       : value(other.value) {}
 
-  CopyCallable(CopyCallable&& other)
+  constexpr CopyCallable(CopyCallable&& other)
       : value(other.value) { other.value = !other.value; }
 
   template <class ...Args>
-  Ret operator()(Args&&...) { return Ret{value}; }
+  constexpr Ret operator()(Args&&...) { return Ret{value}; }
 
-  explicit CopyCallable(bool x) : value(x)  {}
+  constexpr explicit CopyCallable(bool x) : value(x)  {}
   Ret value;
 };
 
 
 template <class Ret = bool>
 struct ConstCallable {
-  ConstCallable(ConstCallable const& other)
+  constexpr ConstCallable(ConstCallable const& other)
       : value(other.value) {}
 
-  ConstCallable(ConstCallable&& other)
+  constexpr ConstCallable(ConstCallable&& other)
       : value(other.value) { other.value = !other.value; }
 
   template <class ...Args>
-  Ret operator()(Args&&...) const { return Ret{value}; }
+  constexpr Ret operator()(Args&&...) const { return Ret{value}; }
 
-  explicit ConstCallable(bool x) : value(x)  {}
+  constexpr explicit ConstCallable(bool x) : value(x)  {}
   Ret value;
 };
 
 
 
 template <class Ret = bool>
 struct NoExceptCallable {
-  NoExceptCallable(NoExceptCallable const& other)
+  constexpr NoExceptCallable(NoExceptCallable const& other)
       : value(other.value) {}
 
   template <class ...Args>
-  Ret operator()(Args&&...) noexcept { return Ret{value}; }
+  constexpr Ret operator()(Args&&...) noexcept { return Ret{value}; }
 
   template <class ...Args>
-  Ret operator()(Args&&...) const noexcept { return Ret{value}; }
+  constexpr Ret operator()(Args&&...) const noexcept { return Ret{value}; }
 
-  explicit NoExceptCallable(bool x) : value(x)  {}
+  constexpr explicit NoExceptCallable(bool x) : value(x)  {}
   Ret value;
 };
 
 struct CopyAssignableWrapper {
-  CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
-  CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
-  CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
-  CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
+  constexpr CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
+  constexpr CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
+  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
+  constexpr CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
 
   template <class ...Args>
-  bool operator()(Args&&...) { return value; }
+  constexpr bool operator()(Args&&...) { return value; }
 
-  explicit CopyAssignableWrapper(bool x) : value(x) {}
+  constexpr explicit CopyAssignableWrapper(bool x) : value(x) {}
   bool value;
 };
 
 
 struct MoveAssignableWrapper {
-  MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
-  MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
-  MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
-  MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
+  constexpr MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
+  constexpr MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
+  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
+  constexpr MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
 
   template <class ...Args>
-  bool operator()(Args&&...) { return value; }
+  constexpr bool operator()(Args&&...) { return value; }
 
-  explicit MoveAssignableWrapper(bool x) : value(x) {}
+  constexpr explicit MoveAssignableWrapper(bool x) : value(x) {}
   bool value;
 };
 
 struct MemFunCallable {
-  explicit MemFunCallable(bool x) : value(x) {}
+  constexpr explicit MemFunCallable(bool x) : value(x) {}
 
-  bool return_value() const { return value; }
-  bool return_value_nc() { return value; }
+  constexpr bool return_value() const { return value; }
+  constexpr bool return_value_nc() { return value; }
   bool value;
 };
 
 enum CallType : unsigned {
   CT_None,
   CT_NonConst = 1,
   CT_Const = 2,
   CT_LValue = 4,
friend EvilBool operator!(EvilBool const& other) {
     return EvilBool{!other.value};
   }
 
 private:
   friend struct MoveOnlyCallable<EvilBool>;
   friend struct CopyCallable<EvilBool>;
   friend struct NoExceptCallable<EvilBool>;
 
-  explicit EvilBool(bool x) : value(x) {}
+  constexpr explicit EvilBool(bool x) : value(x) {}
   EvilBool& operator=(EvilBool const& other) = default;
 
 public:
   bool value;
 };
 
 int EvilBool::bang_called = 0;
 
 struct ExplicitBool {
   ExplicitBool(ExplicitBool const&) = default;
   ExplicitBool(ExplicitBool&&) = default;
 
-  explicit operator bool() const { return value; }
+  constexpr explicit operator bool() const { return value; }
 
 private:
   friend struct MoveOnlyCallable<ExplicitBool>;
   friend struct CopyCallable<ExplicitBool>;
 
-  explicit ExplicitBool(bool x) : value(x) {}
-  ExplicitBool& operator=(bool x) {
+  constexpr explicit ExplicitBool(bool x) : value(x) {}
+  constexpr ExplicitBool& operator=(bool x) {
       value = x;
       return *this;
   }
 
   bool value;
 };
 
 
 struct NoExceptEvilBool {
   NoExceptEvilBool(NoExceptEvilBool const&) = default;
   NoExceptEvilBool(NoExceptEvilBool&&) = default;
   NoExceptEvilBool& operator=(NoExceptEvilBool const& other) = default;
 
-  explicit NoExceptEvilBool(bool x) : value(x) {}
+  constexpr explicit NoExceptEvilBool(bool x) : value(x) {}
 
   friend NoExceptEvilBool operator!(NoExceptEvilBool const& other) noexcept {
     return NoExceptEvilBool{!other.value};
   }
 
   bool value;
 };
 
 
 
-void constructor_tests()
+TEST_CONSTEXPR_CXX20
+bool constructor_tests()
 {
     {
         using T = MoveOnlyCallable<bool>;
         T value(true);
         using RetT = decltype(std::not_fn(std::move(value)));
         static_assert(std::is_move_constructible<RetT>::value, "");
         static_assert(!std::is_copy_constructible<RetT>::value, "");
         static_assert(!std::is_move_assignable<RetT>::value, "");
#endif // _LIBCPP_VERSION
         assert(ret() == false);
         auto ret2 = std::not_fn(std::move(value2));
         assert(ret2() == true);
 #if defined(_LIBCPP_VERSION)
         ret = std::move(ret2);
         assert(ret() == true);
 #endif // _LIBCPP_VERSION
     }
+    return true;
 }
 
 void return_type_tests()
 {
     using std::is_same;
     {
         using T = CopyCallable<bool>;
         auto ret = std::not_fn(T{false});
using std::is_same;
         assert(value_ret.value == true);
         ret();
         assert(EvilBool::bang_called == 2);
     }
 }
 
 // Other tests only test using objects with call operators. Test various
 // other callable types here.
-void other_callable_types_test()
+TEST_CONSTEXPR_CXX20
+bool other_callable_types_test()
 {
     { // test with function pointer
         auto ret = std::not_fn(returns_true);
         assert(ret() == false);
     }
     { // test with lambda
         auto returns_value = [](bool value) { return value; };
         auto ret = std::not_fn(returns_value);
bool other_callable_types_test()
         MemFunCallable mt(true);
         const MemFunCallable mf(false);
         auto ret = std::not_fn(&MemFunCallable::value);
         assert(ret(mt) == false);
         assert(ret(mf) == true);
         assert(ret(&mt) == false);
         assert(ret(&mf) == true);
     }
+    return true;
 }
 
 void throws_in_constructor_test()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     struct ThrowsOnCopy {
       ThrowsOnCopy(ThrowsOnCopy const&) {
         throw 42;
#endif
             assert(false);
         } catch (int const& value) {
             assert(value == 42);
         }
     }
 #endif
 }
 
-void call_operator_sfinae_test() {
+TEST_CONSTEXPR_CXX20
+bool call_operator_sfinae_test() {
     { // wrong number of arguments
         using T = decltype(std::not_fn(returns_true));
         static_assert(std::is_invocable<T>::value, ""); // callable only with no args
         static_assert(!std::is_invocable<T, bool>::value, "");
     }
     { // violates const correctness (member function pointer)
         using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
         static_assert(std::is_invocable<T, MemFunCallable&>::value, "");
         static_assert(!std::is_invocable<T, const MemFunCallable&>::value, "");
     }
     { // violates const correctness (call object)
         using Obj = CopyCallable<bool>;
         using NCT = decltype(std::not_fn(Obj{true}));
         using CT = const NCT;
         static_assert(std::is_invocable<NCT>::value, "");
         static_assert(!std::is_invocable<CT>::value, "");
     }
     { // returns bad type with no operator!
         auto fn = [](auto x) { return x; };
         using T = decltype(std::not_fn(fn));
         static_assert(std::is_invocable<T, bool>::value, "");
         static_assert(!std::is_invocable<T, std::string>::value, "");
     }
+    return true;
 }
 
-void call_operator_forwarding_test()
+TEST_CONSTEXPR_CXX20
+bool call_operator_forwarding_test()
 {
     using Fn = ForwardingCallObject;
     Fn::State st;
     auto obj = std::not_fn(Fn{st});
     const auto& c_obj = obj;
     { // test zero args
         obj();
         assert(st.check_call<>(CT_NonConst | CT_LValue));
const auto& c_obj = obj;
         std::move(c_obj)(std::move(x));
         assert(st.check_call<int&&>(CT_Const | CT_RValue));
         std::move(c_obj)(std::move(cx));
         assert(st.check_call<const int&&>(CT_Const | CT_RValue));
         std::move(c_obj)(42);
         assert(st.check_call<int&&>(CT_Const | CT_RValue));
     }
     { // test multi arg
+        using String = const char *;
         const double y = 3.14;
-        std::string s = "abc";
-        obj(42, std::move(y), s, std::string{"foo"});
-        assert((st.check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_LValue)));
-        std::move(obj)(42, std::move(y), s, std::string{"foo"});
-        assert((st.check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_RValue)));
-        c_obj(42, std::move(y), s, std::string{"foo"});
-        assert((st.check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const  | CT_LValue)));
-        std::move(c_obj)(42, std::move(y), s, std::string{"foo"});
-        assert((st.check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const  | CT_RValue)));
+        String s = "abc";
+        obj(42, std::move(y), s, String{"foo"});
+        assert((st.check_call<int&&, const double&&, String&, String&&>(CT_NonConst | CT_LValue)));
+        std::move(obj)(42, std::move(y), s, String{"foo"});
+        assert((st.check_call<int&&, const double&&, String&, String&&>(CT_NonConst | CT_RValue)));
+        c_obj(42, std::move(y), s, String{"foo"});
+        assert((st.check_call<int&&, const double&&, String&, String&&>(CT_Const  | CT_LValue)));
+        std::move(c_obj)(42, std::move(y), s, String{"foo"});
+        assert((st.check_call<int&&, const double&&, String&, String&&>(CT_Const  | CT_RValue)));
     }
+    return true;
 }
 
-void call_operator_noexcept_test()
+TEST_CONSTEXPR_CXX20
+bool call_operator_noexcept_test()
 {
     {
         using T = ConstCallable<bool>;
         T value(true);
         auto ret = std::not_fn(value);
         static_assert(!noexcept(ret()), "call should not be noexcept");
         auto const& cret = ret;
         static_assert(!noexcept(cret()), "call should not be noexcept");
#endif
     {
         using T = NoExceptCallable<EvilBool>;
         T value(true);
         auto ret = std::not_fn(value);
         static_assert(!noexcept(ret()), "call should not be noexcept");
         auto const& cret = ret;
         static_assert(!noexcept(cret()), "call should not be noexcept");
     }
+    return true;
 }
 
-void test_lwg2767() {
+TEST_CONSTEXPR_CXX20
+bool test_lwg2767() {
     // See https://cplusplus.github.io/LWG/lwg-defects.html#2767
     struct Abstract { virtual void f() const = 0; };
     struct Derived : public Abstract { void f() const {} };
-    struct F { bool operator()(Abstract&&) { return false; } };
+    struct F { constexpr bool operator()(Abstract&&) { return false; } };
     {
         Derived d;
         Abstract &a = d;
         bool b = std::not_fn(F{})(std::move(a));
         assert(b);
     }
+    return true;
 }
 
 int main(int, char**)
 {
     constructor_tests();
     return_type_tests();
     other_callable_types_test();
     throws_in_constructor_test();
     call_operator_sfinae_test(); // somewhat of an extension
     call_operator_forwarding_test();
     call_operator_noexcept_test();
     test_lwg2767();
 
+#if TEST_STD_VER >= 20
+    static_assert(constructor_tests());
+    static_assert(other_callable_types_test());
+    static_assert(call_operator_sfinae_test()); // somewhat of an extension
+    static_assert(call_operator_forwarding_test());
+    static_assert(call_operator_noexcept_test());
+    static_assert(test_lwg2767());
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp

 #include <algorithm>
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <typename Iter1, typename Iter2>
+TEST_CONSTEXPR_CXX20
 void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
     std::default_searcher<Iter2> s{b2, e2};
     assert(result == std::search(b1, e1, s));
 }
 
 template <class Iter1, class Iter2>
-void
-test()
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia),    Iter1(ia));
     do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia+1),  Iter1(ia));
     do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+1),    Iter2(ia+2),  Iter1(ia+1));
     do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+2),  Iter1(ia));
     do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+3),  Iter1(ia+2));
bool test()
     const unsigned sh = sizeof(ih)/sizeof(ih[0]);
     int ii[] = {1, 1, 2};
     do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
     int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
     const unsigned sj = sizeof(ij)/sizeof(ij[0]);
     int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0};
     const unsigned sk = sizeof(ik)/sizeof(ik[0]);
     do_search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk), Iter1(ij+6));
+
+    return true;
 }
 
 int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<forward_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<forward_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, random_access_iterator<const int*>>());
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp

 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 struct count_equal
 {
-    static unsigned count;
+    unsigned *count;
+
     template <class T>
-    bool operator()(const T& x, const T& y) const
-        {++count; return x == y;}
+    TEST_CONSTEXPR_CXX14 bool operator()(const T& x, const T& y) const
+        {++*count; return x == y;}
 };
 
-unsigned count_equal::count = 0;
-
 template <typename Iter1, typename Iter2>
-void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result, unsigned max_count) {
-    std::default_searcher<Iter2, count_equal> s{b2, e2};
-    count_equal::count = 0;
+TEST_CONSTEXPR_CXX20
+void do_search(Iter1 b1, Iter1 e1, Iter2 b2, Iter2 e2, Iter1 result) {
+    unsigned count = 0;
+    std::default_searcher<Iter2, count_equal> s{b2, e2, count_equal{&count}};
     assert(result == std::search(b1, e1, s));
-    assert(count_equal::count <= max_count);
+    auto d1 = std::distance(b1, e1);
+    auto d2 = std::distance(b2, e2);
+    assert((count >= 1) || (d2 == 0) || (d1 < d2));
+    assert((d1 < d2) || count <= d1 * (d1 - d2 + 1));
 }
 
 template <class Iter1, class Iter2>
-void
-test()
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia),    Iter1(ia),      0);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia+1),  Iter1(ia),      sa);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+1),    Iter2(ia+2),  Iter1(ia+1),    sa);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+2),  Iter1(ia),      0);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+3),  Iter1(ia+2),    sa);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+3),  Iter1(ia+2),    sa);
-    do_search(Iter1(ia), Iter1(ia),      Iter2(ia+2),    Iter2(ia+3),  Iter1(ia),      0);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1), sa);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3), 3*sa);
-    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia+sa), Iter1(ia),      sa*sa);
-    do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia),      Iter2(ia+sa), Iter1(ia+sa-1), (sa-1)*sa);
-    do_search(Iter1(ia), Iter1(ia+1),    Iter2(ia),      Iter2(ia+sa), Iter1(ia+1),    sa);
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia),    Iter1(ia));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia+1),  Iter1(ia));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+1),    Iter2(ia+2),  Iter1(ia+1));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+2),  Iter1(ia));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+3),  Iter1(ia+2));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+2),    Iter2(ia+3),  Iter1(ia+2));
+    do_search(Iter1(ia), Iter1(ia),      Iter2(ia+2),    Iter2(ia+3),  Iter1(ia));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+sa-1), Iter2(ia+sa), Iter1(ia+sa-1));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia+sa-3), Iter2(ia+sa), Iter1(ia+sa-3));
+    do_search(Iter1(ia), Iter1(ia+sa),   Iter2(ia),      Iter2(ia+sa), Iter1(ia));
+    do_search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia),      Iter2(ia+sa), Iter1(ia+sa-1));
+    do_search(Iter1(ia), Iter1(ia+1),    Iter2(ia),      Iter2(ia+sa), Iter1(ia+1));
     int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]);
     int ic[] = {1};
-    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1), sb);
+    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), Iter1(ib+1));
     int id[] = {1, 2};
-    do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1), sb*2);
+    do_search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), Iter1(ib+1));
     int ie[] = {1, 2, 3};
-    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4), sb*3);
+    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), Iter1(ib+4));
     int ig[] = {1, 2, 3, 4};
-    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8), sb*4);
+    do_search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), Iter1(ib+8));
     int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4};
     const unsigned sh = sizeof(ih)/sizeof(ih[0]);
     int ii[] = {1, 1, 2};
-    do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3),  sh*3);
+    do_search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), Iter1(ih+3));
+
+    return true;
 }
 
 int main(int, char**) {
     test<forward_iterator<const int*>, forward_iterator<const int*> >();
     test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<forward_iterator<const int*>, random_access_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
     test<random_access_iterator<const int*>, forward_iterator<const int*> >();
     test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
 
+#if TEST_STD_VER >= 20
+    static_assert(test<forward_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<forward_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, forward_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<const int*>>());
+    static_assert(test<random_access_iterator<const int*>, random_access_iterator<const int*>>());
+#endif
+
     return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

# C++2a
     "headers": ["concepts"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_swap_algorithms",
     "values": { "c++2a": int(201806) },
     "headers": ["algorithm"],
     "unimplemented": True,
   }, {
-    "name": "__cpp_lib_constexpr_misc",
-    "values": { "c++2a": int(201811) },
-    "headers": ["array", "functional", "iterator", "string_view", "tuple", "utility"],
-    "unimplemented": True,
+    "name": "__cpp_lib_constexpr_functional",
+    "values": { "c++2a": int(201907) },
+    "headers": ["functional"],
   }, {
     "name": "__cpp_lib_constexpr_numeric",
     "values": { "c++2a": int(201911) },
     "headers": ["numeric"],
   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++2a": int(201811) },
     "headers": ["functional"],