[libc++] ADL-proof <functional> by adding _VSTD:: qualification on calls.

[• Quuxplusone]

Summary

• std::reference_wrapper
• std::function
• std::mem_fn
  
  While I'm here, remove _VSTD:: qualification from calls to declval because it takes no arguments and thus isn't susceptible to ADL.

[• Quuxplusone]

Fix names of new test files.

[• Quuxplusone]

Rebase, to poke the buildbot.

[ldionne]

LGTM if CI passes.

[• Quuxplusone]

The GCC test failure is interesting. I just filed https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98249 about it, and will wait to see what develops.

[• Quuxplusone]

Temporarily rebase on D93153 to see if D93153 indeed fixes the GCC buildbot issue. (Will still wait for review of D93153 before landing either of these.)

libcxx/include/__functional_base

 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
 {
     typedef _Rp result_type;
 };
 
 template <class _Tp, class ..._Args>
 struct __invoke_return
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
+    typedef decltype(_VSTD::__invoke(declval<_Tp>(), declval<_Args>()...)) type;
 };
 
 #else // defined(_LIBCPP_CXX03_LANG)
 
 #include <__functional_base_03>
 
 #endif  // !defined(_LIBCPP_CXX03_LANG)
 
 
 template <class _Ret>
 struct __invoke_void_return_wrapper
 {
 #ifndef _LIBCPP_CXX03_LANG
     template <class ..._Args>
     static _Ret __call(_Args&&... __args) {
-        return __invoke(_VSTD::forward<_Args>(__args)...);
+        return _VSTD::__invoke(_VSTD::forward<_Args>(__args)...);
     }
 #else
     template <class _Fn>
     static _Ret __call(_Fn __f) {
-        return __invoke(__f);
+        return _VSTD::__invoke(__f);
     }
 
     template <class _Fn, class _A0>
     static _Ret __call(_Fn __f, _A0& __a0) {
-        return __invoke(__f, __a0);
+        return _VSTD::__invoke(__f, __a0);
     }
 
     template <class _Fn, class _A0, class _A1>
     static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) {
-        return __invoke(__f, __a0, __a1);
+        return _VSTD::__invoke(__f, __a0, __a1);
     }
 
     template <class _Fn, class _A0, class _A1, class _A2>
     static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2){
-        return __invoke(__f, __a0, __a1, __a2);
+        return _VSTD::__invoke(__f, __a0, __a1, __a2);
     }
 #endif
 };
 
 template <>
 struct __invoke_void_return_wrapper<void>
 {
 #ifndef _LIBCPP_CXX03_LANG
     template <class ..._Args>
     static void __call(_Args&&... __args) {
-        __invoke(_VSTD::forward<_Args>(__args)...);
+        _VSTD::__invoke(_VSTD::forward<_Args>(__args)...);
     }
 #else
     template <class _Fn>
     static void __call(_Fn __f) {
-        __invoke(__f);
+        _VSTD::__invoke(__f);
     }
 
     template <class _Fn, class _A0>
     static void __call(_Fn __f, _A0& __a0) {
-        __invoke(__f, __a0);
+        _VSTD::__invoke(__f, __a0);
     }
 
     template <class _Fn, class _A0, class _A1>
     static void __call(_Fn __f, _A0& __a0, _A1& __a1) {
-        __invoke(__f, __a0, __a1);
+        _VSTD::__invoke(__f, __a0, __a1);
     }
 
     template <class _Fn, class _A0, class _A1, class _A2>
     static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) {
-        __invoke(__f, __a0, __a1, __a2);
+        _VSTD::__invoke(__f, __a0, __a1, __a2);
     }
 #endif
 };
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS reference_wrapper
     : public __weak_result_type<_Tp>
 {
#endif
     _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
 
 #ifndef _LIBCPP_CXX03_LANG
     // invoke
     template <class... _ArgTypes>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_of<type&, _ArgTypes...>::type
     operator() (_ArgTypes&&... __args) const {
-        return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
+        return _VSTD::__invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
     }
 #else
 
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return<type>::type
     operator() () const {
-        return __invoke(get());
+        return _VSTD::__invoke(get());
     }
 
     template <class _A0>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return0<type, _A0>::type
     operator() (_A0& __a0) const {
-        return __invoke(get(), __a0);
+        return _VSTD::__invoke(get(), __a0);
     }
 
     template <class _A0>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return0<type, _A0 const>::type
     operator() (_A0 const& __a0) const {
-        return __invoke(get(), __a0);
+        return _VSTD::__invoke(get(), __a0);
     }
 
     template <class _A0, class _A1>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return1<type, _A0, _A1>::type
     operator() (_A0& __a0, _A1& __a1) const {
-        return __invoke(get(), __a0, __a1);
+        return _VSTD::__invoke(get(), __a0, __a1);
     }
 
     template <class _A0, class _A1>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return1<type, _A0 const, _A1>::type
     operator() (_A0 const& __a0, _A1& __a1) const {
-        return __invoke(get(), __a0, __a1);
+        return _VSTD::__invoke(get(), __a0, __a1);
     }
 
     template <class _A0, class _A1>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return1<type, _A0, _A1 const>::type
     operator() (_A0& __a0, _A1 const& __a1) const {
-        return __invoke(get(), __a0, __a1);
+        return _VSTD::__invoke(get(), __a0, __a1);
     }
 
     template <class _A0, class _A1>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return1<type, _A0 const, _A1 const>::type
     operator() (_A0 const& __a0, _A1 const& __a1) const {
-        return __invoke(get(), __a0, __a1);
+        return _VSTD::__invoke(get(), __a0, __a1);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0, _A1, _A2>::type
     operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0 const, _A1, _A2>::type
     operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0, _A1 const, _A2>::type
     operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0, _A1, _A2 const>::type
     operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
     operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
     operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
     operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 
     template <class _A0, class _A1, class _A2>
     _LIBCPP_INLINE_VISIBILITY
     typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
     operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
-        return __invoke(get(), __a0, __a1, __a2);
+        return _VSTD::__invoke(get(), __a0, __a1, __a2);
     }
 #endif // _LIBCPP_CXX03_LANG
 };
 
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>

libcxx/include/__functional_base_03

typedef typename add_lvalue_reference<
                 typename __apply_cv<_T1, _Ret>::type
             >::type _Bullet3;
     typedef _Bullet3 type;
 };
 
 template <class _Ret, class _T1>
 struct __enable_invoke_imp<_Ret, _T1, false, false>  {
     typedef typename add_lvalue_reference<
-                typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _Ret>::type
+                typename __apply_cv<decltype(*declval<_T1>()), _Ret>::type
             >::type _Bullet4;
     typedef _Bullet4 type;
 };
 
 template <class _Ret, class _T1>
 struct __enable_invoke_imp<_Ret, _T1*, false, false>  {
     typedef typename add_lvalue_reference<
                 typename __apply_cv<_T1, _Ret>::type

 __invoke(_Fn __f, _T1& __t1) {
     return (*__t1).*__f;
 }
 
 // fifth bullet
 
 template <class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(_VSTD::declval<_Fp&>()())
+decltype(declval<_Fp&>()())
 __invoke(_Fp& __f)
 {
     return __f();
 }
 
 template <class _Fp, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>()))
+decltype(declval<_Fp&>()(declval<_A0&>()))
 __invoke(_Fp& __f, _A0& __a0)
 {
     return __f(__a0);
 }
 
 template <class _Fp, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>(), _VSTD::declval<_A1&>()))
+decltype(declval<_Fp&>()(declval<_A0&>(), declval<_A1&>()))
 __invoke(_Fp& __f, _A0& __a0, _A1& __a1)
 {
     return __f(__a0, __a1);
 }
 
 template <class _Fp, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>(), _VSTD::declval<_A1&>(), _VSTD::declval<_A2&>()))
+decltype(declval<_Fp&>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
 __invoke(_Fp& __f, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return __f(__a0, __a1, __a2);
 }
 
 template <class _Fp, bool = __has_result_type<__weak_result_type<_Fp> >::value>
 struct __invoke_return
 {
     typedef typename __weak_result_type<_Fp>::result_type type;
 };
 
 template <class _Fp>
 struct __invoke_return<_Fp, false>
 {
-    typedef decltype(__invoke(_VSTD::declval<_Fp&>())) type;
+    typedef decltype(_VSTD::__invoke(declval<_Fp&>())) type;
 };
 
 template <class _Tp, class _A0>
 struct __invoke_return0
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>())) type;
+    typedef decltype(_VSTD::__invoke(declval<_Tp&>(), declval<_A0&>())) type;
 };
 
 template <class _Rp, class _Tp, class _A0>
 struct __invoke_return0<_Rp _Tp::*, _A0>
 {
     typedef typename __enable_invoke<_Rp _Tp::*, _A0>::type type;
 };
 
 template <class _Tp, class _A0, class _A1>
 struct __invoke_return1
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>(),
-                                                      _VSTD::declval<_A1&>())) type;
+    typedef decltype(_VSTD::__invoke(declval<_Tp&>(), declval<_A0&>(),
+                                                      declval<_A1&>())) type;
 };
 
 template <class _Rp, class _Class, class _A0, class _A1>
 struct __invoke_return1<_Rp _Class::*, _A0, _A1> {
     typedef typename __enable_invoke<_Rp _Class::*, _A0>::type type;
 };
 
 template <class _Tp, class _A0, class _A1, class _A2>
 struct __invoke_return2
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>(),
-                                                      _VSTD::declval<_A1&>(),
-                                                      _VSTD::declval<_A2&>())) type;
+    typedef decltype(_VSTD::__invoke(declval<_Tp&>(), declval<_A0&>(),
+                                                      declval<_A1&>(),
+                                                      declval<_A2&>())) type;
 };
 
 template <class _Ret, class _Class, class _A0, class _A1, class _A2>
 struct __invoke_return2<_Ret _Class::*, _A0, _A1, _A2> {
     typedef typename __enable_invoke<_Ret _Class::*, _A0>::type type;
 };
 #endif  // _LIBCPP_FUNCTIONAL_BASE_03

libcxx/include/functional

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

     virtual void destroy_deallocate() _NOEXCEPT {
         _LIBCPP_ASSERT(false,
             "Block pointers are just pointers, so they should always fit into "
             "std::function's small buffer optimization. This function should "
             "never be invoked.");
     }
 
     virtual _Rp operator()(_ArgTypes&& ... __arg) {
-        return __invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
+        return _VSTD::__invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
     }
 
 #ifndef _LIBCPP_NO_RTTI
     virtual const void* target(type_info const& __ti) const _NOEXCEPT {
         if (__ti == typeid(__func::__block_type))
             return &__f_;
         return (const void*)nullptr;
     }

libcxx/test/std/utilities/function.objects/func.memfn/robust_against_adl.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
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Incomplete;
+template<class T> struct Holder { T t; };
+typedef Holder<Incomplete> *Ptr;
+
+struct A {
+    Ptr no_args() const { return nullptr; }
+    Ptr one_arg(Ptr p) const { return p; }
+    void one_arg_void(Ptr) const { }
+};
+
+int main(int, char**)
+{
+    A a;
+    A *pa = &a;
+    const A *cpa = &a;
+    Ptr x = nullptr;
+    const Ptr cx = nullptr;
+    std::mem_fn(&A::no_args)(a);
+    std::mem_fn(&A::no_args)(pa);
+    std::mem_fn(&A::no_args)(*cpa);
+    std::mem_fn(&A::no_args)(cpa);
+    std::mem_fn(&A::one_arg)(a, x);
+    std::mem_fn(&A::one_arg)(pa, x);
+    std::mem_fn(&A::one_arg)(a, cx);
+    std::mem_fn(&A::one_arg)(pa, cx);
+    std::mem_fn(&A::one_arg)(*cpa, x);
+    std::mem_fn(&A::one_arg)(cpa, x);
+    std::mem_fn(&A::one_arg)(*cpa, cx);
+    std::mem_fn(&A::one_arg)(cpa, cx);
+    std::mem_fn(&A::one_arg_void)(a, x);
+    std::mem_fn(&A::one_arg_void)(pa, x);
+    std::mem_fn(&A::one_arg_void)(a, cx);
+    std::mem_fn(&A::one_arg_void)(pa, cx);
+    std::mem_fn(&A::one_arg_void)(*cpa, x);
+    std::mem_fn(&A::one_arg_void)(cpa, x);
+    std::mem_fn(&A::one_arg_void)(*cpa, cx);
+    std::mem_fn(&A::one_arg_void)(cpa, cx);
+    return 0;
+}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/robust_against_adl.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
+
+// <functional>
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Incomplete;
+template<class T> struct Holder { T t; };
+typedef Holder<Incomplete> *Ptr;
+
+Ptr no_args() { return nullptr; }
+Ptr one_arg(Ptr p) { return p; }
+Ptr two_args(Ptr p, Ptr) { return p; }
+Ptr three_args(Ptr p, Ptr, Ptr) { return p; }
+Ptr four_args(Ptr p, Ptr, Ptr, Ptr) { return p; }
+
+void one_arg_void(Ptr) { }
+
+int main(int, char**)
+{
+    Ptr x = nullptr;
+    std::function<Ptr()> f(no_args); f();
+    std::function<Ptr(Ptr)> g(one_arg); g(x);
+    std::function<void(Ptr)> h(one_arg_void); h(x);
+    return 0;
+}

libcxx/test/std/utilities/function.objects/refwrap/refwrap.invoke/robust_against_adl.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
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Incomplete;
+template<class T> struct Holder { T t; };
+typedef Holder<Incomplete> *Ptr;
+
+Ptr no_args() { return nullptr; }
+Ptr one_arg(Ptr p) { return p; }
+Ptr two_args(Ptr p, Ptr) { return p; }
+Ptr three_args(Ptr p, Ptr, Ptr) { return p; }
+
+void one_arg_void(Ptr) { }
+
+int main(int, char**)
+{
+    Ptr x = nullptr;
+    const Ptr cx = nullptr;
+    std::ref(no_args)();
+    std::ref(one_arg)(x);
+    std::ref(one_arg)(cx);
+    std::ref(two_args)(x, x);
+    std::ref(two_args)(x, cx);
+    std::ref(two_args)(cx, x);
+    std::ref(two_args)(cx, cx);
+    std::ref(three_args)(x, x, x);
+    std::ref(three_args)(x, x, cx);
+    std::ref(three_args)(x, cx, x);
+    std::ref(three_args)(cx, x, x);
+    std::ref(three_args)(x, cx, cx);
+    std::ref(three_args)(cx, x, cx);
+    std::ref(three_args)(cx, cx, x);
+    std::ref(three_args)(cx, cx, cx);
+    std::ref(one_arg_void)(x);
+    std::ref(one_arg_void)(cx);
+
+    return 0;
+}