[libcxx] Fix PR 23589: std::function doesn't recognize null pointer to varargs function

[EricWF]

Summary

__not_null is missing overloads for cv and ref qualified member functions as well as functions that have varargs. This patch adds these overloads.

see https://llvm.org/bugs/show_bug.cgi?id=23589.

[Potatoswatter]

A lot of work can be saved by ignoring the function signature.

template<class _R2, class _Cp>
static bool not_null(_R2 _Cp::* p) {return __p;}

[EricWF]

Flush out tests.

[EricWF]

Use Davids suggestion to reduce code duplication. I didn't know that would work :-)

[EricWF]

Withdrawing this patch. I have a large number of __invoke tests to check in before I start fixing this.

include/__functional_03

         static bool __not_null(_R2 (*__p)()) {return __p;}
     template <class _R2>
         _LIBCPP_INLINE_VISIBILITY
+        static bool __not_null(_R2 (*__p)(...)) {return __p;}
+    template <class _R2>
+        _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2()>& __p) {return __p;}
 public:
     typedef _Rp result_type;

     template <class _R2, class _B0>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(_R2 (*__p)(_B0)) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)()) {return __p;}
-    template <class _R2, class _Cp>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() const) {return __p;}
-    template <class _R2, class _Cp>
+    template <class _R2, class _B0>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() volatile) {return __p;}
-    template <class _R2, class _Cp>
+        static bool __not_null(_R2 (*__p)(_B0, ...)) {return __p;}
+    template <class _Ret, class _Class>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)() const volatile) {return __p;}
+        static bool __not_null(_Ret _Class::*__p) { return __p; }
     template <class _R2, class _B0>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2(_B0)>& __p) {return __p;}

     template <class _R2, class _B0, class _B1>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(_R2 (*__p)(_B0, _B1)) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1)) {return __p;}
-    template <class _R2, class _Cp, class _B1>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) const) {return __p;}
-    template <class _R2, class _Cp, class _B1>
+    template <class _R2, class _B0, class _B1>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) volatile) {return __p;}
-    template <class _R2, class _Cp, class _B1>
+        static bool __not_null(_R2 (*__p)(_B0, _B1, ...)) {return __p;}
+    template <class _Ret, class _Class>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1) const volatile) {return __p;}
+        static bool __not_null(_Ret _Class::*__p) { return __p; }
     template <class _R2, class _B0, class _B1>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2(_B0, _B1)>& __p) {return __p;}

     template <class _R2, class _B0, class _B1, class _B2>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(_R2 (*__p)(_B0, _B1, _B2)) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2)) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
+    template <class _R2, class _B0, class _B1, class _B2>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) volatile) {return __p;}
-    template <class _R2, class _Cp, class _B1, class _B2>
+        static bool __not_null(_R2 (*__p)(_B0, _B1, _B2, ...)) {return __p;}
+    template <class _Ret, class _Class>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const volatile) {return __p;}
+        static bool __not_null(_Ret _Class::*__p) { return __p; }
     template <class _R2, class _B0, class _B1, class _B2>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2(_B0, _B1, _B2)>& __p) {return __p;}

include/__functional_base_03

     return (__t1.*__f)();
 }
 
+
+template <class _Rp, class _Tp, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(...), _T1& __t1)
+{
+    return (__t1.*__f)();
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, ...), _T1& __t1, _A0& __a0)
+{
+    return (__t1.*__f)(__a0);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, ...), _T1& __t1, _A0& __a0, _A1& __a1)
+{
+    return (__t1.*__f)(__a0, __a1);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2, ...), _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+{
+    return (__t1.*__f)(__a0, __a1, __a2);
+}
+
+
 template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)();
 }
 
+
+template <class _Rp, class _Tp, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(...) const, _T1& __t1)
+{
+    return (__t1.*__f)();
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, ...) const, _T1& __t1, _A0& __a0)
+{
+    return (__t1.*__f)(__a0);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, ...) const, _T1& __t1, _A0& __a0, _A1& __a1)
+{
+    return (__t1.*__f)(__a0, __a1);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2, ...) const, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+{
+    return (__t1.*__f)(__a0, __a1, __a2);
+}
+
 template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)();
 }
 
+
+template <class _Rp, class _Tp, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(...) volatile, _T1& __t1)
+{
+    return (__t1.*__f)();
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, ...) volatile, _T1& __t1, _A0& __a0)
+{
+    return (__t1.*__f)(__a0);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, ...) volatile, _T1& __t1, _A0& __a0, _A1& __a1)
+{
+    return (__t1.*__f)(__a0, __a1);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2, ...) volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+{
+    return (__t1.*__f)(__a0, __a1, __a2);
+}
+
 template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)();
 }
 
+
+template <class _Rp, class _Tp, class _T1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(...) const volatile, _T1& __t1)
+{
+    return (__t1.*__f)();
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, ...) const volatile, _T1& __t1, _A0& __a0)
+{
+    return (__t1.*__f)(__a0);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, ...) const volatile, _T1& __t1, _A0& __a0, _A1& __a1)
+{
+    return (__t1.*__f)(__a0, __a1);
+}
+
 template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if

     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
+
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
+>::type
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2, ...) const volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+{
+    return (__t1.*__f)(__a0, __a1, __a2);
+}
+
+
 // second bullet
 
 template <class _Rp, class _Tp, class _T1>

include/functional

     template <class _R2, class ..._Ap>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
+    template <class _R2, class ..._Ap>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;}
-    template <class _R2, class _Cp, class ..._Ap>
+        static bool __not_null(_R2 (*__p)(_Ap..., ...)) { return __p; }
+    template <class _Ret, class _Class>
         _LIBCPP_INLINE_VISIBILITY
-        static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;}
+        static bool __not_null(_Ret _Class::*__p) { return __p; }
     template <class _R2, class ..._Ap>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2(_Ap...)>& __p) {return !!__p;}

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp

 
 // class function<R(ArgTypes...)>
 
-// function(nullptr_t);
+// function(Fp);
 
 #include <functional>
 #include <cassert>

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// class function<R(ArgTypes...)>
+
+// function(Fp);
+
+// Ensure that __not_null works for all function types.
+// See https://llvm.org/bugs/show_bug.cgi?id=23589
+
+#include <functional>
+#include <cassert>
+
+struct A {};
+
+#define NULL_CV_TYPE
+
+#if __cplusplus >= 201103L
+#define TEST_CV_MEM_TYPE_RET(Ret, CV) \
+    test_mf<Ret(A::*)() CV, Ret(A CV &), A CV &>(); \
+    test_mf<Ret(A::*)(...) CV, Ret(A CV &), A CV &>(); \
+    test_mf<Ret(A::*)() CV &, Ret(A CV &), A CV &>(); \
+    test_mf<Ret(A::*)(...) CV &, Ret(A CV &), A CV &>(); \
+    test_mf<Ret(A::*)() CV &&, Ret(A CV &&), A CV &&>(); \
+    test_mf<Ret(A::*)(...) CV &&, Ret(A CV &&), A CV &&>()
+#else
+#define TEST_CV_MEM_TYPE_RET(Ret, CV) \
+    test_mf<Ret(A::*)() CV, Ret(A CV &), A CV &>(); \
+    test_mf<Ret(A::*)(...) CV, Ret(A CV &), A CV &>()
+#endif
+
+#define TEST_CV_MEM_TYPE(CV) \
+    TEST_CV_MEM_TYPE_RET(void, CV); \
+    TEST_CV_MEM_TYPE_RET(int, CV)
+
+#define TEST_CV_TYPE(CV) \
+    test0<void(*)(), void()>(); \
+    test0<void(*)(...), void()>(); \
+    test1<void(*)(int CV), void(int CV)>(); \
+    test1<void(*)(int CV, ...), void(int CV)>();\
+    test2<void(*)(int CV, int CV), void(int CV, int CV)>(); \
+    test2<void(*)(int CV, int CV, ...), void(int CV, int CV)>();\
+    test3<void(*)(int CV, int CV, int CV), void(int CV, int CV, int CV)>(); \
+    test3<void(*)(int CV, int CV, int CV...), void(int CV, int CV, int CV)>();\
+    test0<int(*)(), int()>(); \
+    test0<int(*)(...), int()>(); \
+    test1<int(*)(int CV), int(int CV)>(); \
+    test1<int(*)(int CV, ...), int(int CV)>();\
+    test2<int(*)(int CV, int CV), int(int CV, int CV)>(); \
+    test2<int(*)(int CV, int CV, ...), int(int CV, int CV)>();\
+    test3<int(*)(int CV, int CV, int CV), int(int CV, int CV, int CV)>(); \
+    test3<int(*)(int CV, int CV, int CV...), int(int CV, int CV, int CV)>()
+
+
+template <class MemFn, class Fn, class CVA>
+void test_mf() {
+    MemFn mf = nullptr;
+    std::function<Fn> f = mf;
+    A a;
+    try { f(static_cast<CVA>(a)); assert(false); }
+    catch (std::bad_function_call&) {}
+}
+
+template <class RawFn, class Fn>
+void test0() {
+    RawFn fn = nullptr;
+    std::function<Fn> f = fn;
+    try { f(); assert(false); }
+    catch (std::bad_function_call&) {}
+}
+
+template <class RawFn, class Fn>
+void test1() {
+    RawFn fn = nullptr;
+    std::function<Fn> f = fn;
+    int x = 42;
+    try { f(x); assert(false); }
+    catch (std::bad_function_call&) {}
+}
+
+template <class RawFn, class Fn>
+void test2() {
+    RawFn fn = nullptr;
+    std::function<Fn> f = fn;
+    int x = 42;
+    try { f(x, x); assert(false); }
+    catch (std::bad_function_call&) {}
+}
+
+template <class RawFn, class Fn>
+void test3() {
+    RawFn fn = nullptr;
+    std::function<Fn> f = fn;
+    int x = 42;
+    try { f(x, x, x); assert(false); }
+    catch (std::bad_function_call&) {}
+}
+
+int main() {
+    {
+        TEST_CV_MEM_TYPE( NULL_CV_TYPE );
+        TEST_CV_MEM_TYPE( const );
+        TEST_CV_MEM_TYPE( volatile );
+        TEST_CV_MEM_TYPE( const volatile );
+    }
+    {
+       TEST_CV_TYPE( NULL_CV_TYPE );
+       TEST_CV_TYPE( const );
+       TEST_CV_TYPE( volatile );
+       TEST_CV_TYPE( const volatile );
+
+       TEST_CV_TYPE( & );
+       TEST_CV_TYPE( const & );
+       TEST_CV_TYPE( volatile & );
+       TEST_CV_TYPE( const volatile & );
+    }
+}
 No newline at end of file