[libcxx] Add Apple blocks support to std::function

[EricWF]

include/functional

1431

I agree this should never be called. I'm unsure of this use of _LIBCPP_ASSERT because (as I understand it) _LIBCPP_ASSERT should be used to verify that the user is using libc++ correctly and not that our implementation is correct.

1446–1448

When is it possible for __f_ to be null?

include/__config

 #define _LIBCPP_HAS_NO_STRONG_ENUMS
 #endif
 
+#if __has_extension(blocks)
+#define _LIBCPP_HAS_BLOCKS
+#endif
+
 #if !(__has_feature(cxx_constexpr))
 #define _LIBCPP_HAS_NO_CONSTEXPR
 #endif

include/functional

 
 #include <__functional_base>
 
+#if defined(_LIBCPP_HAS_BLOCKS) && !defined(_LIBCPP_HAS_OBJC_ARC)
+#include <Block.h>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

 
 #endif  // _LIBCPP_NO_RTTI
 
+#if defined(_LIBCPP_HAS_BLOCKS) && !defined(_LIBCPP_HAS_OBJC_ARC)
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>
+    : public  __base<_Rp(_ArgTypes...)>
+{
+    typedef _Rp1(^__block_type)(_ArgTypes1...);
+    __block_type __f_;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __func(__block_type __f)
+        : __f_(__f ? Block_copy(__f) : (__block_type)0) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit __func(__block_type __f, const _Alloc& /* unused */)
+        : __f_(__f ? Block_copy(__f) : (__block_type)0) {}
+
+    virtual __base<_Rp(_ArgTypes...)>* __clone() const;
+    virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
+    virtual void destroy() _NOEXCEPT;
+    virtual void destroy_deallocate() _NOEXCEPT;
+    virtual _Rp operator()(_ArgTypes&& ... __arg);
+#ifndef _LIBCPP_NO_RTTI
+    virtual const void* target(const type_info&) const _NOEXCEPT;
+    virtual const std::type_info& target_type() const _NOEXCEPT;
+#endif  // _LIBCPP_NO_RTTI
+};
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+__base<_Rp(_ArgTypes...)>*
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::__clone() const
+{
+    // Block pointers are just pointers, so it should always fit in __buf_. This version
+    // of __clone should never get invoked.
+    _LIBCPP_ASSERT(false, "std::function should capture blocks internally");
+    return 0;
+}
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
+{
+    ::new (__p) __func(__f_);
+}
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
+{
+    if (__f_)
+        Block_release(__f_);
+    __f_ = 0;
+}
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
+{
+    // Block pointers are just pointers, so it should always fit in __buf_. This version
+    // of destroy should never get invoked.
+    _LIBCPP_ASSERT(false, "std::function should capture blocks internally");
+    return 0;
+}
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+_Rp
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
+{
+    return __invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
+}
+
+#ifndef _LIBCPP_NO_RTTI
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+const void*
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
+{
+    if (__ti == typeid(__func::__block_type))
+        return &__f_;
+    return (const void*)0;
+}
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+const std::type_info&
+__func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
+{
+    return typeid(__func::__block_type);
+}
+
+#endif  // _LIBCPP_NO_RTTI
+#endif  // _LIBCPP_HAS_BLOCKS && !_LIBCPP_HAS_OBJC_ARC
+
+
 }  // __function
 
 template<class _Rp, class ..._ArgTypes>

     template <class _R2, class ..._Ap>
         _LIBCPP_INLINE_VISIBILITY
         static bool __not_null(const function<_R2(_Ap...)>& __p) {return !!__p;}
+#ifdef _LIBCPP_HAS_BLOCKS
+    template <class _R2, class ..._Ap>
+        _LIBCPP_INLINE_VISIBILITY
+        static bool __not_null(_R2 (^__p)(_Ap...)) {return __p;}
+#endif
 
     template <class _Fp, bool = !is_same<_Fp, function>::value &&
                                 __invokable<_Fp&, _ArgTypes...>::value>

test/lit.cfg

                     'C++ ABI setting %s unsupported for tests' % cxx_abi)
 
             if sys.platform == 'darwin':
-                self.link_flags += ['-lSystem']
+                self.link_flags += ['-lSystem', '-fblocks']
             elif sys.platform == 'linux2':
                 self.link_flags += ['-lgcc_eh', '-lc', '-lm', '-lpthread',
                                     '-lrt', '-lgcc_s']

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp

     }
     assert(A::count == 0);
     assert(new_called == 0);
+#ifdef _LIBCPP_HAS_BLOCKS
+    {
+    std::function<int(int)> f1 = g;
+    std::function<int(int)> f2 = ^(int x) { return x + 1; };
+    assert(A::count == 0);
+    assert(new_called == 0);
+    assert(*f1.target<int(*)(int)>() == g);
+    assert(*f2.target<int(^)(int)>() != 0);
+    swap(f1, f2);
+    assert(A::count == 0);
+    assert(new_called == 0);
+    assert(*f1.target<int(^)(int)>() != 0);
+    assert(*f2.target<int(*)(int)>() == g);
+    }
+#endif
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.cpp

     f = g;
     assert(f);
     }
+#ifdef _LIBCPP_HAS_BLOCKS
+    {
+    std::function<int(int)> f;
+    assert(!f);
+    f = ^(int x) { return x+1; };
+    assert(f);
+    }
+#endif
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_int_0.pass.cpp

     std::function<int ()> r1(a0);
     assert(r1() == 4);
     }
+#ifdef _LIBCPP_HAS_BLOCKS
+    // block
+    {
+    std::function<int ()> r1 = ^{ return 5; };
+    assert(r1() == 5);
+    }
+#endif
 }
 
 int main()

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke_void_0.pass.cpp

     assert(count == save_count+1);
     save_count = count;
     }
+#ifdef _LIBCPP_HAS_BLOCKS
+    // block
+    {
+    std::function<void ()> r1(^{ ++count; });
+    r1();
+    assert(count == save_count+1);
+    save_count = count;
+    }
+#endif
 }
 
 int main()

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp

     }
     assert(A::count == 0);
     assert(new_called == 0);
+#ifdef _LIBCPP_HAS_BLOCKS
+    {
+    std::function<int(int)> f1 = A(1);
+    std::function<int(int)> f2 = ^(int x) { return x + 1; };
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f1.target<A>()->id() == 1);
+    assert((*f2.target<int(^)(int)>())(13) == 14);
+    f1.swap(f2);
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert((*f1.target<int(^)(int)>())(13) == 14);
+    assert(f2.target<A>()->id() == 1);
+    }
+#endif
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp

     f = g;
     assert(f != nullptr);
     assert(nullptr != f);
+#ifdef _LIBCPP_HAS_BLOCKS
+    f = ^(int x) { return x + 1; };
+    assert(f != nullptr);
+    assert(nullptr != f);
+#endif
     }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp

     assert(f.target<A>() == 0);
     }
     assert(A::count == 0);
+#ifdef _LIBCPP_HAS_BLOCKS
+    {
+    int (^block)(int) = Block_copy(^(int x) { return x + 1; });
+    std::function<int(int)> f = block;
+    assert(*f.target<int(^)(int)>() == block);
+    assert(f.target<int(*)(int)>() == 0);
+    Block_release(block);
+    }
+#endif
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.cpp

     std::function<int(int)> f;
     assert(f.target_type() == typeid(void));
     }
+#ifdef _LIBCPP_HAS_BLOCKS
+    {
+    std::function<int(int)> f = ^(int x) { return x + 1; };
+    assert(f.target_type() == typeid(int(^)(int)));
+    }
+#endif
 }