This is an archive of the discontinued LLVM Phabricator instance.

Differential D132339

[libc++][NFC] Remove mentions of warn_unused_result
ClosedPublic

Authored by philnik on Aug 21 2022, 6:05 PM.

Details

Reviewers
ldionne
Mordante
var-const
huixie90
Group Reviewers
Restricted Project
Commits
rG36aea6158732: [libc++][NFC] Remove mentions of warn_unused_result
Summary

We don't use clang::warn_unused_result anymore, so let's remove the mentions of it from the tests

Diff Detail

Event Timeline

philnik created this revision.Aug 21 2022, 6:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 21 2022, 6:05 PM
philnik requested review of this revision.Aug 21 2022, 6:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 21 2022, 6:05 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Mordante accepted this revision.Aug 25 2022, 9:36 AM

Thanks for the cleanup! LGTM!

The AIX CI runner was cancelled, can you either rebase to restart the CI or keep an eye on the CI after landing this.

This revision is now accepted and ready to land.Aug 25 2022, 9:36 AM
This revision was landed with ongoing or failed builds.Aug 25 2022, 1:28 PM
Closed by commit rG36aea6158732: [libc++][NFC] Remove mentions of warn_unused_result (authored by philnik). · Explain Why
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG36aea6158732: [libc++][NFC] Remove mentions of warn_unused_result.

Revision Contents

PathSize
libcxx/
test/
libcxx/
diagnostics/
4 lines
180 lines

Diff 455701

libcxx/test/libcxx/diagnostics/enable_nodiscard_ext.verify.cpp

Show All 14 Lines
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD_EXT // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_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**) {
foo(); // expected-warning-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} foo(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
bar(); // expected-warning-re {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} bar(); // expected-warning {{ignoring return value of function declared with 'nodiscard' 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/nodiscard_extensions.verify.cpp

Show All 29 Lines
struct P { struct P {
bool operator()(int) const { return false; } bool operator()(int) const { return false; }
}; };
void test_algorithms() { void test_algorithms() {
int arr[1] = { 1 }; int arr[1] = { 1 };
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::adjacent_find(std::begin(arr), std::end(arr)); std::adjacent_find(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::all_of(std::begin(arr), std::end(arr), P()); std::all_of(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::any_of(std::begin(arr), std::end(arr), P()); std::any_of(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::binary_search(std::begin(arr), std::end(arr), 1); std::binary_search(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::clamp(2, 1, 3); std::clamp(2, 1, 3);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::clamp(2, 1, 3, std::greater<int>()); std::clamp(2, 1, 3, std::greater<int>());
#endif #endif
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::count_if(std::begin(arr), std::end(arr), P()); std::count_if(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::count(std::begin(arr), std::end(arr), 1); std::count(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::equal_range(std::begin(arr), std::end(arr), 1); std::equal_range(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::equal(std::begin(arr), std::end(arr), std::begin(arr)); std::equal(std::begin(arr), std::end(arr), std::begin(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::find_if_not(std::begin(arr), std::end(arr), P()); std::find_if_not(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::find_if(std::begin(arr), std::end(arr), P()); std::find_if(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::find(std::begin(arr), std::end(arr), 1); std::find(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::get_temporary_buffer<int>(1); std::get_temporary_buffer<int>(1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::is_heap_until(std::begin(arr), std::end(arr)); std::is_heap_until(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::is_heap(std::begin(arr), std::end(arr)); std::is_heap(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::is_partitioned(std::begin(arr), std::end(arr), P()); std::is_partitioned(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::is_sorted_until(std::begin(arr), std::end(arr)); std::is_sorted_until(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::is_sorted(std::begin(arr), std::end(arr)); std::is_sorted(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::lower_bound(std::begin(arr), std::end(arr), 1); std::lower_bound(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::max_element(std::begin(arr), std::end(arr)); std::max_element(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::max(1, 2); std::max(1, 2);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::max(1, 2, std::greater<int>()); std::max(1, 2, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::max({1, 2, 3}); std::max({1, 2, 3});
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::max({1, 2, 3}, std::greater<int>()); std::max({1, 2, 3}, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::min_element(std::begin(arr), std::end(arr)); std::min_element(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::min(1, 2); std::min(1, 2);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::min(1, 2, std::greater<int>()); std::min(1, 2, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::min({1, 2, 3}); std::min({1, 2, 3});
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::min({1, 2, 3}, std::greater<int>()); std::min({1, 2, 3}, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::minmax_element(std::begin(arr), std::end(arr)); std::minmax_element(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::minmax(1, 2); std::minmax(1, 2);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::minmax(1, 2, std::greater<int>()); std::minmax(1, 2, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::minmax({1, 2, 3}); std::minmax({1, 2, 3});
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::minmax({1, 2, 3}, std::greater<int>()); std::minmax({1, 2, 3}, std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::mismatch(std::begin(arr), std::end(arr), std::begin(arr)); std::mismatch(std::begin(arr), std::end(arr), std::begin(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::none_of(std::begin(arr), std::end(arr), P()); std::none_of(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::remove_if(std::begin(arr), std::end(arr), P()); std::remove_if(std::begin(arr), std::end(arr), P());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::remove(std::begin(arr), std::end(arr), 1); std::remove(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::search_n(std::begin(arr), std::end(arr), 1, 1); std::search_n(std::begin(arr), std::end(arr), 1, 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::unique(std::begin(arr), std::end(arr)); std::unique(std::begin(arr), std::end(arr));
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::unique(std::begin(arr), std::end(arr), std::greater<int>()); std::unique(std::begin(arr), std::end(arr), std::greater<int>());
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::upper_bound(std::begin(arr), std::end(arr), 1); std::upper_bound(std::begin(arr), std::end(arr), 1);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' 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>());
} }
template<class LV, class RV> template<class LV, class RV>
void test_template_cast_wrappers(LV&& lv, RV&& rv) { void test_template_cast_wrappers(LV&& lv, RV&& rv) {
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::forward<LV>(lv); std::forward<LV>(lv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::forward<RV>(rv); std::forward<RV>(rv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::move(lv); std::move(lv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::move(rv); std::move(rv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::move_if_noexcept(lv); std::move_if_noexcept(lv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::move_if_noexcept(rv); std::move_if_noexcept(rv);
#if TEST_STD_VER >= 17 #if TEST_STD_VER >= 17
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::as_const(lv); std::as_const(lv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::as_const(rv); std::as_const(rv);
#endif #endif
#if TEST_STD_VER >= 20 #if TEST_STD_VER >= 20
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::identity()(lv); std::identity()(lv);
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::identity()(rv); std::identity()(rv);
#endif #endif
} }
void test_nontemplate_cast_wrappers() void test_nontemplate_cast_wrappers()
{ {
#if TEST_STD_VER > 14 #if TEST_STD_VER > 14
std::byte b{42}; std::byte b{42};
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::to_integer<int>(b); std::to_integer<int>(b);
#endif #endif
#if TEST_STD_VER > 17 #if TEST_STD_VER > 17
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::bit_cast<unsigned int>(42); std::bit_cast<unsigned int>(42);
#endif #endif
#if TEST_STD_VER > 20 #if TEST_STD_VER > 20
enum E { Apple, Orange } e = Apple; enum E { Apple, Orange } e = Apple;
// expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}} // expected-warning@+1 {{ignoring return value of function declared with 'nodiscard' attribute}}
std::to_underlying(e); std::to_underlying(e);
#endif #endif
} }
int main(int, char**) { int main(int, char**) {
test_algorithms(); test_algorithms();
int i = 42; int i = 42;
test_template_cast_wrappers(i, std::move(i)); test_template_cast_wrappers(i, std::move(i));
test_nontemplate_cast_wrappers(); test_nontemplate_cast_wrappers();
return 0; return 0;
} }