[libc++] Mark <filesystem> as unavailable on Apple platforms using pragmas

[ldionne]

Summary

Also add the corresponding XFAILs to tests that require filesystem.
The approach taken to mark <filesystem> as unavailable in this patch
is to mark all the header as unavailable using #pragma clang attribute.
Marking each declaration using the attribute is more intrusive and
does not provide a lot of value right now because pretty much everything
in <filesystem> requires dylib support, often transitively.

This is an alternative to https://reviews.llvm.org/D59093.

[ldionne]

Work around PR41078.

[ldionne]

Since this needs both D59282 and D59394, we'll want to wait for D59394 to land. We'll also want to update the compiler on any tester that uses availability markup (so any tester that checks for back-deployment on Apple platforms) to Clang trunk.

[ldionne]

I committed about half of this (most of the test markup) in r356558. The goal was to fix tests for back-deployment use cases.

[ldionne]

Update the review after half the changes have been applied in r356558.

include/__config

 // spaceship operator is provided, or (B) a compiler provides a complete
 // implementation.
 #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 // Decide whether to use availability macros.
 #if !defined(_LIBCPP_BUILDING_LIBRARY) &&                                      \
     !defined(_LIBCPP_DISABLE_AVAILABILITY) &&                                  \
     __has_feature(attribute_availability_with_strict) &&                       \
-    __has_feature(attribute_availability_in_templates)
+    __has_feature(attribute_availability_in_templates) &&                      \
+    __has_extension(pragma_clang_attribute_external_declaration)
 #  ifdef __APPLE__
 #    define _LIBCPP_USE_AVAILABILITY_APPLE
 #  endif
 #endif
 
 // Define availability macros.
 #if defined(_LIBCPP_USE_AVAILABILITY_APPLE)
 #  define _LIBCPP_AVAILABILITY_SHARED_MUTEX                                    \

 #  define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR                               \
      __attribute__((availability(macosx,strict,introduced=10.9)))              \
      __attribute__((availability(ios,strict,introduced=7.0)))
 #  define _LIBCPP_AVAILABILITY_FILESYSTEM                                      \
      __attribute__((availability(macosx,strict,unavailable)))                  \
      __attribute__((availability(ios,strict,unavailable)))                     \
      __attribute__((availability(tvos,strict,unavailable)))                    \
      __attribute__((availability(watchos,strict,unavailable)))
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH                                 \
+     _Pragma("clang attribute push(__attribute__((availability(macosx,strict,unavailable))), apply_to=any(function,record))") \
+     _Pragma("clang attribute push(__attribute__((availability(ios,strict,unavailable))), apply_to=any(function,record))")    \
+     _Pragma("clang attribute push(__attribute__((availability(tvos,strict,unavailable))), apply_to=any(function,record))")   \
+     _Pragma("clang attribute push(__attribute__((availability(watchos,strict,unavailable))), apply_to=any(function,record))")
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM_POP                                  \
+     _Pragma("clang attribute pop")                                            \
+     _Pragma("clang attribute pop")                                            \
+     _Pragma("clang attribute pop")                                            \
+     _Pragma("clang attribute pop")
 #else
 #  define _LIBCPP_AVAILABILITY_SHARED_MUTEX
 #  define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
 #  define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 #  define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
 #  define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
 #  define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
 #  define _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #  define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
 #  define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
 #  define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 #  define _LIBCPP_AVAILABILITY_FILESYSTEM
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 #endif
 
 // Define availability that depends on _LIBCPP_NO_EXCEPTIONS.
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #  define _LIBCPP_AVAILABILITY_FUTURE
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS

include/chrono

#else
   typedef nano period;
 #endif
 
   typedef chrono::duration<rep, period> duration;
   typedef chrono::time_point<_FilesystemClock> time_point;
 
   static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
 
-  _LIBCPP_FUNC_VIS static time_point now() noexcept;
+  _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;
 
   _LIBCPP_INLINE_VISIBILITY
   static time_t to_time_t(const time_point& __t) noexcept {
       typedef chrono::duration<rep> __secs;
       return time_t(
           chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
   }
 

include/filesystem

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
+_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+
 typedef chrono::time_point<_FilesystemClock> file_time_type;
 
 struct _LIBCPP_TYPE_VIS space_info {
   uintmax_t capacity;
   uintmax_t free;
   uintmax_t available;
 };
 
return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
          __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
-class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
+// TODO(ldionne): We need to pop the pragma and push it again after
+//                filesystem_error to work around PR41078.
+_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+
+class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(path(), path())) {
     __create_what(0);
   }
 
struct _LIBCPP_HIDDEN _Storage {
 
     path __p1_;
     path __p2_;
     string __what_;
   };
   shared_ptr<_Storage> __storage_;
 };
 
+_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+
 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(std::forward<_Args>(__args)...);
 }
 #else
 void __throw_filesystem_error(_Args&&...) {
begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 end(const recursive_directory_iterator&) noexcept {
   return recursive_directory_iterator();
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // !_LIBCPP_CXX03_LANG
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FILESYSTEM

test/std/utilities/time/time.clock/time.clock.file/consistency.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++98, c++03, c++11, c++14, c++17
 
 // Due to C++17 inline variables ASAN flags this test as containing an ODR
 // violation because Clock::is_steady is defined in both the dylib and this TU.
 // UNSUPPORTED: asan
 
+// XFAIL: dylib-has-no-filesystem
+
 // <chrono>
 
 // file_clock
 
 // check clock invariants
 
 #include <chrono>
 

test/std/utilities/time/time.clock/time.clock.file/file_time.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++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 
 // <chrono>
 
 // file_time
 
 #include <chrono>
 
 #include "test_macros.h"
 
 template <class Dur>
 void test() {
   ASSERT_SAME_TYPE(std::chrono::file_time<Dur>, std::chrono::time_point<std::chrono::file_clock, Dur>);
 }
 
 int main(int, char**) {
   test<std::chrono::nanoseconds>();
   test<std::chrono::minutes>();
   test<std::chrono::hours>();
 
   return 0;
 }
 No newline at end of file

test/std/utilities/time/time.clock/time.clock.file/rep_signed.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++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 
 // <chrono>
 
 // file_clock
 
 // rep should be signed
 
 #include <chrono>