[libc++] Allow backdeployment CI to run on newer macOS

[ldionne]

Summary

This should work now that we are using a matching libunwind.dylib when
we run the tests in back-deployment scenarios. The only restriction we
have now is to run on macOS x86_64, since that's what the old dylibs
were compiled for. This should allow us to move to newer AppleClangs
in the CI.

[ldionne]

Fix availability annotations

[ldionne]

Final version, I tested this to work.

[ldionne]

I'm updating the macOS CI nodes at the moment. I'm going to land this immediately because it's required as part of the update.

libcxx/include/optional

constexpr value_type value_or(_Up&& __v) &&
         static_assert(is_convertible_v<_Up, value_type>,
                       "optional<T>::value_or: U must be convertible to T");
         return this->has_value() ? _VSTD::move(this->__get()) :
                                   static_cast<value_type>(_VSTD::forward<_Up>(__v));
     }
 
 #if _LIBCPP_STD_VER > 20
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto and_then(_Func&& __f) & {
     using _Up = invoke_result_t<_Func, value_type&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
       return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
     return remove_cvref_t<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto and_then(_Func&& __f) const& {
     using _Up = invoke_result_t<_Func, const value_type&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
       return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
     return remove_cvref_t<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto and_then(_Func&& __f) && {
     using _Up = invoke_result_t<_Func, value_type&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
       return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
     return remove_cvref_t<_Up>();
   }
 
   template<class _Func>
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto and_then(_Func&& __f) const&& {
     using _Up = invoke_result_t<_Func, const value_type&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
       return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
     return remove_cvref_t<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto transform(_Func&& __f) & {
     using _Up = remove_cv_t<invoke_result_t<_Func, value_type&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>,
                   "Result of f(value()) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>,
                   "Result of f(value()) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
     if (*this)
       return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
     return optional<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto transform(_Func&& __f) const& {
     using _Up = remove_cv_t<invoke_result_t<_Func, const value_type&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>,
                   "Result of f(value()) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>,
                   "Result of f(value()) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
     if (*this)
       return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
     return optional<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto transform(_Func&& __f) && {
     using _Up = remove_cv_t<invoke_result_t<_Func, value_type&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>,
                   "Result of f(std::move(value())) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>,
                   "Result of f(std::move(value())) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");
     if (*this)
       return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), _VSTD::move(value()));
     return optional<_Up>();
   }
 
   template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
   constexpr auto transform(_Func&& __f) const&& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const value_type&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>,
                   "Result of f(std::move(value())) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>,
                   "Result of f(std::move(value())) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");

libcxx/test/std/utilities/optional/optional.monadic/and_then.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, c++11, c++14, c++17, c++20
+
+// Throwing bad_optional_access is supported starting in macosx10.13
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
 // <optional>
 
 // template<class F> constexpr auto and_then(F&&) &;
 // template<class F> constexpr auto and_then(F&&) &&;
 // template<class F> constexpr auto and_then(F&&) const&;
 // template<class F> constexpr auto and_then(F&&) const&&;
 
 #include <cassert>

libcxx/test/std/utilities/optional/optional.monadic/transform.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, c++11, c++14, c++17, c++20
+
+// Throwing bad_optional_access is supported starting in macosx10.13
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
 // <optional>
 
 // template<class F> constexpr auto transform(F&&) &;
 // template<class F> constexpr auto transform(F&&) &&;
 // template<class F> constexpr auto transform(F&&) const&;
 // template<class F> constexpr auto transform(F&&) const&&;
 
 #include "test_macros.h"

libcxx/utils/ci/buildkite-pipeline.yml

- group: ":apple: Apple"
 
     # Test back-deployment to older Apple platforms
     - label: "Apple back-deployment macosx10.9"
       command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.9"
       artifact_paths:
         - "**/test-results.xml"
       agents:
         queue: "libcxx-builders"
-        os: "macos10.15" # TODO: For now, we're running the back-deployment tests for 10.9 on 10.15, because we don't have proper 10.9 machines
-        arch: "x86_64"
+        os: "macos"
+        arch: "x86_64" # We need to use x86_64 for back-deployment CI, since the old dylibs were compiled for x86_64
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
     - label: "Apple back-deployment macosx10.15"
       command: "libcxx/utils/ci/run-buildbot apple-system-backdeployment-10.15"
       artifact_paths:
         - "**/test-results.xml"
       agents:
         queue: "libcxx-builders"
-        os: "macos10.15"
-        arch: "x86_64"
+        os: "macos"
+        arch: "x86_64" # We need to use x86_64 for back-deployment CI, since the old dylibs were compiled for x86_64
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
   - group: "ARM"
     steps: