[libc++] Avoid including <Block.h> from <functional>

[ldionne]

Summary

Block.h is a pretty common name, which can lead to nasty collisions with
user provided headers. Since we're only getting a few simple declarations
from the header, it's better to declare them manually than to include the
header.

rdar://66384326

[erik.pilkington]

LGTM

libcxx/include/functional

 #include <exception>
 #include <memory>
 #include <tuple>
 #include <utility>
 #include <version>
 
 #include <__functional_base>
 
-#if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC)
-#include <Block.h>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
_LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
         else
             return reinterpret_cast<const _Tp*>(&__buf_.__small);
     }
 #endif // _LIBCPP_NO_RTTI
 };
 
 #if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC)
 
+extern "C" void *_Block_copy(const void *);
+extern "C" void _Block_release(const void *);
+
 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 const& __f)
-        : __f_(__f ? Block_copy(__f) : (__block_type)0)
+        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
     { }
 
     // [TODO] add && to save on a retain
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __func(__block_type __f, const _Alloc& /* unused */)
-        : __f_(__f ? Block_copy(__f) : (__block_type)0)
+        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
     { }
 
     virtual __base<_Rp(_ArgTypes...)>* __clone() const {
         _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.");
         return nullptr;
     }
 
     virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
         ::new (__p) __func(__f_);
     }
 
     virtual void destroy() _NOEXCEPT {
         if (__f_)
-            Block_release(__f_);
+            _Block_release(__f_);
         __f_ = 0;
     }
 
     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.");

libcxx/test/libcxx/utilities/function.objects/func.blocks.sh.cpp

 
 // RUN: %{build} -fblocks
 // RUN: %{run}
 
 #include <functional>
 #include <cstdlib>
 #include <cassert>
 
+#include <Block.h>
+
 #include "test_macros.h"
 #include "count_new.h"
 
 
 struct A {
   static int count;
   int id_;
   explicit A(int id) { ++count; id_ = id; }