Cherry-pick a few changes to unbreak libc++ testing on release/12.x

[ldionne]

@tstellar Permission to merge this into release/12.x once the CI is passing.

I'm trying to get on top of the release story for libc++ and I'd like to merge a few bug fixes to the 12.0.1 release, but I want to do that on top of clean CI, which is what these 3 small patches do.

[tstellar]

In D104400#2822815, @ldionne wrote:

@tstellar Permission to merge this into release/12.x once the CI is passing.

I'm trying to get on top of the release story for libc++ and I'd like to merge a few bug fixes to the 12.0.1 release, but I want to do that on top of clean CI, which is what these 3 small patches do.

Sure, no problem. Is the bot you are trying to fix: libcxx-libcxxabi-x86_64-linux-debian-release ?

[ldionne]

In D104400#2822831, @tstellar wrote:

In D104400#2822815, @ldionne wrote:

@tstellar Permission to merge this into release/12.x once the CI is passing.

I'm trying to get on top of the release story for libc++ and I'd like to merge a few bug fixes to the 12.0.1 release, but I want to do that on top of clean CI, which is what these 3 small patches do.

Sure, no problem. Is the bot you are trying to fix: libcxx-libcxxabi-x86_64-linux-debian-release ?

Thanks. No, I'm trying to fix https://buildkite.com/llvm-project/libcxx-ci/builds?branch=release%2F12.x right now. But I'll also have a look at the linux-debian-release one.

[ldionne]

Merged.

libcxx/include/__bit_reference

 
 public:
     _LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
     : __seg_(nullptr), __ctz_(0)
 #endif
     {}
 
-    // avoid re-declaring a copy constructor for the non-const version.
-    using __type_for_copy_to_const =
-      _If<_IsConst, __bit_iterator<_Cp, false>, struct __private_nat>;
-
+    // When _IsConst=false, this is the copy constructor.
+    // It is non-trivial. Making it trivial would break ABI.
+    // When _IsConst=true, this is a converting constructor;
+    // the copy and move constructors are implicitly generated
+    // and trivial.
     _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(const __type_for_copy_to_const& __it) _NOEXCEPT
+    __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
         : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
 
-    // The non-const __bit_iterator has historically had a non-trivial
-    // copy constructor (as a quirk of its construction). We need to maintain
-    // this for ABI purposes.
-    using __type_for_abi_non_trivial_copy_ctor =
-      _If<!_IsConst, __bit_iterator, struct __private_nat>;
-
+    // When _IsConst=false, we have a user-provided copy constructor,
+    // so we must also provide a copy assignment operator because
+    // the implicit generation of a defaulted one is deprecated.
+    // When _IsConst=true, the assignment operators are
+    // implicitly generated and trivial.
     _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(__type_for_abi_non_trivial_copy_ctor const& __it) _NOEXCEPT
-      : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
-
-    // Always declare the copy assignment operator since the implicit declaration
-    // is deprecated.
-    _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator& operator=(__bit_iterator const&) = default;
+    __bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
+        __seg_ = __it.__seg_;
+        __ctz_ = __it.__ctz_;
+        return *this;
+    }
 
     _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
         {return reference(__seg_, __storage_type(1) << __ctz_);}
 
     _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
     {
         if (__ctz_ != __bits_per_word-1)
             ++__ctz_;

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/expected.pass.cpp

struct expected {
   std::shared_ptr<Data> data;
 
   expected(T val) : data(std::make_shared<Data>(val, Error())) {}
   expected(error_tag, Error error) : data(std::make_shared<Data>(T(), error)) {}
   expected(std::shared_ptr<Data> p) : data(p) {}
 
   struct promise_type {
     std::shared_ptr<Data> data;
-    std::shared_ptr<Data> get_return_object() { data = std::make_shared<Data>(); return data; }
+    expected get_return_object() { data = std::make_shared<Data>(); return {data}; }
     suspend_never initial_suspend() { return {}; }
     suspend_never final_suspend() noexcept { return {}; }
     void return_value(T v) { data->val = v; data->error = {}; }
     void unhandled_exception() {}
   };
 
   bool await_ready() { return !data->error; }
   T await_resume() { return data->val; }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/deduct.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
 // UNSUPPORTED: libcpp-no-deduction-guides
 // UNSUPPORTED: apple-clang-9
 
 // GCC's implementation of class template deduction is still immature and runs
 // into issues with libc++. However GCC accepts this code when compiling
 // against libstdc++.
-// XFAIL: gcc-5, gcc-6, gcc-7
+// XFAIL: gcc-5, gcc-6, gcc-7, gcc-8, gcc-9, gcc-10, gcc-11
 
 // <tuple>
 
 // Test that the constructors offered by std::tuple are formulated
 // so they're compatible with implicit deduction guides, or if that's not
 // possible that they provide explicit guides to make it work.
 
 #include <tuple>