This is an archive of the discontinued LLVM Phabricator instance.

Differential D76311

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

Authored by ldionne on Mar 17 2020, 12:05 PM.

Details

Reviewers
EricWF
Group Reviewers
Restricted Project
Commits
rGa5fa5f7cb86c: [libc++] Do not force the use of -Werror in verify tests
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.

Diff Detail

Event Timeline

ldionne created this revision.Mar 17 2020, 12:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 17 2020, 12:05 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libcxx-commits, dexonsmith, jkorous. · View Herald Transcript
ldionne added a parent revision: D76256: [libc++] Require the use of clang-verify in .fail.cpp tests that don't fail without it.Mar 17 2020, 12:06 PM
Harbormaster failed remote builds in B49467: Diff 250851!Mar 17 2020, 12:57 PM
EricWF accepted this revision.Mar 18 2020, 8:00 PM
EricWF added a subscriber: 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?

This revision is now accepted and ready to land.Mar 18 2020, 8:00 PM
ldionne marked 2 inline comments as done.Mar 18 2020, 9:00 PM
ldionne added inline comments.
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).

Closed by commit rGa5fa5f7cb86c: [libc++] Do not force the use of -Werror in verify tests (authored by ldionne). · Explain WhyMar 26 2020, 5:23 AM
This revision was automatically updated to reflect the committed changes.
ldionne marked an inline comment as done.
Herald added a subscriber: broadwaylamb. · View Herald TranscriptMar 26 2020, 5:23 AM
MaskRay added a subscriber: MaskRay.EditedMar 26 2020, 5:36 PM

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 added inline comments.Mar 26 2020, 6:28 PM
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 added a comment.Mar 26 2020, 6:35 PM
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.

Revision Contents

PathSize
libcxx/
test/
libcxx/
algorithms/
alg.modifying.operations/
alg.random.shuffle/
4 lines
depr/
depr.auto.ptr/
auto.ptr/
6 lines
depr.default.allocator/
allocator.members/
2 lines
2 lines
2 lines
14 lines
6 lines
depr.function.objects/
44 lines
diagnostics/
4 lines
2 lines
2 lines
2 lines
154 lines
experimental/
filesystem/
2 lines
thread/
thread.lock/
thread.lock.guard/
4 lines
utilities/
function.objects/
func.wrap/
12 lines
std/
containers/
associative/
map/
map.access/
2 lines
multimap/
2 lines
multiset/
2 lines
set/
2 lines
container.adaptors/
priority.queue/
priqueue.members/
2 lines
queue/
queue.defn/
2 lines
stack/
stack.defn/
2 lines
sequences/
array/
array.creation/
1 line
4 lines
deque/
deque.capacity/
2 lines
forwardlist/
2 lines
list/
list.capacity/
2 lines
vector.bool/
2 lines
vector/
vector.capacity/
2 lines
unord/
unord.map/
2 lines
unord.multimap/
2 lines
unord.multiset/
2 lines
unord.set/
2 lines
depr/
depr.lib.binders/
depr.lib.bind.1st/
4 lines
depr.lib.bind.2nd/
4 lines
depr.lib.binder.1st/
4 lines
depr.lib.binder.2nd/
4 lines
input.output/
filesystems/
class.path/
path.member/
path.decompose/
2 lines
iterators/
iterator.container/
2 lines
2 lines
2 lines
language.support/
support.dynamic/
new.delete/
new.delete.placement/
2 lines
2 lines
new.delete.single/
2 lines
2 lines
ptr.launder/
2 lines
numerics/
c.math/
4 lines
re/
re.results/
re.results.size/
2 lines
strings/
basic.string/
string.capacity/
2 lines
string.view/
string.view.capacity/
2 lines
thread/
futures/
futures.async/
4 lines
utilities/
allocator.adaptor/
allocator.adaptor.members/
2 lines
2 lines
function.objects/
negators/
4 lines
4 lines
4 lines
2 lines
memory/
allocator.traits/
allocator.traits.members/
4 lines
default.allocator/
allocator.members/
2 lines
meta/
meta.const.eval/
2 lines
smartptr/
unique.ptr/
unique.ptr.class/
unique.ptr.modifiers/
1 line
utils/
libcxx/
test/
3 lines

Diff 252807

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

Show All 35 Lines std::ptrdiff_t operator()(std::ptrdiff_t n)
return n-1; return n-1;
} }
}; };
int main(int, char**) int main(int, char**)
{ {
int v[1] = {1}; 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; 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; return 0;
} }

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

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

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

Show All 22 Lines
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
int x = 0; int x = 0;
std::allocator<int> a; 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; (void)p;
return 0; return 0;
} }

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

Show All 26 Lines
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::allocator<int> a; 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; return 0;
} }

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

Show All 19 Lines
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::allocator<int> a; 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; return 0;
} }

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

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

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

Show All 26 Lines
// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS // MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#include <memory> #include <memory>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
typedef std::allocator<void>::pointer AP; // 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-error{{'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-error{{'allocator<void>' is deprecated}} typedef std::allocator<void>::rebind<int>::other ARO; // expected-warning {{'allocator<void>' is deprecated}}
return 0; return 0;
} }

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

Show All 25 Linesstruct Foo {
int const_zero() const { return 0; } int const_zero() const { return 0; }
int const_identity(int v) const { return v; } int const_identity(int v) const { return v; }
int zero() { return 0; } int zero() { return 0; }
int identity(int v) { return v; } int identity(int v) { return v; }
}; };
int main(int, char**) 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_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-error{{'pointer_to_binary_function<int, 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-error{{'ptr_fun<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-error{{'ptr_fun<int, 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-error{{'mem_fun_t<int, Foo>' 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-error{{'mem_fun1_t<int, Foo, int>' 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-error{{'const_mem_fun_t<int, Foo>' 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-error{{'const_mem_fun1_t<int, Foo, int>' 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-error{{'mem_fun<int, Foo>' 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-error{{'mem_fun<int, Foo, int>' 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-error{{'mem_fun<int, Foo>' 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-error{{'mem_fun<int, Foo, int>' 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-error{{'mem_fun_ref_t<int, Foo>' 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-error{{'mem_fun1_ref_t<int, Foo, int>' 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-error{{'const_mem_fun_ref_t<int, Foo>' 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-error{{'const_mem_fun1_ref_t<int, Foo, int>' 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-error{{'mem_fun_ref<int, Foo>' 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-error{{'mem_fun_ref<int, Foo, int>' 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-error{{'mem_fun_ref<int, Foo>' 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-error{{'mem_fun_ref<int, Foo, int>' is deprecated}} std::mem_fun_ref<int, Foo, int>(&Foo::const_identity); // expected-warning {{'mem_fun_ref<int, Foo, int>' is deprecated}}
return 0; return 0;
} }

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

Show All 21 Lines
#define _LIBCPP_ENABLE_NODISCARD #define _LIBCPP_ENABLE_NODISCARD
#include <__config> #include <__config>
_LIBCPP_NODISCARD_EXT int foo() { return 42; } _LIBCPP_NODISCARD_EXT int foo() { return 42; }
_LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; } _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
int main(int, char**) { 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(); // 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}}
(void)foo(); // OK. void casts disable the diagnostic. (void)foo(); // OK. void casts disable the diagnostic.
(void)bar(); (void)bar();
return 0; return 0;
} }

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

Show All 21 Lines
#define _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17 #define _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17
#include <__config> #include <__config>
_LIBCPP_NODISCARD_EXT int foo() { return 42; } _LIBCPP_NODISCARD_EXT int foo() { return 42; }
_LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; } _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
int main(int, char**) { 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. bar(); // OK.
(void)foo(); // OK. (void)foo(); // OK.
return 0; return 0;
} }

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

Show All 19 Lines
#define _LIBCPP_DISABLE_NODISCARD_EXT #define _LIBCPP_DISABLE_NODISCARD_EXT
#include <__config> #include <__config>
_LIBCPP_NODISCARD_EXT int foo() { return 42; } _LIBCPP_NODISCARD_EXT int foo() { return 42; }
_LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; } _LIBCPP_NODISCARD_AFTER_CXX17 int bar() { return 42; }
int main(int, char**) { 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. foo(); // OK.
(void)bar(); // OK. (void)bar(); // OK.
return 0; return 0;
} }

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

Show All 13 Lines
// REQUIRES: verify-support // REQUIRES: verify-support
#include <__config> #include <__config>
_LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; } _LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
int main(int, char**) 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; return 0;
} }

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

Show All 32 Lines
struct P { struct P {
bool operator()(int) const { return false; } bool operator()(int) const { return false; }
}; };
int main(int, char**) { int main(int, char**) {
int arr[1] = { 1 }; 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)); 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>()); 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()); 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()); 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); 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>()); std::binary_search(std::begin(arr), std::end(arr), 1, std::greater<int>());
#if TEST_STD_VER >= 17 #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); 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>()); std::clamp(2, 1, 3, std::greater<int>());
#endif #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()); 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); 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); 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>()); 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)); 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::equal(std::begin(arr), std::end(arr), std::begin(arr),
std::greater<int>()); std::greater<int>());
#if TEST_STD_VER >= 14 #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)); 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::equal(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
std::greater<int>()); std::greater<int>());
#endif #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)); 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::find_end(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
std::greater<int>()); 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::find_first_of(std::begin(arr), std::end(arr), std::begin(arr),
std::end(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::find_first_of(std::begin(arr), std::end(arr), std::begin(arr),
std::end(arr), std::greater<int>()); 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()); 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()); 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); 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); 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)); 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::includes(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
std::greater<int>()); 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)); 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>()); 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)); 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>()); 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()); 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)); 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::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
std::greater<int>()); std::greater<int>());
#if TEST_STD_VER >= 14 #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::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
std::end(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::is_permutation(std::begin(arr), std::end(arr), std::begin(arr),
std::end(arr), std::greater<int>()); std::end(arr), std::greater<int>());
#endif #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)); 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>()); 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)); 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>()); 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::lexicographical_compare(std::begin(arr), std::end(arr), std::begin(arr),
std::end(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::lexicographical_compare(std::begin(arr), std::end(arr), std::begin(arr),
std::end(arr), std::greater<int>()); 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); 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>()); 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)); 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>()); 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); 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>()); 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}); 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>()); 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)); 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>()); 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); 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>()); 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}); 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>()); 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)); 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>()); 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); 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>()); 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}); 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>()); 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)); 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::mismatch(std::begin(arr), std::end(arr), std::begin(arr),
std::greater<int>()); std::greater<int>());
#if TEST_STD_VER >= 14 #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)); 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::mismatch(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
std::greater<int>()); std::greater<int>());
#endif #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()); 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()); 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); 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); 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>()); 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)); 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::search(std::begin(arr), std::end(arr), std::begin(arr), std::end(arr),
std::greater<int>()); std::greater<int>());
#if TEST_STD_VER >= 17 #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::search(std::begin(arr), std::end(arr),
std::default_searcher(std::begin(arr), std::end(arr))); std::default_searcher(std::begin(arr), std::end(arr)));
#endif #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)); 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>()); 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); 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>()); std::upper_bound(std::begin(arr), std::end(arr), 1, std::greater<int>());
return 0; return 0;
} }

libcxx/test/libcxx/experimental/filesystem/deprecated.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// REQUIRES: verify-support // REQUIRES: verify-support
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
// <experimental/filesystem> // <experimental/filesystem>
#include <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**) { int main(int, char**) {
return 0; return 0;
} }

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

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

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

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

Show All 18 Lines
#include <map> #include <map>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::map<int, int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <map> #include <map>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::multimap<int, int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <set> #include <set>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::multiset<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <set> #include <set>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::set<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <queue> #include <queue>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::priority_queue<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <queue> #include <queue>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::queue<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <stack> #include <stack>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::stack<int> c; 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; return 0;
} }

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

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

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

Show All 19 Lines
#include <array> #include <array>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::array<int, 1> c; 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; 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; return 0;
} }

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

Show All 18 Lines
#include <deque> #include <deque>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::deque<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <forward_list> #include <forward_list>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::forward_list<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <list> #include <list>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::list<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::vector<bool> c; 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; return 0;
} }

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

Show All 18 Lines
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::vector<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::unordered_map<int, int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <unordered_map> #include <unordered_map>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::unordered_multimap<int, int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::unordered_multiset<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <unordered_set> #include <unordered_set>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::unordered_set<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <functional> #include <functional>
#include "../test_func.h" #include "../test_func.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 18 Lines
#include <functional> #include <functional>
#include "../test_func.h" #include "../test_func.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 18 Lines
#include <functional> #include <functional>
#include "../test_func.h" #include "../test_func.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 18 Lines
#include <functional> #include <functional>
#include "../test_func.h" #include "../test_func.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 18 Lines
#include "filesystem_include.h" #include "filesystem_include.h"
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
fs::path c; 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; return 0;
} }

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

Show All 18 Lines
#include <vector> #include <vector>
#include <iterator> #include <iterator>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
int c[5]; 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; return 0;
} }

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

Show All 18 Lines
#include <vector> #include <vector>
#include <iterator> #include <iterator>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::vector<int> c; 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; return 0;
} }

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

Show All 18 Lines
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::initializer_list<int> c = { 4 }; 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; return 0;
} }

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

Show All 16 Lines
#include <new> #include <new>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
char buffer[100]; 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; return 0;
} }

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

Show All 16 Lines
#include <new> #include <new>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
char buffer[100]; 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; return 0;
} }

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

Show All 15 Lines
// REQUIRES: verify-support // REQUIRES: verify-support
#include <new> #include <new>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 15 Lines
// REQUIRES: verify-support // REQUIRES: verify-support
#include <new> #include <new>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) 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; return 0;
} }

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

Show All 17 Lines
#include <new> #include <new>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
int *p = nullptr; 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; return 0;
} }

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

Show All 10 Lines
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
unsigned int ui = -5; unsigned int ui = -5;
ui = std::abs(ui); // expected-error {{call to 'abs' is ambiguous}} ui = std::abs(ui); // expected-error {{call to 'abs' is ambiguous}}
unsigned char uc = -5; 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; 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; unsigned long ul = -5;
ul = std::abs(ul); // expected-error {{call to 'abs' is ambiguous}} ul = std::abs(ul); // expected-error {{call to 'abs' is ambiguous}}
unsigned long long ull = -5; unsigned long long ull = -5;
ull = ::abs(ull); // expected-error {{call to 'abs' is ambiguous}} ull = ::abs(ull); // expected-error {{call to 'abs' is ambiguous}}
return 0; return 0;
} }

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

Show All 17 Lines
#include <regex> #include <regex>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::match_results<const char*> c; 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; return 0;
} }

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

Show All 18 Lines
#include <string> #include <string>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::string c; 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; return 0;
} }

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

Show All 18 Lines
#include <string_view> #include <string_view>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::string_view c; 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; return 0;
} }

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

Show All 27 Lines
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int foo (int x) { return x; } int foo (int x) { return x; }
int main(int, char**) int main(int, char**)
{ {
std::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-error {{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; return 0;
} }

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

Show All 19 Lines
#include <scoped_allocator> #include <scoped_allocator>
#include <cassert> #include <cassert>
#include "allocators.h" #include "allocators.h"
int main(int, char**) int main(int, char**)
{ {
std::scoped_allocator_adaptor<A1<int>> a; 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; return 0;
} }

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

Show All 19 Lines
#include <scoped_allocator> #include <scoped_allocator>
#include <cassert> #include <cassert>
#include "allocators.h" #include "allocators.h"
int main(int, char**) int main(int, char**)
{ {
std::scoped_allocator_adaptor<A1<int>> a; 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; return 0;
} }

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

Show All 20 Lines
struct Predicate { struct Predicate {
typedef int first_argument_type; typedef int first_argument_type;
typedef int second_argument_type; typedef int second_argument_type;
bool operator()(first_argument_type, second_argument_type) const { return true; } bool operator()(first_argument_type, second_argument_type) const { return true; }
}; };
int main(int, char**) { 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; (void)f;
return 0; return 0;
} }

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

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

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

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

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

Show All 19 Lines
#include "test_macros.h" #include "test_macros.h"
struct Predicate { struct Predicate {
typedef int argument_type; typedef int argument_type;
bool operator()(argument_type) const { return true; } bool operator()(argument_type) const { return true; }
}; };
int main(int, char**) { 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; (void)f;
return 0; return 0;
} }

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

Show All 40 Lines value_type* allocate(std::size_t n, const void* p)
assert(p == 0); assert(p == 0);
return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF)); return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF));
} }
}; };
int main(int, char**) int main(int, char**)
{ {
A<int> a; 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); // expected-warning {{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, nullptr); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
return 0; return 0;
} }

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

Show All 17 Lines
#include <memory> #include <memory>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::allocator<int> a; 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; return 0;
} }

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

Show All 18 Lines
int main(int, char**) int main(int, char**)
{ {
#ifndef __cpp_lib_is_constant_evaluated #ifndef __cpp_lib_is_constant_evaluated
// expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}} // expected-error@+1 {{no member named 'is_constant_evaluated' in namespace 'std'}}
bool b = std::is_constant_evaluated(); bool b = std::is_constant_evaluated();
#else #else
// expected-error@+1 {{static_assert failed}} // expected-error@+1 {{static_assert failed}}
static_assert(!std::is_constant_evaluated(), ""); 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 #endif
return 0; 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. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <memory> // <memory>
// UNSUPPORTED: c++98, c++03
EricWFUnsubmitted
Done
ReplyInline Actions

Why does this no longer pass?

EricWF: Why does this no longer pass?
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

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).

ldionne: When adding `-Werror`, we were also adding some specially tailored `-Wno-c++11-extensions`…
EricWFUnsubmitted
Not Done
ReplyInline Actions

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

EricWF: FYI we do use unique_ptr throughout our implementation of the C++03 library.
// unique_ptr // unique_ptr
// test reset // test reset
#include <memory> #include <memory>
#include <cassert> #include <cassert>
Show All 14 Lines

libcxx/utils/libcxx/test/format.py

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines def _evaluate_fail_test(self, test, test_cxx, parsers):
# FIXME(EricWF): GCC 5 does not evaluate static assertions that # FIXME(EricWF): GCC 5 does not evaluate static assertions that
# are dependant on a template parameter when '-fsyntax-only' is passed. # 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" # This is fixed in GCC 6. However for now we only pass "-fsyntax-only"
# when using Clang. # when using Clang.
if test_cxx.type != 'gcc': if test_cxx.type != 'gcc':
test_cxx.flags += ['-fsyntax-only'] test_cxx.flags += ['-fsyntax-only']
if use_verify: if use_verify:
test_cxx.useVerify() 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) cmd, out, err, rc = test_cxx.compile(source_path, out=os.devnull)
check_rc = lambda rc: rc == 0 if use_verify else rc != 0 check_rc = lambda rc: rc == 0 if use_verify else rc != 0
report = libcxx.util.makeReport(cmd, out, err, rc) report = libcxx.util.makeReport(cmd, out, err, rc)
if check_rc(rc): if check_rc(rc):
return lit.Test.Result(lit.Test.PASS, report) return lit.Test.Result(lit.Test.PASS, report)
else: else:
report += ('Expected compilation to fail!\n' if not use_verify else report += ('Expected compilation to fail!\n' if not use_verify else
'Expected compilation using verify to pass!\n') 'Expected compilation using verify to pass!\n')
return lit.Test.Result(lit.Test.FAIL, report) return lit.Test.Result(lit.Test.FAIL, report)