[libc++] Enable more warnings in the test suite

[philnik]

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

109–111

@Mordante These test-cases look completely redundant to me. Do you know why you added them?

[philnik]

• Fix CI

[jloser]

libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp

242

This, and below, no longer check the return value of std::visit call is the correct value. Isn't that more or less the whole point of this test?

[philnik]

libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp

242

Look closer :). This checks that 42 == 42. This uses the opertor,. std::visit returns void in these cases.

[jloser]

libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp

242

Ah, got it. Thanks!

[jloser]

Seems reasonable to me (LGTM) once CI is green.

[philnik]

• Try to fix CI

[philnik]

• Next try

[philnik]

• Next try

[Mordante]

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

109–111

What do you mean with redundant?

libcxx/test/std/language.support/support.start.term/quick_exit.pass.cpp

26

Not your change, but it looks like we're not testing anything in this test.

[philnik]

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

109–111

Aren't throw() and noexcept specifications indistinguishable? (Same for noexcept and noexcept(true), but these don't produce warnings)

libcxx/test/std/language.support/support.start.term/quick_exit.pass.cpp

26

I'll add an assert(false).

libcxx/include/__format/format_error.h

 #if _LIBCPP_STD_VER > 17
 
 class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
       : runtime_error(__s) {}
+  format_error(const format_error&) = default;
+  format_error& operator=(const format_error&) = default;
   virtual ~format_error() noexcept;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
 __throw_format_error(const char* __s) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
   throw format_error(__s);
 #else

libcxx/include/__memory/shared_ptr.h

 }
 
 class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
     : public std::exception
 {
 public:
     bad_weak_ptr() _NOEXCEPT = default;
     bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
+    bad_weak_ptr& operator=(const bad_weak_ptr&) = default;
     virtual ~bad_weak_ptr() _NOEXCEPT;
     virtual const char* what() const  _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS

libcxx/include/exception

 {
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY exception(const exception&) _NOEXCEPT = default;
-
+    exception& operator=(const exception&) = default;
     virtual ~exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_exception
     : public exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
+    bad_exception(const bad_exception&) = default;
+    bad_exception& operator=(const bad_exception&) = default;
     virtual ~bad_exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 #if _LIBCPP_STD_VER <= 14 \
     || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
     || defined(_LIBCPP_BUILDING_LIBRARY)

 #endif // _LIBCPP_ABI_MICROSOFT
 // nested_exception
 
 class _LIBCPP_EXCEPTION_ABI nested_exception
 {
     exception_ptr __ptr_;
 public:
     nested_exception() _NOEXCEPT;
-//     nested_exception(const nested_exception&) noexcept = default;
-//     nested_exception& operator=(const nested_exception&) noexcept = default;
+    nested_exception(const nested_exception&) = default;
+    nested_exception& operator=(const nested_exception&) = default;
     virtual ~nested_exception() _NOEXCEPT;
 
     // access functions
     _LIBCPP_NORETURN void rethrow_nested() const;
     _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
 };
 
 template <class _Tp>

libcxx/include/new

 struct _LIBCPP_TYPE_VIS nothrow_t { explicit nothrow_t() = default; };
 extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
 
 class _LIBCPP_EXCEPTION_ABI bad_alloc
     : public exception
 {
 public:
     bad_alloc() _NOEXCEPT;
+    bad_alloc(const bad_alloc&) = default;
+    bad_alloc& operator=(const bad_alloc&) = default;
     virtual ~bad_alloc() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_array_new_length
     : public bad_alloc
 {
 public:
     bad_array_new_length() _NOEXCEPT;
+    bad_array_new_length(const bad_array_new_length&) = default;
+    bad_array_new_length& operator=(const bad_array_new_length&) = default;
     virtual ~bad_array_new_length() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 typedef void (*new_handler)();
 _LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
 

libcxx/include/stdexcept

class _LIBCPP_EXCEPTION_ABI domain_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     domain_error(const domain_error&) _NOEXCEPT = default;
+    domain_error& operator=(const domain_error&) = default;
     virtual ~domain_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI invalid_argument
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     invalid_argument(const invalid_argument&) _NOEXCEPT = default;
+    invalid_argument& operator=(const invalid_argument&) = default;
     virtual ~invalid_argument() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI length_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
 #ifndef _LIBCPP_ABI_VCRUNTIME
     length_error(const length_error&) _NOEXCEPT = default;
+    length_error& operator=(const length_error&) = default;
     virtual ~length_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI out_of_range
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     out_of_range(const out_of_range&) _NOEXCEPT = default;
+    out_of_range& operator=(const out_of_range&) = default;
     virtual ~out_of_range() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI range_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     range_error(const range_error&) _NOEXCEPT = default;
+    range_error& operator=(const range_error&) = default;
     virtual ~range_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI overflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     overflow_error(const overflow_error&) _NOEXCEPT = default;
+    overflow_error& operator=(const overflow_error&) = default;
     virtual ~overflow_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI underflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
     underflow_error(const underflow_error&) _NOEXCEPT = default;
+    underflow_error& operator=(const underflow_error&) = default;
     virtual ~underflow_error() _NOEXCEPT;
 #endif
 };
 
 } // namespace std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/typeinfo

 #endif // defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXCEPTION_ABI bad_cast
     : public exception
 {
  public:
   bad_cast() _NOEXCEPT;
   bad_cast(const bad_cast&) _NOEXCEPT = default;
+  bad_cast& operator=(const bad_cast&) = default;
   virtual ~bad_cast() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_typeid
     : public exception
 {
  public:
   bad_typeid() _NOEXCEPT;
+  bad_typeid(const bad_typeid&) = default;
+  bad_typeid& operator=(const bad_typeid&) = default;
   virtual ~bad_typeid() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
 } // namespace std
 
 #endif // defined(_LIBCPP_ABI_VCRUNTIME)
 

libcxx/test/libcxx/assertions/single_expression.sh.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
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that _LIBCPP_ASSERT is a single expression. This is useful so we can use
 // it in places that require an expression, such as in a constructor initializer list.
 
-// RUN: %{build} -Wno-macro-redefined -D_LIBCPP_ENABLE_ASSERTIONS=1
+// RUN: %{build} -Wno-macro-redefined -Wno-comma -D_LIBCPP_ENABLE_ASSERTIONS=1
 // RUN: %{run}
 
-// RUN: %{build} -Wno-macro-redefined -D_LIBCPP_ENABLE_ASSERTIONS=0
+// RUN: %{build} -Wno-macro-redefined -Wno-comma -D_LIBCPP_ENABLE_ASSERTIONS=0
 // RUN: %{run}
 
-// RUN: %{build} -Wno-macro-redefined -D_LIBCPP_ENABLE_ASSERTIONS=0 -D_LIBCPP_ASSERTIONS_DISABLE_ASSUME
+// RUN: %{build} -Wno-macro-redefined -Wno-comma -D_LIBCPP_ENABLE_ASSERTIONS=0 -D_LIBCPP_ASSERTIONS_DISABLE_ASSUME
 // RUN: %{run}
 
 // We flag uses of the assertion handler in older dylibs at compile-time to avoid runtime
 // failures when back-deploying.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 
 #include <__assert>
 #include <cassert>

libcxx/test/libcxx/atomics/bit-int.verify.cpp

 // disable them for now until their behavior can be designed better later.
 // See https://reviews.llvm.org/D84049 for details.
 
 // UNSUPPORTED: apple-clang-13, apple-clang-14
 // UNSUPPORTED: clang-13
 
 // UNSUPPORTED: c++03
 
+// ADDITIONAL_COMPILE_FLAGS: -Wno-bit-int-extension
+
 #include <atomic>
 
 int main(int, char**)
 {
   // expected-error@atomic:*1 {{_Atomic cannot be applied to integer type '_BitInt(32)'}}
   std::atomic<_BitInt(32)> x(42);
 
   return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.cpp

 
 #include "test_macros.h"
 
 struct A
 {
   static std::function<void()> global;
   static bool cancel;
 
+  A() = default;
+  A(const A&) = default;
   ~A() {
     DoNotOptimize(cancel);
     if (cancel)
       global = std::function<void()>(nullptr);
   }
   void operator()() {}
 };
 

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.cpp

 
 #include "test_macros.h"
 
 struct A
 {
   static std::function<void()> global;
   static bool cancel;
 
+  A() = default;
+  A(const A&) = default;
   ~A() {
     DoNotOptimize(cancel);
     if (cancel)
       global = nullptr;
   }
   void operator()() {}
 };
 

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

void test() {
   test<void (Empty::*)(const int&) volatile,
        void (Empty::*)(const int&) const volatile>();
   test<void (Empty::*)(const int&) const volatile>();
   test<void (Empty::*)(const int&) const volatile, double>();
   test<void (Empty::*)(const int&)&>();
   test<void (Empty::*)(const int&)&, void (Empty::*)(const int&) &&>();
   test<void (Empty::*)(const int&) &&>();
   test<void (Empty::*)(const int&)&&, void (Empty::*)(const int&)>();
-  test<void (Empty::*)(const int&) throw()>();
-  test<void (Empty::*)(const int&) throw(),
-       void(Empty::*)(const int&) noexcept(true)>();
   test<void (Empty::*)(const int&) noexcept>();
   test<void (Empty::*)(const int&) noexcept(true)>();
   test<void (Empty::*)(const int&) noexcept(true),
        void (Empty::*)(const int&) noexcept(false)>();
   test<void (Empty::*)(const int&) noexcept(false)>();
 
   test<int&>();
   test<int&, int>();

libcxx/test/std/containers/sequences/array/array.creation/to_array.pass.cpp

//  Test deduced type.
     auto arr = std::to_array(std::move(source));
     ASSERT_SAME_TYPE(decltype(arr), std::array<MoveOnly, 3>);
     for (int i = 0; i < 3; ++i)
       assert(arr[i].get() == i && source[i].get() == 0);
   }
 
   // Test C99 compound literal.
   {
+TEST_DIAGNOSTIC_PUSH
+TEST_CLANG_DIAGNOSTIC_IGNORED("-Wc99-extensions")
     auto arr = std::to_array((int[]){3, 4});
     ASSERT_SAME_TYPE(decltype(arr), std::array<int, 2>);
     assert(arr[0] == 3);
     assert(arr[1] == 4);
+TEST_DIAGNOSTIC_POP
   }
 
   //  Test explicit type.
   {
     auto arr = std::to_array<long>({1, 2, 3});
     ASSERT_SAME_TYPE(decltype(arr), std::array<long, 3>);
     assert(arr[0] == 1);
     assert(arr[1] == 2);

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp

test(C c)
     return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
+    Copyable(const Copyable&) = default;
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::vector<Copyable>());
 #if TEST_STD_VER >= 20
     test(ConstexprFixedCapacityDeque<int, 10>());
     static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
 #endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp

test(C c)
     return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
+    Copyable(const Copyable&) = default;
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::list<Copyable>());
     test(nasty_list<Copyable>());
 #if TEST_STD_VER >= 20
     test(ConstexprFixedCapacityDeque<int, 10>());
     static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
 #endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.star/op_star.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     A() : data_(1) {}
+    A(const A&) = default;
     ~A() {data_ = -1;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.data_ == y.data_;}
 };
 
 template <class It>
 void

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.elem/arrow.pass.cpp

test(It i, typename std::iterator_traits<It>::value_type x)
     assert(r->get() == x.get());
 }
 
 class B
 {
     int data_;
 public:
     B(int d=1) : data_(d) {}
+    B(const B&) = default;
     ~B() {data_ = -1;}
 
     int get() const {return data_;}
 
     friend bool operator==(const B& x, const B& y)
         {return x.data_ == y.data_;}
     const B *operator&() const { return nullptr; }
     B       *operator&()       { return nullptr; }

libcxx/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int data_;
 public:
     explicit A(int data) : data_(data) {}
+    A(const A&) = default;
     virtual ~A() TEST_NOEXCEPT {}
 
     friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
 };
 
 class B
     : public std::nested_exception,
       public A

 
 int main(int, char**)
 {
     {
         try
         {
             A a(3);  // not a polymorphic type --> no effect
             std::rethrow_if_nested(a);
-            assert(true);
         }
         catch (...)
         {
             assert(false);
         }
     }
     {
         try
         {
             D s;  // inaccessible base class --> no effect
             std::rethrow_if_nested(s);
-            assert(true);
         }
         catch (...)
         {
             assert(false);
         }
     }
     {
         try
         {
             E s;  // ambiguous base class --> no effect
             std::rethrow_if_nested(s);
-            assert(true);
         }
         catch (...)
         {
             assert(false);
         }
     }
     {
         try
int main(int, char**)
                 }
             }
         }
     }
     {
         try
         {
             std::rethrow_if_nested(C());
-            assert(true);
         }
         catch (...)
         {
             assert(false);
         }
     }
 
 
   return 0;
 }

libcxx/test/std/language.support/support.start.term/quick_exit.pass.cpp

 
 #include <cstdlib>
 
 void f() {}
 
 int main(int, char**) {
     std::at_quick_exit(f);
     std::quick_exit(0);
-    return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

struct ZeroOnDestroy : std::ranges::view_base {
   unsigned count = 0;
   int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   constexpr ForwardIter begin() { return ForwardIter(buff); }
   constexpr ForwardIter begin() const { return ForwardIter(); }
   constexpr ForwardIter end() { return ForwardIter(buff + 8); }
   constexpr ForwardIter end() const { return ForwardIter(); }
 
+  ZeroOnDestroy() = default;
+  ZeroOnDestroy(const ZeroOnDestroy&) = default;
+
   ~ZeroOnDestroy() {
     std::memset(buff, 0, sizeof(buff));
   }
 
   static auto dropFirstFour() {
     ZeroOnDestroy zod;
     std::ranges::drop_view dv(zod, 4);
     // Make sure we call begin here so the next call to begin will

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/singular.pass.cpp

struct ThrowOnIncrementIterator {
   using iterator_concept = std::input_iterator_tag;
 
   ThrowOnIncrementIterator() = default;
   explicit ThrowOnIncrementIterator(int* it) : it_(it) {}
 
   ThrowOnIncrementIterator& operator++() {
     ++it_;
     throw 5;
-    return *this;
   }
+
   void operator++(int) { ++it_; }
 
   int& operator*() const { return *it_; }
 
   friend bool operator==(ThrowOnIncrementIterator const&, ThrowOnIncrementIterator const&) = default;
 };
 
 struct ThrowOnIncrementView : IntBufferView {

libcxx/test/std/strings/string.view/string.view.cons/from_range.pass.cpp

 static_assert(!std::is_constructible_v<std::wstring_view, WithTraitsType<std::char_traits<char>>>);  // wrong traits type
 #endif
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 void test_throwing() {
   struct ThrowingData {
     char* begin() const { return nullptr; }
     char* end() const { return nullptr; }
-    char* data() const { throw 42; return nullptr; }
+    char* data() const { throw 42; }
   };
   try {
     ThrowingData x;
     (void) std::string_view(x);
     assert(false);
   } catch (int i) {
     assert(i == 42);
   }
 
   struct ThrowingSize {
     char* begin() const { return nullptr; }
     char* end() const { return nullptr; }
-    size_t size() const { throw 42; return 0; }
+    size_t size() const { throw 42; }
   };
   try {
     ThrowingSize x;
     (void) std::string_view(x);
     assert(false);
   } catch (int i) {
     assert(i == 42);
   }
 }
 #endif
 
 int main(int, char**) {
   test();
   static_assert(test());
 #ifndef TEST_HAS_NO_EXCEPTIONS
   test_throwing();
 #endif
 
   return 0;
 }
-

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/lock.pass.cpp

public:
     void lock()
     {
         TEST_THROW(1);
     }
 
     bool try_lock()
     {
         TEST_THROW(1);
-        return locked_;
     }
 
     void unlock() {locked_ = false;}
 
     bool locked() const {return locked_;}
 };
 
 int main(int, char**)

libcxx/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp

class L2
     bool locked_;
 
 public:
     L2() : locked_(false) {}
 
     bool try_lock()
     {
         TEST_THROW(1);
-        return locked_;
     }
 
     void unlock() {locked_ = false;}
 
     bool locked() const {return locked_;}
 };
 
 int main(int, char**)

libcxx/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp

 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
 struct Tracked {
   static int count;
   Tracked()  {++count;}
+  Tracked(const Tracked&) = default;
   ~Tracked() { --count; }
 };
 int Tracked::count = 0;
 
 template <class Type>
 void test_emplace_type() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);

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

 };
 
 class Y
 {
 public:
     static bool dtor_called;
     Y() = default;
     Y(int) { TEST_THROW(6);}
+    Y(const Y&) = default;
     ~Y() {dtor_called = true;}
 };
 
 bool Y::dtor_called = false;
 
 template <class T>
 constexpr bool test_one_arg() {
     using Opt = std::optional<T>;

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

class X
     int i_;
     int j_ = 0;
     bool* dtor_called_;
 public:
     constexpr X(bool& dtor_called) : i_(0), dtor_called_(&dtor_called) {}
     constexpr X(int i, bool& dtor_called) : i_(i), dtor_called_(&dtor_called) {}
     constexpr X(std::initializer_list<int> il, bool& dtor_called)
     : i_(il.begin()[0]), j_(il.begin()[1]), dtor_called_(&dtor_called) {}
+    constexpr X(const X&) = default;
     TEST_CONSTEXPR_CXX20 ~X() {*dtor_called_ = true;}
 
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Y
 {

 
 class Z
 {
     int i_;
     int j_ = 0;
 public:
     static bool dtor_called;
     Z() : i_(0) {}
+    Z(const Z&) = default;
     Z(int i) : i_(i) {}
     Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
         { TEST_THROW(6);}
     ~Z() {dtor_called = true;}
 
     friend bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

struct PODType {
   int value2;
 };
 
 class X
 {
 public:
     static bool dtor_called;
     X() = default;
+    X(const X&) = default;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
 int main(int, char**)
 {
     {

libcxx/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp

 
 #include "test_macros.h"
 
 using std::optional;
 
 struct X
 {
     static bool dtor_called;
+    X() = default;
+    X(const X&) = default;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
 constexpr bool check_reset()
 {
     {

libcxx/test/std/utilities/tuple/tuple.tuple/alloc_first.h

 {
     static bool allocator_constructed;
 
     typedef A1<int> allocator_type;
 
     int data_;
 
     alloc_first() : data_(0) {}
+    alloc_first(const alloc_first&) = default;
     alloc_first(int d) : data_(d) {}
     alloc_first(std::allocator_arg_t, const A1<int>& a)
         : data_(0)
     {
         assert(a.id() == 5);
         allocator_constructed = true;
     }
 

libcxx/test/std/utilities/tuple/tuple.tuple/alloc_last.h

 {
     static bool allocator_constructed;
 
     typedef A1<int> allocator_type;
 
     int data_;
 
     alloc_last() : data_(0) {}
+    alloc_last(const alloc_last&) = default;
     alloc_last(int d) : data_(d) {}
     alloc_last(const A1<int>& a)
         : data_(0)
     {
         assert(a.id() == 5);
         allocator_constructed = true;
     }
 

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B {
     int id_;
     explicit B(int i = 0) : id_(i) {}
+    B(const B&) = default;
+    B& operator=(const B&) = default;
     virtual ~B() {}
 };
 
 struct D : B {
     explicit D(int i) : B(i) {}
 };
 
 struct E {

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

struct Implicit {
   Implicit(int x) : value(x) {}
 };
 
 struct B
 {
     int id_;
 
     explicit B(int i) : id_(i) {}
-
+    B(const B&) = default;
     virtual ~B() {}
 };
 
 struct D
     : B
 {
     explicit D(int i) : B(i) {}
 };

libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp

const Fn &cobj = obj;
     V v1(42l), v2("hello"), v3(nullptr), v4(1.1);
     static_assert(std::is_same_v<decltype(std::visit<ReturnType>(obj, v1, v2, v3, v4)), ReturnType>);
     static_assert(std::is_same_v<decltype(std::visit<ReturnType>(cobj, v1, v2, v3, v4)), ReturnType>);
     static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(obj), v1, v2, v3, v4)), ReturnType>);
     static_assert(std::is_same_v<decltype(std::visit<ReturnType>(std::move(cobj), v1, v2, v3, v4)), ReturnType>);
   }
 }
 
-void test_constexpr_void() {
+constexpr bool test_constexpr_void() {
   constexpr ReturnFirst obj{};
   constexpr ReturnArity aobj{};
   {
     using V = std::variant<int>;
     constexpr V v(42);
-    static_assert((std::visit<void>(obj, v), 42) == 42, "");
+    std::visit<void>(obj, v);
   }
   {
     using V = std::variant<short, long, char>;
     constexpr V v(42l);
-    static_assert((std::visit<void>(obj, v), 42) == 42, "");
+    std::visit<void>(obj, v);
   }
   {
     using V1 = std::variant<int>;
     using V2 = std::variant<int, char *, long long>;
     using V3 = std::variant<bool, int, int>;
     constexpr V1 v1;
     constexpr V2 v2(nullptr);
     constexpr V3 v3;
-    static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
+    std::visit<void>(aobj, v1, v2, v3);
   }
   {
     using V1 = std::variant<int>;
     using V2 = std::variant<int, char *, long long>;
     using V3 = std::variant<void *, int, int>;
     constexpr V1 v1;
     constexpr V2 v2(nullptr);
     constexpr V3 v3;
-    static_assert((std::visit<void>(aobj, v1, v2, v3), 3) == 3, "");
+    std::visit<void>(aobj, v1, v2, v3);
   }
   {
     using V = std::variant<int, long, double, int *>;
     constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
-    static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
+    std::visit<void>(aobj, v1, v2, v3, v4);
   }
   {
     using V = std::variant<int, long, double, long long, int *>;
     constexpr V v1(42l), v2(101), v3(nullptr), v4(1.1);
-    static_assert((std::visit<void>(aobj, v1, v2, v3, v4), 4) == 4, "");
+    std::visit<void>(aobj, v1, v2, v3, v4);
   }
+
+  return true;
 }
 
 void test_constexpr_int() {
   constexpr ReturnFirst obj{};
   constexpr ReturnArity aobj{};
   {
     using V = std::variant<int>;
     constexpr V v(42);
void test_sfinae() {
   static_assert(has_visit<std::variant<int> >(int()));
   static_assert(!has_visit<BadVariant>(int()));
 }
 
 int main(int, char**) {
   test_call_operator_forwarding<void>();
   test_argument_forwarding<void>();
   test_return_type<void>();
-  test_constexpr_void();
+  static_assert(test_constexpr_void());
   test_exceptions<void>();
   test_caller_accepts_nonconst<void>();
   test_call_operator_forwarding<int>();
   test_argument_forwarding<int>();
   test_return_type<int>();
   test_constexpr_int();
   test_exceptions<int>();
   test_caller_accepts_nonconst<int>();
   test_constexpr_explicit_side_effect();
   test_derived_from_variant();
   test_sfinae();
 
   return 0;
 }

libcxx/test/support/any_helpers.h

struct small_throws_on_copy
     }
     explicit small_throws_on_copy(int, int val, int) : value(val) {
         ++count;
     }
     small_throws_on_copy(small_throws_on_copy const &) {
         throwMyAnyExpression();
     }
 
-    small_throws_on_copy(small_throws_on_copy && other) throw() {
+    small_throws_on_copy(small_throws_on_copy && other) noexcept {
         value = other.value;
         ++count; ++moved;
     }
 
     ~small_throws_on_copy() {
         --count;
     }
 private:
struct large_throws_on_copy
     explicit large_throws_on_copy(int, int val, int) : value(val) {
         data[0] = 0;
         ++count;
     }
     large_throws_on_copy(large_throws_on_copy const &) {
          throwMyAnyExpression();
     }
 
-    large_throws_on_copy(large_throws_on_copy && other) throw() {
+    large_throws_on_copy(large_throws_on_copy && other) noexcept {
         value = other.value;
         ++count; ++moved;
     }
 
     ~large_throws_on_copy() {
         --count;
     }
 

libcxx/test/support/counting_predicates.h

 
 template <typename Predicate, typename Arg>
 struct unary_counting_predicate {
 public:
     typedef Arg argument_type;
     typedef bool result_type;
 
     unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
+    unary_counting_predicate(const unary_counting_predicate&) = default;
     ~unary_counting_predicate() {}
 
     bool operator () (const Arg &a) const { ++count_; return p_(a); }
     size_t count() const { return count_; }
     void reset() { count_ = 0; }
 
 private:
     Predicate p_;

libcxx/test/support/deleter_types.h

 template <class T>
 class CDeleter
 {
     int state_;
 
 public:
 
     CDeleter() : state_(0) {}
+    CDeleter(const CDeleter&) = default;
+    CDeleter& operator=(const CDeleter&) = default;
     explicit CDeleter(int s) : state_(s) {}
     ~CDeleter() {assert(state_ >= 0); state_ = -1;}
 
     template <class U>
         CDeleter(const CDeleter<U>& d)
             : state_(d.state()) {}
 
     int state() const {return state_;}
     void set_state(int i) {state_ = i;}
 
     void operator()(T* p) {delete p;}
 };
 
 template <class T>
 class CDeleter<T[]>
 {
     int state_;
 
 public:
 
     CDeleter() : state_(0) {}
+    CDeleter(const CDeleter&) = default;
+    CDeleter& operator=(const CDeleter&) = default;
     explicit CDeleter(int s) : state_(s) {}
     template <class U>
         CDeleter(const CDeleter<U>& d)
             : state_(d.state()) {}
 
     ~CDeleter() {assert(state_ >= 0); state_ = -1;}
 
     int state() const {return state_;}

libcxx/test/support/nasty_containers.h

public:
 
     nasty_vector() : v_() {}
     explicit nasty_vector(size_type n) : v_(n) {}
     nasty_vector(size_type n, const value_type& value) : v_(n, value) {}
     template <class InputIterator> nasty_vector(InputIterator first, InputIterator last) : v_(first, last) {}
 #if TEST_STD_VER >= 11
     nasty_vector(std::initializer_list<value_type> il) : v_(il) {}
 #endif
+    nasty_vector(const nasty_vector&) = default;
+    nasty_vector& operator=(const nasty_vector&) = default;
     ~nasty_vector() {}
 
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last) { v_.assign(first, last); }
     void assign(size_type n, const value_type& u) { v_.assign(n, u); }
 #if TEST_STD_VER >= 11
     void assign(std::initializer_list<value_type> il)  { v_.assign(il); }
 #endif

libcxx/utils/libcxx/test/params.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
-from libcxx.test.features import _isMSVC
+from libcxx.test.features import _isMSVC, _isClang
 import re
 
 _warningFlags = [
-  '-Werror',
   '-Wall',
+  '-Walloca',
+  '-Wcomma',
+  '-Wdeprecated',
   '-Wextra',
+  '-Werror',
   '-Wshadow',
   '-Wundef',
+  '-Wunreachable-code-aggressive',
+  '-Wvla',
+
+  # GCC doesn't support -Wno-gnu-include-next, so we can't enable -Wpedantic for it
+  lambda cfg: '-Wpedantic' if _isClang(cfg) else '',
+
+  # We use these extensions in the code base
+  '-Wno-gnu-include-next',
+  '-Wno-c11-extensions',
+  '-Wno-zero-length-array',
+  '-Wno-gcc-compat',
+  '-Wno-gnu-anonymous-struct',
+  '-Wno-nested-anon-types',
+
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
-  '-Wno-pessimizing-move',
-  '-Wno-c++11-extensions',
   '-Wno-noexcept-type',
   '-Wno-aligned-allocation-unavailable',
   '-Wno-atomic-alignment',
+  '-Wno-unused-local-typedef',
+
+  # We only support C++03 with Clang extensions
+  '-Wno-c++11-extensions',
 
   # GCC warns about places where we might want to add sized allocation/deallocation
   # functions, but we know better what we're doing/testing in the test suite.
   '-Wno-sized-deallocation',
 
   # Turn off warnings about user-defined literals with reserved suffixes. Those are
   # just noise since we are testing the Standard Library itself.
   '-Wno-literal-suffix', # GCC
   '-Wno-user-defined-literals', # Clang
 
   # These warnings should be enabled in order to support the MSVC
   # team using the test suite; They enable the warnings below and
   # expect the test suite to be clean.
   '-Wsign-compare',
   '-Wunused-variable',
   '-Wunused-parameter',
-  '-Wunreachable-code',
-  '-Wno-unused-local-typedef',
 ]
 
 _allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++20', 'c++2b']
 def getStdFlag(cfg, std):
   fallbacks = {
     'c++11': 'c++0x',
     'c++14': 'c++1y',
     'c++17': 'c++1z',