[libc++] Cleanup and enable multiple warnings.

Too many warnings are being disabled too quickly. Warnings are
important to keeping libc++ correct. This patch re-enables two
warnings: -Wconstant-evaluated and -Wdeprecated-copy.

In future, all warnings disabled for the test suite should require
an attached bug. The bug should state the plan for re-enabling that
warning, or a strong case why it should remain disabled.

libcxx/include/__bit_reference

@@ -1114,8 +1114,12 @@ public:
 #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>;
+
     _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
+    __bit_iterator(const __type_for_copy_to_const& __it) _NOEXCEPT
         : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
 
     _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT

libcxx/include/__hash_table

@@ -825,11 +825,13 @@ private:
 
     allocator_type& __na_;
 
-    __hash_node_destructor& operator=(const __hash_node_destructor&);
-
 public:
     bool __value_constructed;
 
+    __hash_node_destructor(__hash_node_destructor const&) = default;
+    __hash_node_destructor& operator=(const __hash_node_destructor&) = delete;
+
+
     _LIBCPP_INLINE_VISIBILITY
     explicit __hash_node_destructor(allocator_type& __na,
                                     bool __constructed = false) _NOEXCEPT

libcxx/include/__tree

@@ -775,11 +775,14 @@ private:
     typedef __tree_node_types<pointer> _NodeTypes;
     allocator_type& __na_;
 
-    __tree_node_destructor& operator=(const __tree_node_destructor&);
 
 public:
     bool __value_constructed;
 
+
+    __tree_node_destructor(const __tree_node_destructor &) = default;
+    __tree_node_destructor& operator=(const __tree_node_destructor&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
         : __na_(__na),

libcxx/include/ext/hash_map

@@ -318,12 +318,13 @@ private:
 
     allocator_type& __na_;
 
-    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
-
 public:
     bool __first_constructed;
     bool __second_constructed;
 
+    __hash_map_node_destructor(__hash_map_node_destructor const&) = default;
+    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&) = delete;
+
     _LIBCPP_INLINE_VISIBILITY
     explicit __hash_map_node_destructor(allocator_type& __na)
         : __na_(__na),

libcxx/include/random

@@ -6105,6 +6105,7 @@ public:
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
+        param_type(param_type const&) = default;
         param_type & operator=(const param_type& __rhs);
 
         _LIBCPP_INLINE_VISIBILITY
@@ -6428,6 +6429,7 @@ public:
         template<class _UnaryOperation>
             param_type(size_t __nw, result_type __xmin, result_type __xmax,
                        _UnaryOperation __fw);
+        param_type(param_type const&) = default;
         param_type & operator=(const param_type& __rhs);
 
         _LIBCPP_INLINE_VISIBILITY

libcxx/include/valarray

@@ -1256,6 +1256,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    slice_array(slice_array const&) = default;
+
     _LIBCPP_INLINE_VISIBILITY
     const slice_array& operator=(const slice_array& __sa) const;
 
@@ -1505,11 +1507,6 @@ public:
 
 #endif  // _LIBCPP_CXX03_LANG
 
-//  gslice(const gslice&)            = default;
-//  gslice(gslice&&)                 = default;
-//  gslice& operator=(const gslice&) = default;
-//  gslice& operator=(gslice&&)      = default;
-
     _LIBCPP_INLINE_VISIBILITY
     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
 
@@ -1645,10 +1642,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
-//  gslice_array(const gslice_array&)            = default;
-//  gslice_array(gslice_array&&)                 = default;
-//  gslice_array& operator=(const gslice_array&) = default;
-//  gslice_array& operator=(gslice_array&&)      = default;
+    gslice_array(const gslice_array&)            = default;
 
 private:
     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
@@ -1977,17 +1971,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    mask_array(const mask_array&) = default;
+
     _LIBCPP_INLINE_VISIBILITY
     const mask_array& operator=(const mask_array& __ma) const;
 
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
-//  mask_array(const mask_array&)            = default;
-//  mask_array(mask_array&&)                 = default;
-//  mask_array& operator=(const mask_array&) = default;
-//  mask_array& operator=(mask_array&&)      = default;
-
 private:
     _LIBCPP_INLINE_VISIBILITY
     mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
@@ -2336,17 +2327,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    indirect_array(const indirect_array&) = default;
+
     _LIBCPP_INLINE_VISIBILITY
     const indirect_array& operator=(const indirect_array& __ia) const;
 
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
-//  indirect_array(const indirect_array&)            = default;
-//  indirect_array(indirect_array&&)                 = default;
-//  indirect_array& operator=(const indirect_array&) = default;
-//  indirect_array& operator=(indirect_array&&)      = default;
-
 private:
      _LIBCPP_INLINE_VISIBILITY
    indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)

libcxx/test/libcxx/containers/sequences/vector/asan_throw.pass.cpp

@@ -50,6 +50,7 @@ public:
             throw 0;
         }
     }
+    ThrowOnCopy& operator=(ThrowOnCopy const&) = default;
 
     bool should_throw;
 };

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.fail.cpp

@@ -24,6 +24,7 @@ int main(int, char**)
 #else
   // expected-error@+1 {{static_assert failed}}
   static_assert(!std::is_constant_evaluated(), "");
+  // expected-error@-1 0-1 {{'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression}}
 #endif
   return 0;
 }

libcxx/test/std/utilities/meta/meta.const.eval/is_constant_evaluated.pass.cpp

@@ -23,6 +23,12 @@
 #endif
 #endif
 
+// Disable the tautological constant evaluation warnings for this test,
+// because it's explicitly testing those cases.
+#if TEST_HAS_WARNING("-Wconstant-evaluated") && defined(__clang__)
+#pragma clang diagnostic ignored "-Wconstant-evaluated"
+#endif
+
 template <bool> struct InTemplate {};
 
 int main(int, char**)

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp

@@ -30,6 +30,7 @@ struct X
         if (throw_now)
             TEST_THROW(6);
     }
+    X& operator=(X const&) = default;
 };
 
 bool X::throw_now = false;

libcxx/test/support/test_macros.h

@@ -47,6 +47,12 @@
 #define TEST_HAS_EXTENSION(X) 0
 #endif
 
+#ifdef __has_warning
+#define TEST_HAS_WARNING(X) __has_warning(X)
+#else
+#define TEST_HAS_WARNING(X) 0
+#endif
+
 #ifdef __has_builtin
 #define TEST_HAS_BUILTIN(X) __has_builtin(X)
 #else

libcxx/utils/libcxx/test/config.py

@@ -917,8 +917,6 @@ class Configuration(object):
         self.cxx.addWarningFlagIfSupported('-Wshadow')
         self.cxx.addWarningFlagIfSupported('-Wno-unused-command-line-argument')
         self.cxx.addWarningFlagIfSupported('-Wno-attributes')
-        self.cxx.addWarningFlagIfSupported('-Wno-deprecated-copy')
-        self.cxx.addWarningFlagIfSupported('-Wno-constant-evaluated')
         self.cxx.addWarningFlagIfSupported('-Wno-pessimizing-move')
         self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
         self.cxx.addWarningFlagIfSupported('-Wno-user-defined-literals')