[libc++] Do not force the use of -Werror in verify tests

[ldionne]

Summary

Forcing -Werror and other warnings means that the test suite isn't
actually testing what most people are seeing in their code -- it seems
better and less arbitrary to compile these tests as close as possible
to the compiler default instead.

Removing -Werror also means that we get to differentiate between
diagnostics that are errors and those that are warnings, which makes
the test suite more precise.

[EricWF]

I'm not sure I love this, but I'm OK demoting warnings to errors in the XFAIL tests.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp

10

Why does this no longer pass?

[ldionne]

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp

10

When adding -Werror, we were also adding some specially tailored -Wno-c++11-extensions warning suppressor. The problem is that we use min_allocator.h, which uses the C++11 extension = default even in C++03 mode.

My original workaround was to backport min_allocator.h to C++03, but I thought you would prefer just disabling that specific test (unique_ptr is supposed to be C++11 anyway).

[MaskRay]

Just out of curiosity, did you create the patch by writing a script to parse clang -verify output and fix the tests automatically?
I asked because I had done similar things.

[EricWF]

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.cpp

10

FYI we do use unique_ptr throughout our implementation of the C++03 library.

[ldionne]

In D76311#1945309, @MaskRay wrote:

Just out of curiosity, did you create the patch by writing a script to parse clang -verify output and fix the tests automatically?
I asked because I had done similar things.

No, I am writing a new test format for libc++ and it wasn't adding that specific warning flag. I noticed the failures of the tests changed by this patch, observed it was because we didn't pass the warning flag, and created this patch.

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp

std::ptrdiff_t operator()(std::ptrdiff_t n)
         return n-1;
     }
 };
 
 
 int main(int, char**)
 {
     int v[1] = {1};
-    std::random_shuffle(&v[0], &v[1]); // expected-error{{'random_shuffle<int *>' is deprecated}}
+    std::random_shuffle(&v[0], &v[1]); // expected-warning {{'random_shuffle<int *>' is deprecated}}
     gen r;
-    std::random_shuffle(&v[0], &v[1], r); // expected-error{{'random_shuffle<int *, gen &>' is deprecated}}
+    std::random_shuffle(&v[0], &v[1], r); // expected-warning {{'random_shuffle<int *, gen &>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp

 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    typedef std::auto_ptr<int> AP; // expected-error{{'auto_ptr<int>' is deprecated}}
-    typedef std::auto_ptr<void> APV; // expected-error{{'auto_ptr<void>' is deprecated}}
-    typedef std::auto_ptr_ref<int> APR; // expected-error{{'auto_ptr_ref<int>' is deprecated}}
+    typedef std::auto_ptr<int> AP; // expected-warning {{'auto_ptr<int>' is deprecated}}
+    typedef std::auto_ptr<void> APV; // expected-warning {{'auto_ptr<void>' is deprecated}}
+    typedef std::auto_ptr_ref<int> APR; // expected-warning {{'auto_ptr_ref<int>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp

 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
   int x = 0;
   std::allocator<int> a;
 
-  int* p = a.address(x); // expected-error{{'address' is deprecated}}
+  int* p = a.address(x); // expected-warning {{'address' is deprecated}}
   (void)p;
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.fail.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::allocator<int> a;
-    a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    a.allocate(3, nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.depr_in_cxx17.fail.cpp

 #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::allocator<int> a;
-    TEST_IGNORE_NODISCARD a.allocate(3, nullptr); // expected-error {{'allocate' is deprecated}}
+    TEST_IGNORE_NODISCARD a.allocate(3, nullptr); // expected-warning {{'allocate' is deprecated}}
 
     return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.depr_in_cxx17.fail.cpp

 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    typedef std::allocator<char>::size_type AST;          // expected-error{{'size_type' is deprecated}}
-    typedef std::allocator<char>::difference_type ADT;    // expected-error{{'difference_type' is deprecated}}
-    typedef std::allocator<char>::pointer AP;             // expected-error{{'pointer' is deprecated}}
-    typedef std::allocator<char>::const_pointer ACP;      // expected-error{{'const_pointer' is deprecated}}
-    typedef std::allocator<char>::reference AR;           // expected-error{{'reference' is deprecated}}
-    typedef std::allocator<char>::const_reference ACR;    // expected-error{{'const_reference' is deprecated}}
-    typedef std::allocator<char>::rebind<int>::other ARO; // expected-error{{'rebind<int>' is deprecated}}
+    typedef std::allocator<char>::size_type AST;          // expected-warning {{'size_type' is deprecated}}
+    typedef std::allocator<char>::difference_type ADT;    // expected-warning {{'difference_type' is deprecated}}
+    typedef std::allocator<char>::pointer AP;             // expected-warning {{'pointer' is deprecated}}
+    typedef std::allocator<char>::const_pointer ACP;      // expected-warning {{'const_pointer' is deprecated}}
+    typedef std::allocator<char>::reference AR;           // expected-warning {{'reference' is deprecated}}
+    typedef std::allocator<char>::const_reference ACR;    // expected-warning {{'const_reference' is deprecated}}
+    typedef std::allocator<char>::rebind<int>::other ARO; // expected-warning {{'rebind<int>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.depr_in_cxx17.fail.cpp

 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    typedef std::allocator<void>::pointer AP;             // expected-error{{'allocator<void>' is deprecated}}
-    typedef std::allocator<void>::const_pointer ACP;      // expected-error{{'allocator<void>' is deprecated}}
-    typedef std::allocator<void>::rebind<int>::other ARO; // expected-error{{'allocator<void>' is deprecated}}
+    typedef std::allocator<void>::pointer AP;             // expected-warning {{'allocator<void>' is deprecated}}
+    typedef std::allocator<void>::const_pointer ACP;      // expected-warning {{'allocator<void>' is deprecated}}
+    typedef std::allocator<void>::rebind<int>::other ARO; // expected-warning {{'allocator<void>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.cpp

struct Foo {
     int const_zero() const { return 0; }
     int const_identity(int v) const { return v; }
     int zero() { return 0; }
     int identity(int v) { return v; }
 };
 
 int main(int, char**)
 {
-    typedef std::pointer_to_unary_function<int, int> PUF; // expected-error{{'pointer_to_unary_function<int, int>' is deprecated}}
-    typedef std::pointer_to_binary_function<int, int, int> PBF; // expected-error{{'pointer_to_binary_function<int, int, int>' is deprecated}}
-    std::ptr_fun<int, int>(identity); // expected-error{{'ptr_fun<int, int>' is deprecated}}
-    std::ptr_fun<int, int, int>(sum); // expected-error{{'ptr_fun<int, int, int>' is deprecated}}
-
-    typedef std::mem_fun_t<int, Foo> MFT0; // expected-error{{'mem_fun_t<int, Foo>' is deprecated}}
-    typedef std::mem_fun1_t<int, Foo, int> MFT1; // expected-error{{'mem_fun1_t<int, Foo, int>' is deprecated}}
-    typedef std::const_mem_fun_t<int, Foo> CMFT0; // expected-error{{'const_mem_fun_t<int, Foo>' is deprecated}}
-    typedef std::const_mem_fun1_t<int, Foo, int> CMFT1; // expected-error{{'const_mem_fun1_t<int, Foo, int>' is deprecated}}
-    std::mem_fun<int, Foo>(&Foo::zero); // expected-error{{'mem_fun<int, Foo>' is deprecated}}
-    std::mem_fun<int, Foo, int>(&Foo::identity); // expected-error{{'mem_fun<int, Foo, int>' is deprecated}}
-    std::mem_fun<int, Foo>(&Foo::const_zero); // expected-error{{'mem_fun<int, Foo>' is deprecated}}
-    std::mem_fun<int, Foo, int>(&Foo::const_identity); // expected-error{{'mem_fun<int, Foo, int>' is deprecated}}
-
-    typedef std::mem_fun_ref_t<int, Foo> MFR0; // expected-error{{'mem_fun_ref_t<int, Foo>' is deprecated}}
-    typedef std::mem_fun1_ref_t<int, Foo, int> MFR1; // expected-error{{'mem_fun1_ref_t<int, Foo, int>' is deprecated}}
-    typedef std::const_mem_fun_ref_t<int, Foo> CMFR0; // expected-error{{'const_mem_fun_ref_t<int, Foo>' is deprecated}}
-    typedef std::const_mem_fun1_ref_t<int, Foo, int> CMFR1; // expected-error{{'const_mem_fun1_ref_t<int, Foo, int>' is deprecated}}
-    std::mem_fun_ref<int, Foo>(&Foo::zero); // expected-error{{'mem_fun_ref<int, Foo>' is deprecated}}
-    std::mem_fun_ref<int, Foo, int>(&Foo::identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
-    std::mem_fun_ref<int, Foo>(&Foo::const_zero); // expected-error{{'mem_fun_ref<int, Foo>' is deprecated}}
-    std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-error{{'mem_fun_ref<int, Foo, int>' is deprecated}}
+    typedef std::pointer_to_unary_function<int, int> PUF; // expected-warning {{'pointer_to_unary_function<int, int>' is deprecated}}
+    typedef std::pointer_to_binary_function<int, int, int> PBF; // expected-warning {{'pointer_to_binary_function<int, int, int>' is deprecated}}
+    std::ptr_fun<int, int>(identity); // expected-warning {{'ptr_fun<int, int>' is deprecated}}
+    std::ptr_fun<int, int, int>(sum); // expected-warning {{'ptr_fun<int, int, int>' is deprecated}}
+
+    typedef std::mem_fun_t<int, Foo> MFT0; // expected-warning {{'mem_fun_t<int, Foo>' is deprecated}}
+    typedef std::mem_fun1_t<int, Foo, int> MFT1; // expected-warning {{'mem_fun1_t<int, Foo, int>' is deprecated}}
+    typedef std::const_mem_fun_t<int, Foo> CMFT0; // expected-warning {{'const_mem_fun_t<int, Foo>' is deprecated}}
+    typedef std::const_mem_fun1_t<int, Foo, int> CMFT1; // expected-warning {{'const_mem_fun1_t<int, Foo, int>' is deprecated}}
+    std::mem_fun<int, Foo>(&Foo::zero); // expected-warning {{'mem_fun<int, Foo>' is deprecated}}
+    std::mem_fun<int, Foo, int>(&Foo::identity); // expected-warning {{'mem_fun<int, Foo, int>' is deprecated}}
+    std::mem_fun<int, Foo>(&Foo::const_zero); // expected-warning {{'mem_fun<int, Foo>' is deprecated}}
+    std::mem_fun<int, Foo, int>(&Foo::const_identity); // expected-warning {{'mem_fun<int, Foo, int>' is deprecated}}
+
+    typedef std::mem_fun_ref_t<int, Foo> MFR0; // expected-warning {{'mem_fun_ref_t<int, Foo>' is deprecated}}
+    typedef std::mem_fun1_ref_t<int, Foo, int> MFR1; // expected-warning {{'mem_fun1_ref_t<int, Foo, int>' is deprecated}}
+    typedef std::const_mem_fun_ref_t<int, Foo> CMFR0; // expected-warning {{'const_mem_fun_ref_t<int, Foo>' is deprecated}}
+    typedef std::const_mem_fun1_ref_t<int, Foo, int> CMFR1; // expected-warning {{'const_mem_fun1_ref_t<int, Foo, int>' is deprecated}}
+    std::mem_fun_ref<int, Foo>(&Foo::zero); // expected-warning {{'mem_fun_ref<int, Foo>' is deprecated}}
+    std::mem_fun_ref<int, Foo, int>(&Foo::identity); // expected-warning {{'mem_fun_ref<int, Foo, int>' is deprecated}}
+    std::mem_fun_ref<int, Foo>(&Foo::const_zero); // expected-warning {{'mem_fun_ref<int, Foo>' is deprecated}}
+    std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-warning {{'mem_fun_ref<int, Foo, int>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/enable_nodiscard.fail.cpp

 #define _LIBCPP_ENABLE_NODISCARD
 
 #include <__config>
 
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
 int main(int, char**) {
-  foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
-  bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  foo(); // expected-warning-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  bar(); // expected-warning-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   (void)foo(); // OK. void casts disable the diagnostic.
   (void)bar();
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/enable_nodiscard_disable_after_cxx17.fail.cpp

 #define _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17
 #include <__config>
 
 
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
 int main(int, char**) {
-  foo(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  foo(); // expected-warning-re{{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   bar(); // OK.
   (void)foo(); // OK.
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/enable_nodiscard_disable_nodiscard_ext.fail.cpp

 #define _LIBCPP_DISABLE_NODISCARD_EXT
 #include <__config>
 
 
 _LIBCPP_NODISCARD_EXT int foo() { return 42; }
 _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
 
 int main(int, char**) {
-  bar(); // expected-error-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  bar(); // expected-warning-re{{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   foo(); // OK.
   (void)bar(); // OK.
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/nodiscard_aftercxx17.fail.cpp

 // REQUIRES: verify-support
 
 #include <__config>
 
 _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
 int main(int, char**)
 {
-  foo();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    foo(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/libcxx/diagnostics/nodiscard_extensions.fail.cpp

 
 struct P {
   bool operator()(int) const { return false; }
 };
 
 int main(int, char**) {
   int arr[1] = { 1 };
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::adjacent_find(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::adjacent_find(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::all_of(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::any_of(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::binary_search(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::binary_search(std::begin(arr), std::end(arr), 1, std::greater<int>());
 
 #if TEST_STD_VER >= 17
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::clamp(2, 1, 3);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::clamp(2, 1, 3, std::greater<int>());
 #endif
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::count_if(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::count(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal_range(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal_range(std::begin(arr), std::end(arr), 1, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal(std::begin(arr), std::end(arr), std::begin(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal(std::begin(arr), std::end(arr), std::begin(arr),
              std::greater<int>());
 
 #if TEST_STD_VER >= 14
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::equal(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
              std::greater<int>());
 #endif
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_end(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_end(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
                 std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_first_of(std::begin(arr), std::end(arr), std::begin(arr),
                      std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_first_of(std::begin(arr), std::end(arr), std::begin(arr),
                      std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_if_not(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find_if(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::find(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::get_temporary_buffer<int>(1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::includes(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::includes(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
                 std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_heap_until(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_heap_until(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_heap(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_heap(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_partitioned(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_permutation(std::begin(arr), std::end(arr), std::begin(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
                       std::greater<int>());
 
 #if TEST_STD_VER >= 14
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
                       std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
                       std::end(arr), std::greater<int>());
 #endif
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_sorted_until(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_sorted_until(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_sorted(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::is_sorted(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::lexicographical_compare(std::begin(arr), std::end(arr), std::begin(arr),
                                std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::lexicographical_compare(std::begin(arr), std::end(arr), std::begin(arr),
                                std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::lower_bound(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::lower_bound(std::begin(arr), std::end(arr), 1, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max_element(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max_element(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max(1, 2);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max(1, 2, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max({1, 2, 3});
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::max({1, 2, 3}, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min_element(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min_element(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min(1, 2);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min(1, 2, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min({1, 2, 3});
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::min({1, 2, 3}, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax_element(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax_element(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax(1, 2);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax(1, 2, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax({1, 2, 3});
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::minmax({1, 2, 3}, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr),
                 std::greater<int>());
 
 #if TEST_STD_VER >= 14
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::mismatch(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
                 std::greater<int>());
 #endif
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::none_of(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::remove_if(std::begin(arr), std::end(arr), P());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::remove(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::search_n(std::begin(arr), std::end(arr), 1, 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::search_n(std::begin(arr), std::end(arr), 1, 1, std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::search(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::search(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
               std::greater<int>());
 
 #if TEST_STD_VER >= 17
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::search(std::begin(arr), std::end(arr),
               std::default_searcher(std::begin(arr), std::end(arr)));
 #endif
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::unique(std::begin(arr), std::end(arr));
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::unique(std::begin(arr), std::end(arr), std::greater<int>());
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::upper_bound(std::begin(arr), std::end(arr), 1);
 
-  // expected-error-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::upper_bound(std::begin(arr), std::end(arr), 1, std::greater<int>());
 
   return 0;
 }

libcxx/test/libcxx/experimental/filesystem/deprecated.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: verify-support
 // UNSUPPORTED: c++98, c++03
 
 // <experimental/filesystem>
 
 #include <experimental/filesystem>
 
-using namespace std::experimental::filesystem; // expected-error {{'filesystem' is deprecated: std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro.}}
+using namespace std::experimental::filesystem; // expected-warning {{'filesystem' is deprecated: std::experimental::filesystem has now been deprecated in favor of C++17's std::filesystem. Please stop using it and start using std::filesystem. This experimental version will be removed in LLVM 11. You can remove this warning by defining the _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM macro.}}
 
 int main(int, char**) {
   return 0;
 }

libcxx/test/libcxx/thread/thread.lock/thread.lock.guard/nodiscard.fail.cpp

 // which is a libc++ extension.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_NODISCARD
 #define _LIBCPP_ENABLE_NODISCARD
 #include <mutex>
 
 int main(int, char**) {
     std::mutex m;
-    std::lock_guard<std::mutex>{m}; // expected-error{{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
-    std::lock_guard<std::mutex>{m, std::adopt_lock}; // expected-error{{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
+    std::lock_guard<std::mutex>{m}; // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
+    std::lock_guard<std::mutex>{m, std::adopt_lock}; // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.wrap/depr_in_cxx03.fail.cpp

 
 // REQUIRES: c++98 || c++03
 // REQUIRES: verify-support
 
 #include <functional>
 #include "test_macros.h"
 
 int main() {
     // Note:
     // We use sizeof() to require it to be a complete type. We don't create a
-    // variable because otherwise we get two errors for each variable (the
-    // second error is when the destructor is implicitly called).
-    (void)sizeof(std::function<void ()>); // expected-error{{'function<void ()>' is deprecated}}
-    (void)sizeof(std::function<void (int)>); // expected-error{{'function<void (int)>' is deprecated}}
-    (void)sizeof(std::function<void (int, int)>); // expected-error{{'function<void (int, int)>' is deprecated}}
-    (void)sizeof(std::function<void (int, int, int)>); // expected-error{{'function<void (int, int, int)>' is deprecated}}
+    // variable because otherwise we get two warnings for each variable (the
+    // second warning is when the destructor is implicitly called).
+    (void)sizeof(std::function<void ()>); // expected-warning {{'function<void ()>' is deprecated}}
+    (void)sizeof(std::function<void (int)>); // expected-warning {{'function<void (int)>' is deprecated}}
+    (void)sizeof(std::function<void (int, int)>); // expected-warning {{'function<void (int, int)>' is deprecated}}
+    (void)sizeof(std::function<void (int, int, int)>); // expected-warning {{'function<void (int, int, int)>' is deprecated}}
 }

libcxx/test/std/containers/associative/map/map.access/empty.fail.cpp

 
 #include <map>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::map<int, int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/associative/multimap/empty.fail.cpp

 
 #include <map>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::multimap<int, int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/associative/multiset/empty.fail.cpp

 
 #include <set>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::multiset<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/associative/set/empty.fail.cpp

 
 #include <set>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::set<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp

 
 #include <queue>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::priority_queue<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp

 
 #include <queue>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::queue<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp

 
 #include <stack>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::stack<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

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

 #include "MoveOnly.h"
 
 int main(int, char**) {
   {
     char source[3][6] = {"hi", "world"};
     // expected-error@array:* {{to_array does not accept multidimensional arrays}}
     // expected-error@array:* {{to_array requires copy constructible elements}}
     // expected-error@array:* 3 {{cannot initialize}}
-    // expected-error@array:* {{suggest braces}}
     std::to_array(source); // expected-note {{requested here}}
   }
 
   {
     MoveOnly mo[] = {MoveOnly{3}};
     // expected-error@array:* {{to_array requires copy constructible elements}}
     // expected-error@array:* {{calling a private constructor}}
     std::to_array(mo); // expected-note {{requested here}}

libcxx/test/std/containers/sequences/array/empty.fail.cpp

 #include <array>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
 
     std::array<int, 1> c;
-    c.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     std::array<int, 0> c0;
-    c0.empty(); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c0.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp

 
 #include <deque>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::deque<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/empty.fail.cpp

 
 #include <forward_list>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::forward_list<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/sequences/list/list.capacity/empty.fail.cpp

 
 #include <list>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::list<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/empty.fail.cpp

 
 #include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::vector<bool> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp

 
 #include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::vector<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/empty.fail.cpp

 
 #include <unordered_map>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::unordered_map<int, int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/empty.fail.cpp

 
 #include <unordered_map>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::unordered_multimap<int, int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/empty.fail.cpp

 
 #include <unordered_set>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::unordered_multiset<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/empty.fail.cpp

 
 #include <unordered_set>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::unordered_set<int> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.cpp

 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    std::bind1st(test_func(1), 5); // expected-error{{'bind1st<test_func, int>' is deprecated}}
+    std::bind1st(test_func(1), 5); // expected-warning {{'bind1st<test_func, int>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.cpp

 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    std::bind2nd(test_func(1), 5); // expected-error{{'bind2nd<test_func, int>' is deprecated}}
+    std::bind2nd(test_func(1), 5); // expected-warning {{'bind2nd<test_func, int>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.cpp

 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    typedef std::binder1st<test_func> B1ST; // expected-error{{'binder1st<test_func>' is deprecated}}
+    typedef std::binder1st<test_func> B1ST; // expected-warning {{'binder1st<test_func>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.cpp

 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    typedef std::binder2nd<test_func> B2ND; // expected-error{{'binder2nd<test_func>' is deprecated}}
+    typedef std::binder2nd<test_func> B2ND; // expected-warning {{'binder2nd<test_func>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.fail.cpp

 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     fs::path c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/iterators/iterator.container/empty.array.fail.cpp

 #include <vector>
 #include <iterator>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     int c[5];
-    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/iterators/iterator.container/empty.container.fail.cpp

 #include <vector>
 #include <iterator>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::vector<int> c;
-    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp

 #include <initializer_list>
 #include <iterator>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::initializer_list<int> c = { 4 };
-    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::empty(c); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp

 
 #include <new>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     char buffer[100];
-    ::operator new[](4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new[](4, buffer); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp

 
 #include <new>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     char buffer[100];
-    ::operator new(4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new(4, buffer); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp

 // REQUIRES: verify-support
 
 #include <new>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    ::operator new(4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new(4); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp

 // REQUIRES: verify-support
 
 #include <new>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    ::operator new(4, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    ::operator new(4, std::nothrow); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp

 #include <new>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     int *p = nullptr;
-    std::launder(p);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::launder(p); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/numerics/c.math/abs.fail.cpp

 #include "test_macros.h"
 
 int main(int, char**)
 {
     unsigned int ui = -5;
     ui = std::abs(ui); // expected-error {{call to 'abs' is ambiguous}}
 
     unsigned char uc = -5;
-    uc = std::abs(uc); // expected-error {{taking the absolute value of unsigned type 'unsigned char' has no effect}}
+    uc = std::abs(uc); // expected-warning {{taking the absolute value of unsigned type 'unsigned char' has no effect}}
 
     unsigned short us = -5;
-    us = std::abs(us); // expected-error {{taking the absolute value of unsigned type 'unsigned short' has no effect}}
+    us = std::abs(us); // expected-warning {{taking the absolute value of unsigned type 'unsigned short' has no effect}}
 
     unsigned long ul = -5;
     ul = std::abs(ul); // expected-error {{call to 'abs' is ambiguous}}
 
     unsigned long long ull = -5;
     ull = ::abs(ull); // expected-error {{call to 'abs' is ambiguous}}
 
     return 0;
 }

libcxx/test/std/re/re.results/re.results.size/empty.fail.cpp

 
 #include <regex>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::match_results<const char*> c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/strings/basic.string/string.capacity/empty.fail.cpp

 
 #include <string>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::string c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/strings/string.view/string.view.capacity/empty.fail.cpp

 
 #include <string_view>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::string_view c;
-    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    c.empty();  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/thread/futures/futures.async/async.fail.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int foo (int x) { return x; }
 
 int main(int, char**)
 {
-    std::async(                    foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
-    std::async(std::launch::async, foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::async(                    foo, 3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::async(std::launch::async, foo, 3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp

 #include <scoped_allocator>
 #include <cassert>
 
 #include "allocators.h"
 
 int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
-    a.allocate(10);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    a.allocate(10);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp

 #include <scoped_allocator>
 #include <cassert>
 
 #include "allocators.h"
 
 int main(int, char**)
 {
     std::scoped_allocator_adaptor<A1<int>> a;
-    a.allocate(10, (const void*)0); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    a.allocate(10, (const void*)0); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp

 
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
 int main(int, char**) {
-    std::binary_negate<Predicate> f((Predicate())); // expected-error{{'binary_negate<Predicate>' is deprecated}}
+    std::binary_negate<Predicate> f((Predicate())); // expected-warning {{'binary_negate<Predicate>' is deprecated}}
     (void)f;
 
     return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp

 #include "test_macros.h"
 
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
 int main(int, char**) {
-    std::not1(Predicate()); // expected-error{{'not1<Predicate>' is deprecated}}
+    std::not1(Predicate()); // expected-warning {{'not1<Predicate>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp

 
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
 int main(int, char**) {
-    std::not2(Predicate()); // expected-error{{'not2<Predicate>' is deprecated}}
+    std::not2(Predicate()); // expected-warning {{'not2<Predicate>' is deprecated}}
 
     return 0;
 }

libcxx/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp

 #include "test_macros.h"
 
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
 int main(int, char**) {
-    std::unary_negate<Predicate> f((Predicate())); // expected-error{{'unary_negate<Predicate>' is deprecated}}
+    std::unary_negate<Predicate> f((Predicate())); // expected-warning {{'unary_negate<Predicate>' is deprecated}}
     (void)f;
 
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp

value_type* allocate(std::size_t n, const void* p)
         assert(p == 0);
         return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF));
     }
 };
 
 int main(int, char**)
 {
     A<int> a;
-    std::allocator_traits<A<int> >::allocate(a, 10);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
-    std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::allocator_traits<A<int> >::allocate(a, 10);          // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::allocator<int> a;
-    a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    a.allocate(3); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 
     return 0;
 }

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

 int main(int, char**)
 {
 #ifndef __cpp_lib_is_constant_evaluated
   // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}}
   bool b = std::is_constant_evaluated();
 #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}}
+  // expected-warning@-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/smartptr/unique.ptr/unique.ptr.class/unique.ptr.modifiers/reset.runtime.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
+// UNSUPPORTED: c++98, c++03
 
 // unique_ptr
 
 // test reset
 
 #include <memory>
 #include <cassert>
 

libcxx/utils/libcxx/test/format.py

def _evaluate_fail_test(self, test, test_cxx, parsers):
         # FIXME(EricWF): GCC 5 does not evaluate static assertions that
         # are dependant on a template parameter when '-fsyntax-only' is passed.
         # This is fixed in GCC 6. However for now we only pass "-fsyntax-only"
         # when using Clang.
         if test_cxx.type != 'gcc':
             test_cxx.flags += ['-fsyntax-only']
         if use_verify:
             test_cxx.useVerify()
-            test_cxx.useWarnings()
-            if '-Wuser-defined-warnings' in test_cxx.warning_flags:
-                test_cxx.warning_flags += ['-Wno-error=user-defined-warnings']
         cmd, out, err, rc = test_cxx.compile(source_path, out=os.devnull)
         check_rc = lambda rc: rc == 0 if use_verify else rc != 0
         report = libcxx.util.makeReport(cmd, out, err, rc)
         if check_rc(rc):
             return lit.Test.Result(lit.Test.PASS, report)
         else:
             report += ('Expected compilation to fail!\n' if not use_verify else
                        'Expected compilation using verify to pass!\n')
             return lit.Test.Result(lit.Test.FAIL, report)