[libc++] Enable modernize-use-equals-delete

[Mordante]

Thanks for working on these cleanups! In general LGTM when the CI passes.

libcxx/include/future

1628

As a note for other followup patches. I prefer these clang-tidy improvements not to do other cleanups in the same patch. I would prefer to see that in different patches. This makes reviewing them easier.

[• Quuxplusone]

libcxx/include/__functional/function.h

264

FWIW, my personal style on the OOP polymorphic types like __base (where they are clearly just abstract base classes with lots of pure virtual methods) is not to bother with the special member functions at all. Nobody's seriously going to be value-semantic-copying this type, so why waste the two LoC preventing it?
But I see the "guardrail against accidental copying" argument, so I'm not asking to change this (unless my comment happens to start a new consensus :)).

libcxx/include/__functional/reference_wrapper.h

37–38

Eliminate the NOLINT comment and just make these two declarations public; it can't hurt.
(I agree that 54276 is a real bug, though.)

Ditto in ref_view below.

libcxx/include/iosfwd

287

Stylistically, I'd prefer to see these placed between new lines 278 and 279, so it goes "ctors, assignment operators, dtors." Ditto throughout (at least in the cases where you're already shuffling code around).

libcxx/include/tuple

363–365

Consider west-consting line 363 at the same time, and also doing something explicitly about __tuple_leaf& operator=(__tuple_leaf&&). I actually don't know off the top of my head what happens to it right now.

[EricWF]

Are we sure this doesn't break the ABI because changing user declared constructors into delete constructors can do that, Can't it?

[philnik]

In D121213#3368838, @EricWF wrote:

Are we sure this doesn't break the ABI because changing user declared constructors into delete constructors can do that, Can't it?

How could it change the ABI? The functions can never be called, and it doesn't change any type traits AFAIK. It's not like with = default that the type could be trivially_something after the change that it wasn't before.

[EricWF]

In D121213#3368882, @philnik wrote:

In D121213#3368838, @EricWF wrote:

Are we sure this doesn't break the ABI because changing user declared constructors into delete constructors can do that, Can't it?

How could it change the ABI? The functions can never be called, and it doesn't change any type traits AFAIK. It's not like with = default that the type could be trivially_something after the change that it wasn't before.

From the Itanium C++ ABI Specification:

non-trivial for the purposes of calls

A type is considered non-trivial for the purposes of calls if:

• it has a non-trivial copy constructor, move constructor, or destructor, or
• all of its copy and move constructors are deleted.

This definition, as applied to class types, is intended to be the complement of the definition in [class.temporary]p3 of types for which an extra temporary is allowed when passing or returning a type. A type which is trivial for the purposes of the ABI will be passed and returned according to the rules of the base C ABI, e.g. in registers; often this has the effect of performing a > trivial copy of the type.

[philnik]

@EricWF And in what scenario would that change the ABI? If there are no copy- or move-constructors, then all are deleted by definition, and if there is one it isn't trivial.

[• Quuxplusone]

In D121213#3369677, @philnik wrote:

@EricWF And in what scenario would that change the ABI? If there are no copy- or move-constructors, then all are deleted by definition, and if there is one it isn't trivial.

@philnik: Eric is at least partly correct (and your original goalpost was wrong): this transformation can definitely change the is_trivially_fooable properties of the type. However, I haven't yet been able to get this to cause an actual calling-convention difference. https://godbolt.org/z/d17PM8dWc It seems to me that the wording Eric quoted was probably designed precisely to prevent the breakage Eric is concerned about! It basically says, "Deleted SMFs don't affect triviality, unless you're using deleted SMFs to replicate the old C++98 trick of declare-but-not-defining all your SMFs. If all your SMFs are deleted, then we'll assume you still want to be non-trivial for the purposes of calls."
So I believe Eric is correct about the possibility of breakage here, and I think you should go look at the triviality-for-purposes-of-calls of all of the affected classes (i.e., don't just trust clang-tidy's mechanical change; go through it line by line). I predict you'll find that every affected class is either still non-trivial for other reasons (e.g. virtual dtor), or is a detail type like __save_flags where we don't care about its triviality. But yeah, Eric's convinced me that we shouldn't just assume this is safe.

[ldionne]

The important bit is this (emphasis mine):

A type is considered non-trivial for the purposes of calls if:

• it has a non-trivial copy constructor, move constructor, or destructor, or
• all of its copy and move constructors are deleted.

I went through all the changes in this patch, and I think the key question we need an answer to is:

When a copy assignment operator or copy constructor is explicitly deleted, there is no implicit move constructor generated by the compiler. But does the compiler not declare any move constructor, or does it declare one and mark it as deleted? I wasn't able to find out by reading http://eel.is/c++draft/class.copy.ctor, but it may be easy to answer for others here.

This is relevant because some classes go from having a user-declared private operator=(T const&) to having a deleted one. I believe it's possible for such a type to be trivial for the purpose of calls. However, if we change it to operator(T const&) = delete and the compiler then implicitly declares T(T const&) = delete, we'd go from trivial to non-trivial.

Anyway, I've left some not-done comments on the ones where I'm not 100% confident that this patch isn't changing behavior. I suspect it is correct, I just need to understand why.

Note: In my review, TFPC stands for "Trivial For the Purpose of Call"

libcxx/include/__bit_reference

159

I'm not sure about this one, see question.

libcxx/include/__functional/function.h

262

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/__locale

61

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/__split_buffer

76

Code was not TFPC, and isn't after patch because we have a move ctor but it is user-defined.

libcxx/include/deque

1042

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/forward_list

516

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/future

1623

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/iosfwd

286

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/list

527

Can we move these down near the other constructors?

529

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/locale

3652

Code was not TFPC before, and it's not after because there's a user-defined destructor.

3924

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/map

692

I'm not sure about this one. I think it was TFPC before the patch, because there were no copy/move ctors declared.

After the patch, there shouldn't be any copy/move ctor declared unless the compiler declares them as deleted, in which case it would become non-TFPC.

libcxx/include/regex

1433

Code was not TFPC before, and it's not after because there's a user-defined destructor.

2210

I'm not sure about this one, see question.

2251

I'm not sure about this one, see question.

2293

I'm not sure about this one, see question.

2349

I'm not sure about this one, see question.

3147

I'm not sure about this one, see question.

libcxx/include/thread

153

Code was not TFPC before, and it's not after because there's a user-defined destructor.

libcxx/include/tuple

301

This one has defaulted copy and move constructors, so this won't change triviality.

363

This one has defaulted copy and move constructors, so this won't change triviality.

libcxx/include/unordered_map

780

This one is not TFPC before and not TFPC after because it has user-defined copy/move ctors.

libcxx/include/vector

787

Code was not TFPC before, and it's not after because there's a user-defined destructor.

Also this type should not be ABI affecting, but w/e.

[philnik]

In D121213#3392906, @ldionne wrote:

The important bit is this (emphasis mine):

A type is considered non-trivial for the purposes of calls if:

• it has a non-trivial copy constructor, move constructor, or destructor, or
• all of its copy and move constructors are deleted.

I went through all the changes in this patch, and I think the key question we need an answer to is:

When a copy assignment operator or copy constructor is explicitly deleted, there is no implicit move constructor generated by the compiler. But does the compiler not declare any move constructor, or does it declare one and mark it as deleted? I wasn't able to find out by reading http://eel.is/c++draft/class.copy.ctor, but it may be easy to answer for others here.
This is relevant because some classes go from having a user-declared private operator=(T const&) to having a deleted one. I believe it's possible for such a type to be trivial for the purpose of calls. However, if we change it to operator(T const&) = delete and the compiler then implicitly declares T(T const&) = delete, we'd go from trivial to non-trivial.

I think the compiler doesn't declare one. The explicitly deleted copy constructor counts as a user-declated constructor, which means that no move constructor will be declared. Deleting a copy assignment operator also doesn't delete the copy constructor (https://godbolt.org/z/hc18qhfv1), so that part shouldn't matter.

[ldionne]

I just looked at everything again with the understanding that adding a *copy* assignment operator doesn't have any impact on the generation of a copy constructor by the compiler (which frankly is bonkers), and I think this patch is correct without a doubt. The rules are just crazy though.

Can you rebase this onto main, make sure the CI is green and ship this? Please ping me again if you need to add any additional = deletes to this patch, I'll want to look again. This is kinda subtle and has the potential for a super subtle ABI break if gotten wrong.

libcxx/include/__bit_reference

159

Since this only touches operator=, this can't affect TFPC-ness.

libcxx/include/map

692

Since this only touches operator=, this can't affect TFPC-ness.

[philnik]

Rebased

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Rebased

[philnik]

Try to fix CI

libcxx/.clang-tidy

 InheritParentConfig: true
 Checks: >
   bugprone-copy-constructor-init,
   bugprone-dangling-handle,
   bugprone-infinite-loop,
 
   -llvm-else-after-return,
   -llvm-header-guard,
   -llvm-qualified-auto,
 
   -misc-unconventional-assign-operator,
 
   modernize-redundant-void-arg,
+  modernize-use-equals-delete,
 
   readability-duplicate-include,
   readability-function-cognitive-complexity,
   readability-function-size,
   -readability-identifier-naming,
   readability-misplaced-array-index,
   readability-redundant-control-flow,
   readability-redundant-function-ptr-dereference,

 # TODO: investigate these checks
 # bugprone-branch-clone,
 # bugprone-macro-parentheses,
 # cppcoreguidelines-prefer-member-initializer,
 # modernize-loop-convert,
 # modernize-use-bool-literals,
 # modernize-use-default-member-init,
 # modernize-use-equals-default,
-# modernize-use-equals-delete,
 # modernize-use-nullptr,
 # modernize-use-override,
 # portability-restrict-system-includes,
 # readability-function-cognitive-complexity,
 # readability-implicit-bool-conversion,
 # readability-isolate-declaration,
 # readability-redundant-access-specifiers,
 # readability-redundant-declaration,
 # readability-redundant-member-init,
 # readability-simplify-boolean-expr,

libcxx/include/__bit_reference

 public:
     _LIBCPP_INLINE_VISIBILITY
     __bit_const_reference(const __bit_const_reference&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
         : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
 
+    __bit_const_reference& operator=(const __bit_const_reference&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
         {return static_cast<bool>(*__seg_ & __mask_);}
 
     _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
         {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
         : __seg_(__s), __mask_(__m) {}
-
-    __bit_const_reference& operator=(const __bit_const_reference&) = delete;
 };
 
 // find
 
 template <class _Cp, bool _IsConst>
 __bit_iterator<_Cp, _IsConst>
 __find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
 {

libcxx/include/__functional/function.h

 
 // __base provides an abstract interface for copyable functors.
 
 template<class _Fp> class _LIBCPP_TEMPLATE_VIS __base;
 
 template<class _Rp, class ..._ArgTypes>
 class __base<_Rp(_ArgTypes...)>
 {
-    __base(const __base&);
-    __base& operator=(const __base&);
 public:
+    __base(const __base&) = delete;
+    __base& operator=(const __base&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY __base() {}
     _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
     virtual __base* __clone() const = 0;
     virtual void __clone(__base*) const = 0;
     virtual void destroy() _NOEXCEPT = 0;
     virtual void destroy_deallocate() _NOEXCEPT = 0;
     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 #ifndef _LIBCPP_NO_RTTI

libcxx/include/__functional/reference_wrapper.h

 #endif
 {
 public:
     // types
     typedef _Tp type;
 private:
     type* __f_;
 
     static void __fun(_Tp&) _NOEXCEPT;
-    static void __fun(_Tp&&) = delete;
+    static void __fun(_Tp&&) = delete; // NOLINT(modernize-use-equals-delete) ; This is llvm.org/PR54276
 
 public:
     template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>())) > >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) {
         type& __f = static_cast<_Up&&>(__u);
         __f_ = _VSTD::addressof(__f);
     }

libcxx/include/__locale

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
 struct __libcpp_locale_guard {
   _LIBCPP_INLINE_VISIBILITY
   __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
 
+  __libcpp_locale_guard(__libcpp_locale_guard const&) = delete;
+  __libcpp_locale_guard& operator=(__libcpp_locale_guard const&) = delete;
+
   _LIBCPP_INLINE_VISIBILITY
   ~__libcpp_locale_guard() {
     if (__old_loc_)
       uselocale(__old_loc_);
   }
 
   locale_t __old_loc_;
-private:
-  __libcpp_locale_guard(__libcpp_locale_guard const&);
-  __libcpp_locale_guard& operator=(__libcpp_locale_guard const&);
 };
 #elif defined(_LIBCPP_MSVCRT_LIKE)
 struct __libcpp_locale_guard {
     __libcpp_locale_guard(locale_t __l) :
         __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {
       // Setting the locale can be expensive even when the locale given is
       // already the current locale, so do an explicit check to see if the
       // current locale is already the one we want.

libcxx/include/__mutex_base

 class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable)
 lock_guard
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type& __m_;
-public:
 
+public:
     _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
     explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
         : __m_(__m) {__m_.lock();}
 
     _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
-private:
     lock_guard(lock_guard const&) = delete;
     lock_guard& operator=(lock_guard const&) = delete;
 };
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS unique_lock
 {
 public:

libcxx/include/__ranges/ref_view.h

 
 namespace ranges {
   template<range _Range>
     requires is_object_v<_Range>
   class ref_view : public view_interface<ref_view<_Range>> {
     _Range *__range_;
 
     static void __fun(_Range&);
-    static void __fun(_Range&&) = delete;
+    static void __fun(_Range&&) = delete; // NOLINT(modernize-use-equals-delete) ; This is llvm.org/PR54276
 
 public:
     template<class _Tp>
       requires __different_from<_Tp, ref_view> &&
         convertible_to<_Tp, _Range&> && requires { __fun(declval<_Tp>()); }
     _LIBCPP_HIDE_FROM_ABI
     constexpr ref_view(_Tp&& __t)
       : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))

libcxx/include/__split_buffer

 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
 struct __split_buffer
 {
-private:
-    __split_buffer(const __split_buffer&);
-    __split_buffer& operator=(const __split_buffer&);
 public:
     typedef _Tp                                             value_type;
     typedef _Allocator                                      allocator_type;
     typedef typename remove_reference<allocator_type>::type __alloc_rr;
     typedef allocator_traits<__alloc_rr>                    __alloc_traits;
     typedef value_type&                                     reference;
     typedef const value_type&                               const_reference;
     typedef typename __alloc_traits::size_type              size_type;
public:
     __split_buffer(__split_buffer&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
     __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
     __split_buffer& operator=(__split_buffer&& __c)
         _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
                 is_nothrow_move_assignable<allocator_type>::value) ||
                !__alloc_traits::propagate_on_container_move_assignment::value);
 
+    __split_buffer(const __split_buffer&) = delete;
+    __split_buffer& operator=(const __split_buffer&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY       iterator begin() _NOEXCEPT       {return __begin_;}
     _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
     _LIBCPP_INLINE_VISIBILITY       iterator end() _NOEXCEPT         {return __end_;}
     _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT   {return __end_;}
 
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT
         {__destruct_at_end(__begin_);}

libcxx/include/__tree

public:
     _LIBCPP_INLINE_VISIBILITY
     pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_parent(pointer __p) {
         __parent_ = static_cast<__parent_pointer>(__p);
     }
 
-private:
     ~__tree_node_base() = delete;
     __tree_node_base(__tree_node_base const&) = delete;
     __tree_node_base& operator=(__tree_node_base const&) = delete;
 };
 
 template <class _Tp, class _VoidPtr>
 class _LIBCPP_STANDALONE_DEBUG __tree_node
     : public __tree_node_base<_VoidPtr>
 {
 public:
     typedef _Tp __node_value_type;
 
     __node_value_type __value_;
 
-private:
     ~__tree_node() = delete;
     __tree_node(__tree_node const&) = delete;
     __tree_node& operator=(__tree_node const&) = delete;
 };
 
 
 template <class _Allocator>
 class __tree_node_destructor
 {
     typedef _Allocator                                      allocator_type;
     typedef allocator_traits<allocator_type>                __alloc_traits;

libcxx/include/deque

while (__n > 0)
         __l -= __bs - 1;
     }
     return __r;
 }
 
 template <class _Tp, class _Allocator>
 class __deque_base
 {
-    __deque_base(const __deque_base& __c);
-    __deque_base& operator=(const __deque_base& __c);
 public:
     typedef _Allocator                                allocator_type;
     typedef allocator_traits<allocator_type>          __alloc_traits;
     typedef typename __alloc_traits::size_type        size_type;
 
     typedef _Tp                                       value_type;
     typedef value_type&                               reference;
     typedef const value_type&                         const_reference;
protected:
     const allocator_type& __alloc() const _NOEXCEPT {return __size_.second();}
 
     _LIBCPP_INLINE_VISIBILITY
     __deque_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
     _LIBCPP_INLINE_VISIBILITY
     explicit __deque_base(const allocator_type& __a);
 public:
+    __deque_base(const __deque_base& __c) = delete;
+    __deque_base& operator=(const __deque_base& __c) = delete;
     ~__deque_base();
 
 #ifndef _LIBCPP_CXX03_LANG
     __deque_base(__deque_base&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
     __deque_base(__deque_base&& __c, const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 

libcxx/include/forward_list

__forward_list_base()
         _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
         : __before_begin_(__begin_node(), __default_init_tag()) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const allocator_type& __a)
         : __before_begin_(__begin_node(), __node_allocator(__a)) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __forward_list_base(const __node_allocator& __a)
         : __before_begin_(__begin_node(), __a) {}
-#ifndef _LIBCPP_CXX03_LANG
+
 public:
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
     _LIBCPP_INLINE_VISIBILITY
     __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 
-private:
-    __forward_list_base(const __forward_list_base&);
-    __forward_list_base& operator=(const __forward_list_base&);
+    __forward_list_base(const __forward_list_base&) = delete;
+    __forward_list_base& operator=(const __forward_list_base&) = delete;
 
-public:
     ~__forward_list_base();
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     void __copy_assign_alloc(const __forward_list_base& __x)
         {__copy_assign_alloc(__x, integral_constant<bool,
               __node_traits::propagate_on_container_copy_assignment::value>());}
 

libcxx/include/future

 
 // packaged_task
 
 template<class _Fp> class __packaged_task_base;
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
 {
-    __packaged_task_base(const __packaged_task_base&);
-    __packaged_task_base& operator=(const __packaged_task_base&);
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_base() {}
-    _LIBCPP_INLINE_VISIBILITY
-    virtual ~__packaged_task_base() {}
+    _LIBCPP_HIDE_FROM_ABI __packaged_task_base() {}
+    _LIBCPP_HIDE_FROM_ABI virtual ~__packaged_task_base() {}
+    __packaged_task_base(const __packaged_task_base&) = delete;
+    __packaged_task_base& operator=(const __packaged_task_base&) = delete;
+
     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
     virtual void destroy() = 0;
     virtual void destroy_deallocate() = 0;
     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 };
 
 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
 

libcxx/include/iosfwd

 {
     typedef basic_ios<_CharT, _Traits> __stream_type;
     typedef typename __stream_type::fmtflags fmtflags;
 
     __stream_type& __stream_;
     fmtflags       __fmtflags_;
     _CharT         __fill_;
 
-    __save_flags(const __save_flags&);
-    __save_flags& operator=(const __save_flags&);
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __save_flags(__stream_type& __stream)
         : __stream_(__stream),
           __fmtflags_(__stream.flags()),
           __fill_(__stream.fill())
         {}
     _LIBCPP_INLINE_VISIBILITY
     ~__save_flags()
     {
         __stream_.flags(__fmtflags_);
         __stream_.fill(__fill_);
     }
+
+    __save_flags(const __save_flags&) = delete;
+    __save_flags& operator=(const __save_flags&) = delete;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_IOSFWD

libcxx/include/istream

protected:
     basic_istream& operator=(basic_istream&& __rhs);
 
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     void swap(basic_istream& __rhs) {
       _VSTD::swap(__gc_, __rhs.__gc_);
       basic_ios<char_type, traits_type>::swap(__rhs);
     }
 
+public:
     basic_istream           (const basic_istream& __rhs) = delete;
     basic_istream& operator=(const basic_istream& __rhs) = delete;
-public:
 
     // 27.7.1.1.3 Prefix/suffix:
     class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.1.2 Formatted input:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
     { return __pf(*this); }

libcxx/include/list

#endif // _LIBCPP_DEBUG_LEVEL == 2
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
         {return !(__x == __y);}
 };
 
 template <class _Tp, class _Alloc>
 class __list_imp
 {
-    __list_imp(const __list_imp&);
-    __list_imp& operator=(const __list_imp&);
 public:
+    __list_imp(const __list_imp&) = delete;
+    __list_imp& operator=(const __list_imp&) = delete;
+
     typedef _Alloc                                                  allocator_type;
     typedef allocator_traits<allocator_type>                        __alloc_traits;
     typedef typename __alloc_traits::size_type                      size_type;
 protected:
     typedef _Tp                                                     value_type;
     typedef typename __alloc_traits::void_pointer                   __void_pointer;
     typedef __list_iterator<value_type, __void_pointer>             iterator;
     typedef __list_const_iterator<value_type, __void_pointer>       const_iterator;

libcxx/include/locale

 
 private:
     byte_string __byte_err_string_;
     wide_string __wide_err_string_;
     _Codecvt* __cvtptr_;
     state_type __cvtstate_;
     size_t __cvtcount_;
 
-    wstring_convert(const wstring_convert& __wc);
-    wstring_convert& operator=(const wstring_convert& __wc);
 public:
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert() : wstring_convert(new _Codecvt) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit wstring_convert(_Codecvt* __pcvt);
 #else
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_EXPLICIT_AFTER_CXX11
     wstring_convert(_Codecvt* __pcvt = new _Codecvt);
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(_Codecvt* __pcvt, state_type __state);
     _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(wstring_convert&& __wc);
 #endif
     ~wstring_convert();
 
+    wstring_convert(const wstring_convert& __wc) = delete;
+    wstring_convert& operator=(const wstring_convert& __wc) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     wide_string from_bytes(char __byte)
         {return from_bytes(&__byte, &__byte+1);}
     _LIBCPP_INLINE_VISIBILITY
     wide_string from_bytes(const char* __ptr)
         {return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
     _LIBCPP_INLINE_VISIBILITY
     wide_string from_bytes(const byte_string& __str)
private:
     streambuf* __bufptr_;
     _Codecvt* __cv_;
     state_type __st_;
     ios_base::openmode __cm_;
     bool __owns_eb_;
     bool __owns_ib_;
     bool __always_noconv_;
 
-    wbuffer_convert(const wbuffer_convert&);
-    wbuffer_convert& operator=(const wbuffer_convert&);
-
 public:
 #ifndef _LIBCPP_CXX03_LANG
     wbuffer_convert() : wbuffer_convert(nullptr) {}
     explicit wbuffer_convert(streambuf* __bytebuf,
                              _Codecvt* __pcvt = new _Codecvt,
                              state_type __state = state_type());
 #else
     _LIBCPP_EXPLICIT_AFTER_CXX11
     wbuffer_convert(streambuf* __bytebuf = nullptr,
                     _Codecvt* __pcvt = new _Codecvt,
                     state_type __state = state_type());
 #endif
 
     ~wbuffer_convert();
 
+    wbuffer_convert(const wbuffer_convert&) = delete;
+    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf() const {return __bufptr_;}
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf(streambuf* __bytebuf)
     {
         streambuf* __r = __bufptr_;
         __bufptr_ = __bytebuf;
         return __r;

libcxx/include/map

class __map_node_destructor
     typedef allocator_traits<allocator_type>    __alloc_traits;
 
 public:
     typedef typename __alloc_traits::pointer    pointer;
 
 private:
     allocator_type& __na_;
 
-    __map_node_destructor& operator=(const __map_node_destructor&);
-
 public:
     bool __first_constructed;
     bool __second_constructed;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __map_node_destructor(allocator_type& __na) _NOEXCEPT
         : __na_(__na),
           __first_constructed(false),
           __second_constructed(false)
         {}
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     __map_node_destructor(__tree_node_destructor<allocator_type>&& __x) _NOEXCEPT
         : __na_(__x.__na_),
           __first_constructed(__x.__value_constructed),
           __second_constructed(__x.__value_constructed)
         {
             __x.__value_constructed = false;
         }
 #endif // _LIBCPP_CXX03_LANG
 
+    __map_node_destructor& operator=(const __map_node_destructor&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__second_constructed)
             __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
         if (__first_constructed)
             __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
         if (__p)
template <class _ValueTp,
              >
     _LIBCPP_INLINE_VISIBILITY
     __value_type& operator=(_ValueTp&& __v)
     {
         __ref() = _VSTD::forward<_ValueTp>(__v);
         return *this;
     }
 
-private:
     __value_type() = delete;
     ~__value_type() = delete;
     __value_type(const __value_type&) = delete;
     __value_type(__value_type&&) = delete;
 };
 
 #else
 

libcxx/include/ostream

public:
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // 27.7.2.2 Constructor/destructor:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
     { this->init(__sb); }
     virtual ~basic_ostream();
+
+    basic_ostream           (const basic_ostream& __rhs) = delete;
+    basic_ostream& operator=(const basic_ostream& __rhs) = delete;
+
 protected:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream(basic_ostream&& __rhs);
 
     // 27.7.2.3 Assign/swap
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
 
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     void swap(basic_ostream& __rhs)
     { basic_ios<char_type, traits_type>::swap(__rhs); }
 
-    basic_ostream           (const basic_ostream& __rhs) = delete;
-    basic_ostream& operator=(const basic_ostream& __rhs) = delete;
-
 public:
     // 27.7.2.4 Prefix/suffix:
     class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.2.6 Formatted output:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
     { return __pf(*this); }

libcxx/include/regex

__state()
           __node_(nullptr), __flags_() {}
 };
 
 // __node
 
 template <class _CharT>
 class __node
 {
-    __node(const __node&);
-    __node& operator=(const __node&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __node() {}
     _LIBCPP_INLINE_VISIBILITY
     virtual ~__node() {}
 
+    __node(const __node&) = delete;
+    __node& operator=(const __node&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     virtual void __exec(__state&) const {}
     _LIBCPP_INLINE_VISIBILITY
     virtual void __exec_split(bool, __state&) const {}
 };
 
 // __end_state
 

 template <class _CharT>
 class __match_char
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _CharT __c_;
 
-    __match_char(const __match_char&);
-    __match_char& operator=(const __match_char&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char(_CharT __c, __node<_CharT>* __s)
         : base(__s), __c_(__c) {}
 
+    __match_char(const __match_char&) = delete;
+    __match_char& operator=(const __match_char&) = delete;
+
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __match_char<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_)

 class __match_char_icase
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     _CharT __c_;
 
-    __match_char_icase(const __match_char_icase&);
-    __match_char_icase& operator=(const __match_char_icase&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
 
+    __match_char_icase(const __match_char_icase&) = delete;
+    __match_char_icase& operator=(const __match_char_icase&) = delete;
+
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __match_char_icase<_CharT, _Traits>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ &&

 class __match_char_collate
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     _CharT __c_;
 
-    __match_char_collate(const __match_char_collate&);
-    __match_char_collate& operator=(const __match_char_collate&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
 
+    __match_char_collate(const __match_char_collate&) = delete;
+    __match_char_collate& operator=(const __match_char_collate&) = delete;
+
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __match_char_collate<_CharT, _Traits>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ &&
class __bracket_expression
     vector<string_type> __equivalences_;
     typename regex_traits<_CharT>::char_class_type __mask_;
     typename regex_traits<_CharT>::char_class_type __neg_mask_;
     bool __negate_;
     bool __icase_;
     bool __collate_;
     bool __might_have_digraph_;
 
-    __bracket_expression(const __bracket_expression&);
-    __bracket_expression& operator=(const __bracket_expression&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
                                  bool __negate, bool __icase, bool __collate)
         : base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
           __negate_(__negate), __icase_(__icase), __collate_(__collate),
           __might_have_digraph_(__traits_.getloc().name() != "C") {}
 
+    __bracket_expression(const __bracket_expression&) = delete;
+    __bracket_expression& operator=(const __bracket_expression&) = delete;
+
     virtual void __exec(__state&) const;
 
     _LIBCPP_INLINE_VISIBILITY
     bool __negated() const {return __negate_;}
 
     _LIBCPP_INLINE_VISIBILITY
     void __add_char(_CharT __c)
         {
class __lookahead
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     basic_regex<_CharT, _Traits> __exp_;
     unsigned __mexp_;
     bool __invert_;
 
-    __lookahead(const __lookahead&);
-    __lookahead& operator=(const __lookahead&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef __state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
         : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
 
+    __lookahead(const __lookahead&) = delete;
+    __lookahead& operator=(const __lookahead&) = delete;
+
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __lookahead<_CharT, _Traits>::__exec(__state& __s) const
 {
     match_results<const _CharT*> __m;

libcxx/include/thread

class __thread_specific_ptr
     __libcpp_tls_key __key_;
 
      // Only __thread_local_data() may construct a __thread_specific_ptr
      // and only with _Tp == __thread_struct.
     static_assert((is_same<_Tp, __thread_struct>::value), "");
     __thread_specific_ptr();
     friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
 
-    __thread_specific_ptr(const __thread_specific_ptr&);
-    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
-
     _LIBCPP_HIDDEN static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*);
 
 public:
     typedef _Tp* pointer;
 
     ~__thread_specific_ptr();
 
+    __thread_specific_ptr(const __thread_specific_ptr&) = delete;
+    __thread_specific_ptr& operator=(const __thread_specific_ptr&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     pointer get() const {return static_cast<_Tp*>(__libcpp_tls_get(__key_));}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator*() const {return *get();}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const {return get();}
     void set_pointer(pointer __p);
 };

libcxx/include/tuple

class __tuple_leaf
     static constexpr bool __can_bind_reference() {
 #if __has_keyword(__reference_binds_to_temporary)
       return !__reference_binds_to_temporary(_Hp, _Tp);
 #else
       return true;
 #endif
     }
 
-    _LIBCPP_CONSTEXPR_AFTER_CXX11
-    __tuple_leaf& operator=(const __tuple_leaf&);
 public:
     _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
        {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY constexpr
template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : __value_(_VSTD::forward<_Tp>(__t), __a)
         {static_assert(!is_reference<_Hp>::value,
            "Attempted to uses-allocator construct a reference element in a tuple");}
 
     __tuple_leaf(const __tuple_leaf& __t) = default;
     __tuple_leaf(__tuple_leaf&& __t) = default;
+    __tuple_leaf& operator=(const __tuple_leaf&) = delete;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
-        _VSTD::swap(*this, __t);
+        std::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return __value_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
 };
 
 template <size_t _Ip, class _Hp>
 class __tuple_leaf<_Ip, _Hp, true>
     : private _Hp
 {
-    _LIBCPP_CONSTEXPR_AFTER_CXX11
-    __tuple_leaf& operator=(const __tuple_leaf&);
 public:
     _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
 
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 
template <class _Tp, class _Alloc>
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
             : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY constexpr
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
     __tuple_leaf(__tuple_leaf const &) = default;
     __tuple_leaf(__tuple_leaf &&) = default;
+    __tuple_leaf& operator=(const __tuple_leaf&) = delete;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int
     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
-        _VSTD::swap(*this, __t);
+        std::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 };
 
 template <class ..._Tp>

libcxx/include/unordered_map

 
 template <class _Alloc>
 class __hash_map_node_destructor
 {
     typedef _Alloc                              allocator_type;
     typedef allocator_traits<allocator_type>    __alloc_traits;
 
 public:
-
     typedef typename __alloc_traits::pointer       pointer;
-private:
 
+private:
     allocator_type& __na_;
 
-    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
-
 public:
     bool __first_constructed;
     bool __second_constructed;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT
         : __na_(__na),
           __first_constructed(false),
__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
         : __na_(__x.__na_),
           __first_constructed(__x.__value_constructed),
           __second_constructed(__x.__value_constructed)
         {
             const_cast<bool&>(__x.__value_constructed) = false;
         }
 #endif // _LIBCPP_CXX03_LANG
 
+    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__second_constructed)
             __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
         if (__first_constructed)
             __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
         if (__p)
template <class _ValueTp,
              >
     _LIBCPP_INLINE_VISIBILITY
     __hash_value_type& operator=(_ValueTp&& __v)
     {
         __ref() = _VSTD::forward<_ValueTp>(__v);
         return *this;
     }
 
-private:
     __hash_value_type(const __hash_value_type& __v) = delete;
     __hash_value_type(__hash_value_type&& __v) = delete;
     template <class ..._Args>
     explicit __hash_value_type(_Args&& ...__args) = delete;
 
     ~__hash_value_type() = delete;
 };
 

libcxx/include/vector

#endif
 
   struct _ConstructTransaction {
     explicit _ConstructTransaction(vector &__v, size_type __n)
       : __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
 #ifndef _LIBCPP_HAS_NO_ASAN
       __v_.__annotate_increase(__n);
 #endif
     }
+
     ~_ConstructTransaction() {
       __v_.__end_ = __pos_;
 #ifndef _LIBCPP_HAS_NO_ASAN
       if (__pos_ != __new_end_) {
         __v_.__annotate_shrink(__new_end_ - __v_.__begin_);
       }
 #endif
     }
 
+    _ConstructTransaction(_ConstructTransaction const&) = delete;
+    _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
+
     vector &__v_;
     pointer __pos_;
     const_pointer const __new_end_;
-
-  private:
-    _ConstructTransaction(_ConstructTransaction const&) = delete;
-    _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
   };
 
   template <class ..._Args>
   _LIBCPP_INLINE_VISIBILITY
   void __construct_one_at_end(_Args&& ...__args) {
     _ConstructTransaction __tx(*this, 1);
     __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_),
         _VSTD::forward<_Args>(__args)...);