Constrain tuple/unique_ptr move constructors (2899)

[zoecarver]

Summary

This patch disables unique_ptr& operator=(unique_ptr&&), unique_ptr(unique_ptr&&), and tuple(tuple&&) unless is_move_constructible_v is true. This patch resolves LWG issue 2899.

[zoecarver]

It did not appear that <tuple> needed to be updated. Correct me if I am wrong.

libcxx/include/memory

2269

The indentation is wrong in this section of the file.

2301

The issue said to use is_move_assignable_v<D> but, that will cause some deleters to break. Thoughts on a better way to resolve this? Or should we make people change how they pass their deleter types?

2330

This is unconditionally added because otherwise this overload may be picked when the other overloads are disabled.

[ldionne]

libcxx/include/memory

2279

Any reason for preferring this style of enable_if (as a default argument) as opposed to using a default _template_ argument?

2301

Deleters are allowed to be lvalue references to function objects, so I don't think you want to use remove_reference here (nor remove_const). I think it is expected that a unique_ptr<T, Deleter const&> should be expected _not_ to be move assignable.

[zoecarver]

libcxx/include/memory

2279

For some reason the first time I tried this it didn't work, so I looked at shared_ptr (where I had remembered something similar), and this is how it was implemented. Just tried it again and it did seem to work, so I will use your suggestion.

2301

Alrighty. That does seem more correct. But, it will force us to change our tests, and when we have to change our tests, people will probably have to change their code. Given how often unique_ptr is used, it may not be desirable to break people's code without guarding it to another version (they might expect it when switching from C++17 to C++2a, but it might be bad for them to re-build libcxx and have their program stop working).

That being said, we should implement the standard, so I will make the change.

[ldionne]

libcxx/include/memory

2301

I think what would be useful is to have @mclow.lists 's opinion on this matter. Marshall, do you know whether it was understood that the LWG issue resolution would break some code? Was it deemed OK because it only breaks unique_ptr using something like a Deleter const& (which should be rare)? Are we misunderstanding something?

[zoecarver]

libcxx/include/memory

2301

Agreed. @mclow.lists friendly ping. What are your thoughts on this?

[mclow.lists]

libcxx/include/memory

2301

What's the breakage that you're seeing here?

If you're worried about op= on a unique_ptr<T, const D&> - I don't see how that would have ever worked.

[zoecarver]

libcxx/include/memory

2301

That was what I was worried about. Not sure why, though. I think I may have misdiagnosed the cause of an error while creating this patch. I will update this template to be class _Dummy = _Dp.

[ldionne]

libcxx/include/memory

2301

So, my initial point is that our test suite currently tests for:

using P = std::unique_ptr<const T, Deleter const&>;
static_assert(std::is_nothrow_assignable<P, P&&>::value, "");

See here. When I take Zoe's patch and use class _Dummy = _Dp instead of class _Dummy = typename remove_const<typename remove_reference<_Dp>::type>::type, this test breaks (and others too):

<snip>/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp:224:5: error: static_assert failed due to requirement 'std::is_nothrow_assignable<std::__1::unique_ptr<const A, const GenericConvertingDeleter<0> &>, std::__1::unique_ptr<A, const GenericConvertingDeleter<0> &> &&>::value' ""
    static_assert(std::is_nothrow_assignable<U1C, U1&&>::value, "");
    ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<snip>/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp:410:5: note: in instantiation of function template specialization 'test_sfinae<false>' requested here
    test_sfinae</*IsArray*/false>();
    ^
<snip>/libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp:301:5: error: static_assert failed due to requirement 'std::is_nothrow_assignable<std::__1::unique_ptr<const A, NCDeleter<const A> &>, std::__1::unique_ptr<A, NCDeleter<const A> &> >::value' ""
    static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
    ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Given that, my question was:

1. Why do we test for that? Does the Standard say it should be valid? I thought this was the case, but it isn't (see below).
2. If the Standard says it's valid, then was it discussed in LWG that LWG2899's resolution would break that use case?

Why I don't think std::declval<unique_ptr<T, Deleter const&>&>() = std::declval<unique_ptr<T, Deleter const&>&&>() is valid according to the Standard

1. Deleters are allowed to be lvalue references to function object types per unique_ptr.single#1. And a Deleter const is a valid function object type if Deleter's operator() is const-qualified, per function.objects#1. So Deleter const& is a valid template argument for unique_ptr's deleter.
2. However, per unique.ptr.single/2: "Otherwise, D is a reference type; remove_­reference_­t<D> shall meet the Cpp17CopyAssignable requirements and assignment of the deleter from an lvalue of type D shall not throw an exception." Since remove_reference_t<D> is Deleter const, it's not Cpp17CopyAssignable and the requirements are not met.

So our tests are wrong, they shouldn't expect move-assignment of a unique_ptr with a Deleter const& (or a Deleter const, for that matter) to be valid.

[ldionne]

libcxx/include/memory

2301

In other words, my concern was that LWG2899's resolution would break valid code. But, if my analysis above is correct, that code (move-assigning unique_ptr with Deleter const&) was already invalid. So LWG2899's resolution doesn't break valid code: it causes already invalid code to break in a different way than previously, and that happens to break our tests (because they are incorrect).

[zoecarver]

libcxx/include/memory

2301

Thank you for the message, @ldionne. I talked with @mclow.lists a bit about this yesterday and came to the same conclusion, std::declval<unique_ptr<T, Deleter const&>&>() = std::declval<unique_ptr<T, Deleter const&>&&>() has never been valid. Even before this patch, the above line would fail to compile, however,

using P = std::unique_ptr<const T, Deleter const&>;
static_assert(std::is_nothrow_assignable<P, P&&>::value, "");

Would not. This patch makes sure that is_assignable<...>corrisponds correctly to whether that type may be assigned. Our tests are incorrect; people's code may also be incorrect, but, it is more important that the type trait is correct than the possibility we break someone's code.

With that said, I plan to update both our tests and the enable_if statement (though, for a different reason than I stated in my last comment).

[mclow.lists]

libcxx/include/memory

2301

So our tests are wrong, they shouldn't expect move-assignment of a unique_ptr with a Deleter const& (or a Deleter const, for that matter) to be valid.

I concur.

[zoecarver]

• use _EnableIf when possible
• update tests and remove std::remove_ref

[mclow.lists]

libcxx/include/memory

2333

Ok, this is just weird. Everywhere else in libc++, we avoid using = delete in C++03 mode, because it's not a thing.
We even have a macro for it in __config:

#ifdef _LIBCPP_CXX03_LANG
#  define _LIBCPP_EQUAL_DELETE
#else
#  define _LIBCPP_EQUAL_DELETE = delete
#endif

And yet, here (twice!) we only do this for C++03.
@EricWF added this in https://llvm.org/r364161; so I think he should explain.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp

113

We have a type trait for move_assignable.

[zoecarver]

libcxx/include/memory

2333

Looks like it was just after we dropped support for GCC 4. He was probably just removing some of the C++03 clutter & cleaning up our implementation. But, I'll wait for him to respond.

[ldionne]

libcxx/include/memory

2333

Ping @EricWF

[ldionne]

I think this looks good to me, but can you please rebase onto master and update the review? It'll run the CI and we can see if it fails under some configuration. Then I'll re-read the discussion we had to confirm we're good to go, and we can ship it.

[ldionne]

Requesting changes for now so it shows up correctly in the review queue.

[zoecarver]

libcxx/include/memory

2333

Feel free to correct me Eric, but to elaborate on my original comment, I suspect this was just to "clean up our implementation." Looking at the commit, you can see that previously these methods were "deleted" in C++03 mode by declaring them privately. After we dropped GCC C++03 support we were able to use = delete instead which is much more explicit. However, as far as I can tell, those methods weren't deleted in any way in the "normal" implementation, so that's probably why they were only applied to C++03 here.

[zoecarver]

• Rebase off master.

[zoecarver]

• Use is_move_constructible and is_move_assignable whenever possible.

[zoecarver]

• Mark LWG 2899 as complete in status.

[zoecarver]

• Mark the move constructor as deleted to fix the C++03 tests.

[zoecarver]

• Rebase to trigger CI.

[zoecarver]

While attempting to fix the remaining CI build failures I arrived at a problem and I'm not sure what is the best way to proceed. This is the problem:

1. The "trivial_abi" attribute requires a move constructor or a copy constructor.
2. The standard requires that unique_ptr's "move constructor" doesn't participate in overload resolution unless a requirement is met. This requires a templated "move constructor" so that the function may be disabled.
3. A move constructor is not permitted to be templated. From the standard's point of view, I think it's OK for unique_ptr not to have a move constructor so long as it is move constructible (which would be the case if it has a templated "move constructor").

I am not super familiar with the trivial_abi attribute, so maybe there's some way around this. Any suggestions would be appreciated :)

[ldionne]

In D66262#2412154, @zoecarver wrote:

While attempting to fix the remaining CI build failures I arrived at a problem and I'm not sure what is the best way to proceed. This is the problem:

1. The "trivial_abi" attribute requires a move constructor or a copy constructor.
2. The standard requires that unique_ptr's "move constructor" doesn't participate in overload resolution unless a requirement is met. This requires a templated "move constructor" so that the function may be disabled.
3. A move constructor is not permitted to be templated. From the standard's point of view, I think it's OK for unique_ptr not to have a move constructor so long as it is move constructible (which would be the case if it has a templated "move constructor").

I am not super familiar with the trivial_abi attribute, so maybe there's some way around this. Any suggestions would be appreciated :)

Oh, so that's the reason for the failures. Basically we're bypassing the trivial_abi attribute altogether.

The only way I can *maybe* foresee fixing this in the library would be to specialize unique_ptr based on whether the deleter is move constructible (i.e. specialize based on whether the move constructor should be enabled or not). Now, we can't do that without breaking ABI (because it would require changing template parameters to add one we can use enable_if on), so we'd have to instead:

1. Inherit from a class like __unique_ptr_base which itself does some SFINAE in its template parameters, and has two specializations (one with a move ctor and one without).
2. Use using __unique_ptr_base::__unique_ptr_base; inside std::unique_ptr.

I'm not 100% sure that works cause I haven't tried it out, but it might be worth trying out. Otherwise, I believe we'd have to discuss with the compiler folks to see whether it makes sense to change the attribute, or we'd need to drop that extension (but that's pretty bad).

Can you try out my suggestion with the base class? I'm thinking about something like:

template <class _Tp, class _Deleter, bool = is_move_constructible<_Deleter>::value>
class __unique_ptr_base;

// Move constructible version
template <class _Tp, class _Deleter, bool = is_move_constructible<_Deleter>::value>
class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __unique_ptr_base<_Tp, _Deleter, true> {
    __compressed_pair<pointer, deleter_type> __ptr_;

public:
    _LIBCPP_INLINE_VISIBILITY
    __unique_ptr_base(__unique_ptr_base&& __u) _NOEXCEPT { ... }

    // other constructors...
};

// Non move-constructible version
template <class _Tp, class _Deleter, bool = is_move_constructible<_Deleter>::value>
class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __unique_ptr_base<_Tp, _Deleter, false> {
    __compressed_pair<pointer, deleter_type> __ptr_;

public:
    _LIBCPP_INLINE_VISIBILITY
    __unique_ptr_base(__unique_ptr_base&&) = delete;

    // other constructors...
};

template <class _Tp, class _Dp = default_delete<_Tp> >
class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr : public __unique_ptr_base<_Tp, _Dp> {
    ...
    using __unique_ptr_base::__unique_ptr_base;
};

[EricWF]

I'm going to have to revisit this patch in depth, likely after consulting with philnik.

libcxx/include/memory

unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
+  template<class _Dummy = _Dp, class = _EnableIf<is_move_constructible<_Dummy>::value> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(auto_ptr<_Up>&& __p,
              typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                                     is_same<_Dp, default_delete<_Tp> >::value,
                                 __nat>::type = __nat()) _NOEXCEPT
       : __ptr_(__p.release(), __default_init_tag()) {}
 #endif
 
+  template<class _Dummy = _Dp, class = _EnableIf<is_move_assignable<_Dummy>::value> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
_LIBCPP_INLINE_VISIBILITY
                              is_same<_Dp, default_delete<_Tp> >::value,
                          unique_ptr&>::type
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
-#ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
-#endif
-
 
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
public:
   }
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
+  template<class _Dummy = _Dp, class = _EnableIf<is_move_constructible<_Dummy>::value> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
+  template<class _Dummy = _Dp, class = _EnableIf<is_move_assignable<_Dummy>::value> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
public:
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
-#ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
-#endif
 
 public:
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move.pass.cpp

assert(A::count == 0);
     assert(s1.get() == 0);
     assert(A::count == expect_alive);
     assert(d1.state() == 5);
     assert(d2.state() == 5);
   }
   assert(A::count == 0);
 }
 
+template <class T>
+struct NonMoveableDeleter : std::default_delete<T> {
+    NonMoveableDeleter() = default;
+    NonMoveableDeleter& operator=(NonMoveableDeleter&&) = delete;
+};
+
 template <bool IsArray>
 void test_sfinae() {
   typedef typename std::conditional<IsArray, int[], int>::type VT;
   {
     typedef std::unique_ptr<VT> U;
     static_assert(!std::is_assignable<U, U&>::value, "");
     static_assert(!std::is_assignable<U, const U&>::value, "");
     static_assert(!std::is_assignable<U, const U&&>::value, "");
     static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
   }
   {
     typedef std::unique_ptr<VT, GenericDeleter> U;
     static_assert(!std::is_assignable<U, U&>::value, "");
     static_assert(!std::is_assignable<U, const U&>::value, "");
     static_assert(!std::is_assignable<U, const U&&>::value, "");
     static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
   }
   {
-    typedef std::unique_ptr<VT, NCDeleter<VT>&> U;
-    static_assert(!std::is_assignable<U, U&>::value, "");
-    static_assert(!std::is_assignable<U, const U&>::value, "");
-    static_assert(!std::is_assignable<U, const U&&>::value, "");
-    static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
-  }
-  {
-    typedef std::unique_ptr<VT, const NCDeleter<VT>&> U;
-    static_assert(!std::is_assignable<U, U&>::value, "");
-    static_assert(!std::is_assignable<U, const U&>::value, "");
-    static_assert(!std::is_assignable<U, const U&&>::value, "");
-    static_assert(std::is_nothrow_assignable<U, U&&>::value, "");
+    typedef std::unique_ptr<int, NonMoveableDeleter<int> > NonMoveableUniquePtr;
+    static_assert(!std::is_move_assignable<NonMoveableUniquePtr>::value, "");
   }
 }
 
-
 int main(int, char**) {
   {
     test_basic</*IsArray*/ false>();
     test_sfinae<false>();
   }
   {
     test_basic</*IsArray*/ true>();
     test_sfinae<true>();
   }
 
   return 0;
 }

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp

typedef typename std::conditional<IsArray, A[], A>::type VT;
     static_assert(!std::is_assignable<U1, U2&&>::value, "");
   }
   { // Test that if the deleter assignment is not valid the assignment operator
     // SFINAEs.
     using U1 = std::unique_ptr<VT, GenericConvertingDeleter<0> const& >;
     using U2 = std::unique_ptr<VT, GenericConvertingDeleter<0> >;
     using U3 = std::unique_ptr<VT, GenericConvertingDeleter<0> &>;
     using U4 = std::unique_ptr<VT, GenericConvertingDeleter<1> >;
-    using U5 = std::unique_ptr<VT, GenericConvertingDeleter<1> const&>;
     static_assert(!std::is_assignable<U1, U2&&>::value, "");
     static_assert(!std::is_assignable<U1, U3&&>::value, "");
     static_assert(!std::is_assignable<U1, U4&&>::value, "");
-    static_assert(!std::is_assignable<U1, U5&&>::value, "");
-
-    using U1C = std::unique_ptr<const VT, GenericConvertingDeleter<0> const&>;
-    static_assert(std::is_nothrow_assignable<U1C, U1&&>::value, "");
   }
   { // Test that if the deleter assignment is not valid the assignment operator
     // SFINAEs.
     using U1 = std::unique_ptr<VT, GenericConvertingDeleter<0> & >;
     using U2 = std::unique_ptr<VT, GenericConvertingDeleter<0> >;
     using U3 = std::unique_ptr<VT, GenericConvertingDeleter<0> &>;
     using U4 = std::unique_ptr<VT, GenericConvertingDeleter<1> >;
     using U5 = std::unique_ptr<VT, GenericConvertingDeleter<1> const&>;
typedef typename std::conditional<IsArray, A[], A>::type VT;
     typedef std::unique_ptr<VT> BPtr;
     static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
   }
   {
     typedef std::unique_ptr<const VT, CDeleter<const VT> > APtr;
     typedef std::unique_ptr<VT, CDeleter<VT> > BPtr;
     static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
   }
-  {
-    typedef std::unique_ptr<const VT, NCDeleter<const VT>&> APtr;
-    typedef std::unique_ptr<VT, NCDeleter<const VT>&> BPtr;
-    static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
-  }
-  {
-    typedef std::unique_ptr<const VT, const NCConstDeleter<const VT>&> APtr;
-    typedef std::unique_ptr<VT, const NCConstDeleter<const VT>&> BPtr;
-    static_assert(std::is_nothrow_assignable<APtr, BPtr>::value, "");
-  }
 }
 
 template <bool IsArray>
 void test_deleter_value_category() {
   typedef typename std::conditional<IsArray, A[], A>::type VT;
   using TD1 = TrackingDeleter<1>;
   using TD2 = TrackingDeleter<2>;
   TD1 d1;

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp

void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
   assert(rhs.get_deleter().state() == RHSState);
 }
 
 template <class T>
 struct NCConvertingDeleter {
   NCConvertingDeleter() = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
   NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  NCConvertingDeleter& operator=(NCConvertingDeleter&&) = default;
 
   template <class U>
   NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
+  template <class U>
+  NCConvertingDeleter& operator=(NCConvertingDeleter<U>&&) {}
+
   void operator()(T*) const {}
 };
 
 template <class T>
 struct NCConvertingDeleter<T[]> {
   NCConvertingDeleter() = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
   NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  NCConvertingDeleter& operator=(NCConvertingDeleter&&) = default;
 
   template <class U>
   NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
+  template <class U>
+  NCConvertingDeleter& operator=(NCConvertingDeleter<U>&&) {}
+
   void operator()(T*) const {}
 };
 
 struct GenericDeleter {
   void operator()(void*) const;
 };
 
 struct NCGenericDeleter {

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.single.pass.cpp

void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
   assert(rhs.get_deleter().state() == RHSState);
 }
 
 template <class T>
 struct NCConvertingDeleter {
   NCConvertingDeleter() = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
   NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  NCConvertingDeleter& operator=(NCConvertingDeleter&&) = default;
 
   template <class U>
   NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
+  template <class U>
+  NCConvertingDeleter& operator=(NCConvertingDeleter<U>&&) {}
+
   void operator()(T*) const {}
 };
 
 template <class T>
 struct NCConvertingDeleter<T[]> {
   NCConvertingDeleter() = default;
   NCConvertingDeleter(NCConvertingDeleter const&) = delete;
   NCConvertingDeleter(NCConvertingDeleter&&) = default;
+  NCConvertingDeleter& operator=(NCConvertingDeleter&&) = default;
 
   template <class U>
   NCConvertingDeleter(NCConvertingDeleter<U>&&) {}
 
+  template <class U>
+  NCConvertingDeleter& operator=(NCConvertingDeleter<U>&&) {}
+
   void operator()(T*) const {}
 };
 
 struct NCGenericDeleter {
   NCGenericDeleter() = default;
   NCGenericDeleter(NCGenericDeleter const&) = delete;
   NCGenericDeleter(NCGenericDeleter&&) = default;
 

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move.pass.cpp

 
 template <class VT>
 void sink3(std::unique_ptr<VT, NCDeleter<VT>&> p) {
   assert(p.get() != nullptr);
   assert(p.get_deleter().state() == 5);
   assert(&p.get_deleter() == &source3<VT>().get_deleter());
 }
 
+template <class T>
+struct NonMoveableDeleter : std::default_delete<T> {
+    NonMoveableDeleter() = default;
+    NonMoveableDeleter& operator=(NonMoveableDeleter&&) = delete;
+    NonMoveableDeleter(NonMoveableDeleter&&) = delete;
+};
+
 template <class ValueT>
 void test_sfinae() {
-  typedef std::unique_ptr<ValueT> U;
   { // Ensure unique_ptr is non-copyable
+    typedef std::unique_ptr<ValueT> U;
     static_assert((!std::is_constructible<U, U const&>::value), "");
     static_assert((!std::is_constructible<U, U&>::value), "");
   }
+  {
+    typedef std::unique_ptr<int, NonMoveableDeleter<int> > NonMoveableUniquePtr;
+    static_assert(!std::is_move_constructible<NonMoveableUniquePtr>::value, "");
+  }
 }
 
 template <bool IsArray>
 void test_basic() {
   typedef typename std::conditional<!IsArray, A, A[]>::type VT;
   const int expect_alive = IsArray ? 5 : 1;
   {
     typedef std::unique_ptr<VT> APtr;

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

 
 // a move_only type which does not trigger the empty base optimization
 struct move_only_large final {
   move_only_large() : value(42) {}
   move_only_large(move_only_large&&) = default;
   int value;
 };
 
+// is_move_constructible_v = false here
+struct no_move_const {
+  no_move_const(no_move_const const&) = delete;
+  no_move_const(no_move_const&&) = delete;
+};
+
 template <class Elem>
 void test_sfinae() {
     using Tup = std::tuple<Elem>;
     using Alloc = std::allocator<int>;
     using Tag = std::allocator_arg_t;
     // special members
     {
         static_assert(std::is_default_constructible<Tup>::value, "");
int main(int, char**)
     {
         typedef std::tuple<MoveOnly, MoveOnly, MoveOnly> T;
         T t0(MoveOnly(0), MoveOnly(1), MoveOnly(2));
         T t = std::move(t0);
         assert(std::get<0>(t) == 0);
         assert(std::get<1>(t) == 1);
         assert(std::get<2>(t) == 2);
     }
+    // Issue 2899:
+    // Constraints: is_move_constructible_v<T_i> is true for all i.
+    {
+        typedef std::tuple<no_move_const> T1;
+        typedef std::tuple<no_move_const, no_move_const, no_move_const> T2;
+        typedef std::tuple<int, int, no_move_const> T3;
+        typedef std::tuple<int, no_move_const, int> T4;
+
+        static_assert(!std::is_move_constructible<T1>::value, "");
+        static_assert(!std::is_move_constructible<T2>::value, "");
+        static_assert(!std::is_move_constructible<T3>::value, "");
+        static_assert(!std::is_move_constructible<T4>::value, "");
+    }
     // A bug in tuple caused __tuple_leaf to use its explicit converting constructor
     //  as its move constructor. This tests that ConstructsWithTupleLeaf is not called
     // (w/ __tuple_leaf)
     {
         typedef std::tuple<ConstructsWithTupleLeaf> d_t;
         d_t d((ConstructsWithTupleLeaf()));
         d_t d2(static_cast<d_t &&>(d));
     }
     {
         test_sfinae<move_only_ebo>();
         test_sfinae<move_only_large>();
     }
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp

void test_bad_index() {
     std::tuple<> t0;
     TEST_IGNORE_NODISCARD std::get<char*>(t0); // expected-node {{requested here}}
         // expected-error@tuple:* 1 {{type not in empty type list}}
 }
 
 void test_bad_return_type() {
     typedef std::unique_ptr<int> upint;
     std::tuple<upint> t;
-    upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
+    upint p = std::get<upint>(t); // expected-error{{call to deleted constructor of 'upint' (aka 'unique_ptr<int>')}}
 }
 
 int main(int, char**)
 {
     test_bad_index();
     test_bad_return_type();
 
   return 0;
 }

libcxx/test/support/deleter_types.h

 class NCDeleter
 {
     int state_;
     NCDeleter(NCDeleter const&);
     NCDeleter& operator=(NCDeleter const&);
 public:
 
     NCDeleter() : state_(0) {}
+    NCDeleter& operator=(NCDeleter&& other) { return NCDeleter(std::move(other.state_)); }
     explicit NCDeleter(int s) : state_(s) {}
     ~NCDeleter() {assert(state_ >= 0); state_ = -1;}
 
     int state() const {return state_;}
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) {delete p;}
 };
 
 
 template <class T>
 class NCDeleter<T[]>
 {
     int state_;
     NCDeleter(NCDeleter const&);
     NCDeleter& operator=(NCDeleter const&);
 public:
 
     NCDeleter() : state_(0) {}
+    NCDeleter& operator=(NCDeleter&& other) { return NCDeleter(std::move(other.state_)); }
     explicit NCDeleter(int s) : state_(s) {}
     ~NCDeleter() {assert(state_ >= 0); state_ = -1;}
 
     int state() const {return state_;}
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) {delete [] p;}
 };
 
 
 // Non-copyable deleter
 template <class T>
 class NCConstDeleter
 {
     int state_;
     NCConstDeleter(NCConstDeleter const&);
     NCConstDeleter& operator=(NCConstDeleter const&);
 public:
 
     NCConstDeleter() : state_(0) {}
     explicit NCConstDeleter(int s) : state_(s) {}
+    NCConstDeleter& operator=(NCConstDeleter&& other)
+    {
+        return NCConstDeleter(std::move(other.state_));
+    }
+
     ~NCConstDeleter() {assert(state_ >= 0); state_ = -1;}
 
     int state() const {return state_;}
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) const {delete p;}
 };
 
 
 template <class T>
 class NCConstDeleter<T[]>
 {
     int state_;
     NCConstDeleter(NCConstDeleter const&);
     NCConstDeleter& operator=(NCConstDeleter const&);
 public:
 
     NCConstDeleter() : state_(0) {}
     explicit NCConstDeleter(int s) : state_(s) {}
+    NCConstDeleter& operator=(NCConstDeleter&& other)
+    {
+        return NCConstDeleter(std::move(other.state_));
+    }
+
     ~NCConstDeleter() {assert(state_ >= 0); state_ = -1;}
 
     int state() const {return state_;}
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) const {delete [] p;}
 };
 

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/LWG3133">3133</a></td><td>Modernizing numeric type requirements</td><td>Kona</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3144">3144</a></td><td><tt>span</tt> does not have a <tt>const_pointer</tt> typedef</td><td>Kona</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG3173">3173</a></td><td>Enable CTAD for <i><tt>ref-view</tt></i></td><td>Kona</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3179">3179</a></td><td><tt>subrange</tt> should always model <tt>Range</tt></td><td>Kona</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3180">3180</a></td><td>Inconsistently named return type for <tt>ranges::minmax_element</tt></td><td>Kona</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3182">3182</a></td><td>Specification of <tt>Same</tt> could be clearer</td><td>Kona</td><td></td></tr>
 
   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2899">2899</a></td><td><tt>is_(nothrow_)move_constructible</tt> and <tt>tuple</tt>, <tt>optional</tt> and <tt>unique_ptr</tt></td><td>Cologne</td><td></td></tr>
+  <tr><td><a href="https://wg21.link/LWG2899">2899</a></td><td><tt>is_(nothrow_)move_constructible</tt> and <tt>tuple</tt>, <tt>optional</tt> and <tt>unique_ptr</tt></td><td>Cologne</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG3055">3055</a></td><td><tt>path::operator+=(<i>single-character</i>)</tt> misspecified</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3158">3158</a></td><td><tt>tuple(allocator_arg_t, const Alloc&amp;)</tt> should be conditionally explicit</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3169">3169</a></td><td><tt>ranges</tt> permutation generators discard useful information</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3183">3183</a></td><td>Normative permission to specialize Ranges variable templates</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3184">3184</a></td><td>Inconsistencies in <tt>bind_front</tt> wording</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3185">3185</a></td><td>Uses-allocator construction functions missing <tt>constexpr</tt> and <tt>noexcept</tt></td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3186">3186</a></td><td><tt>ranges</tt> removal, partition, and <tt>partial_sort_copy</tt> algorithms discard useful information</td><td>Cologne</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3187">3187</a></td><td><a href="https://wg21.link/p0591r4">P0591R4</a> reverted DR 2586 fixes to <tt>scoped_allocator_adaptor::construct()</tt></td><td>Cologne</td><td></td></tr>