[libcxx][test] Silence nodiscard warnings for std::expected (llvm#119174)

StephanTLavavej · web-flow · commit cb4433b677a0 · 2024-12-10T07:23:09.000-05:00
I'm exploring marking microsoft/STL's std::expected as [[nodiscard]],
which affects all functions returning std::expected, including its
own monadic member functions.

As usual, libc++'s test suite contains calls to these member functions
to make sure they compile, but it's discarding the returns. I'm adding
void casts to silence the [[nodiscard]] warnings without altering
what the test is covering.
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp
@@ -263,23 +263,23 @@ constexpr void test_val_types() {
 constexpr void test_sfinae() {
   std::expected<NonConst, int> e(std::unexpected<int>(2));
   auto l = [](auto&& x) { return x.non_const(); };
-  e.and_then(l);
-  std::move(e).and_then(l);
+  (void)e.and_then(l);
+  (void)std::move(e).and_then(l);
 }
 
 constexpr void test_move_only_error_type() {
   // Test &&
   {
     std::expected<int, MoveOnlyErrorType> e;
     auto l = [](int) { return std::expected<int, MoveOnlyErrorType>{}; };
-    std::move(e).and_then(l);
+    (void)std::move(e).and_then(l);
   }
 
   // Test const&&
   {
     const std::expected<int, MoveOnlyErrorType> e;
     auto l = [](const int) { return std::expected<int, MoveOnlyErrorType>{}; };
-    std::move(e).and_then(l);
+    (void)std::move(e).and_then(l);
   }
 }
 
@@ -296,10 +296,10 @@ constexpr bool test() {
     return std::expected<int, int>();
   };
 
-  e.and_then(never_called);
-  std::move(e).and_then(never_called);
-  ce.and_then(never_called);
-  std::move(ce).and_then(never_called);
+  (void)e.and_then(never_called);
+  (void)std::move(e).and_then(never_called);
+  (void)ce.and_then(never_called);
+  (void)std::move(ce).and_then(never_called);
 
   return true;
 }
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp
@@ -178,37 +178,37 @@ struct NonConst {
 constexpr void test_sfinae() {
   std::expected<int, NonConst> e{1};
   auto l = [](auto&& x) { return x.non_const(); };
-  e.or_else(l);
-  std::move(e).or_else(l);
+  (void)e.or_else(l);
+  (void)std::move(e).or_else(l);
 }
 
 constexpr void test_move_only_error_type() {
   // Test &
   {
       std::expected<int, MoveOnlyErrorType> e;
       auto l = [](MoveOnlyErrorType&) { return std::expected<int, int>{}; };
-      e.or_else(l);
+      (void)e.or_else(l);
   }
 
   // Test const&
   {
       const std::expected<int, MoveOnlyErrorType> e;
       auto l = [](const MoveOnlyErrorType&) { return std::expected<int, int>{}; };
-      e.or_else(l);
+      (void)e.or_else(l);
   }
 
   // Test &&
   {
       std::expected<int, MoveOnlyErrorType> e;
       auto l = [](MoveOnlyErrorType&&) { return std::expected<int, int>{}; };
-      std::move(e).or_else(l);
+      (void)std::move(e).or_else(l);
   }
 
   // Test const&&
   {
       const std::expected<int, MoveOnlyErrorType> e;
       auto l = [](const MoveOnlyErrorType&&) { return std::expected<int, int>{}; };
-      std::move(e).or_else(l);
+      (void)std::move(e).or_else(l);
   }
 }
 
@@ -225,10 +225,10 @@ constexpr bool test() {
     return std::expected<int, int>();
   };
 
-  e.or_else(never_called);
-  std::move(e).or_else(never_called);
-  ce.or_else(never_called);
-  std::move(ce).or_else(never_called);
+  (void)e.or_else(never_called);
+  (void)std::move(e).or_else(never_called);
+  (void)ce.or_else(never_called);
+  (void)std::move(ce).or_else(never_called);
   return true;
 }
 
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp
@@ -187,27 +187,27 @@ constexpr void test_val_types() {
 constexpr void test_take_val_return_void() {
   std::expected<int, int> e(1);
   int val = 0;
-  e.transform([&val]<typename T>(T&&) -> void {
+  (void)e.transform([&val]<typename T>(T&&) -> void {
     static_assert(std::is_same_v<T, int&>);
     assert(val == 0);
     val = 1;
   });
   assert(val == 1);
-  std::move(e).transform([&val]<typename T>(T&&) -> void {
+  (void)std::move(e).transform([&val]<typename T>(T&&) -> void {
     static_assert(std::is_same_v<T, int>);
     assert(val == 1);
     val = 2;
   });
 
   const auto& ce = e;
   assert(val == 2);
-  ce.transform([&val]<typename T>(T&&) -> void {
+  (void)ce.transform([&val]<typename T>(T&&) -> void {
     static_assert(std::is_same_v<T, const int&>);
     assert(val == 2);
     val = 3;
   });
   assert(val == 3);
-  std::move(ce).transform([&val]<typename T>(T&&) -> void {
+  (void)std::move(ce).transform([&val]<typename T>(T&&) -> void {
     static_assert(std::is_same_v<T, const int>);
     assert(val == 3);
     val = 4;
@@ -227,8 +227,8 @@ constexpr void test_direct_non_list_init() {
 constexpr void test_sfinae() {
   std::expected<NonConst, int> e(std::unexpected<int>(2));
   auto l = [](auto&& x) { return x.non_const(); };
-  e.transform(l);
-  std::move(e).transform(l);
+  (void)e.transform(l);
+  (void)std::move(e).transform(l);
 
   std::expected<int, int> e1(std::unexpected<int>(1));
   const auto& ce1         = e1;
@@ -237,25 +237,25 @@ constexpr void test_sfinae() {
     return std::expected<int, int>();
   };
 
-  e1.transform(never_called);
-  std::move(e1).transform(never_called);
-  ce1.and_then(never_called);
-  std::move(ce1).transform(never_called);
+  (void)e1.transform(never_called);
+  (void)std::move(e1).transform(never_called);
+  (void)ce1.transform(never_called);
+  (void)std::move(ce1).transform(never_called);
 }
 
 constexpr void test_move_only_error_type() {
   // Test &&
   {
       std::expected<int, MoveOnlyErrorType> e;
       auto l = [](int) { return 0; };
-      std::move(e).transform(l);
+      (void)std::move(e).transform(l);
   }
 
   // Test const&&
   {
       const std::expected<int, MoveOnlyErrorType> e;
       auto l = [](const int) { return 0; };
-      std::move(e).transform(l);
+      (void)std::move(e).transform(l);
   }
 }
 
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp
@@ -197,8 +197,8 @@ constexpr void test_direct_non_list_init() {
 constexpr void test_sfinae() {
   std::expected<int, NonConst> e(2);
   auto l = [](auto&& x) { return x.non_const(); };
-  e.transform_error(l);
-  std::move(e).transform_error(l);
+  (void)e.transform_error(l);
+  (void)std::move(e).transform_error(l);
 
   std::expected<int, int> e1;
   const auto& ce1 = e1;
@@ -208,39 +208,39 @@ constexpr void test_sfinae() {
     return 0;
   };
 
-  e1.transform_error(never_called);
-  std::move(e1).transform_error(never_called);
-  ce1.transform_error(never_called);
-  std::move(ce1).transform_error(never_called);
+  (void)e1.transform_error(never_called);
+  (void)std::move(e1).transform_error(never_called);
+  (void)ce1.transform_error(never_called);
+  (void)std::move(ce1).transform_error(never_called);
 }
 
 constexpr void test_move_only_error_type() {
   // Test &
   {
       std::expected<int, MoveOnlyErrorType> e;
       auto l = [](MoveOnlyErrorType&) { return 0; };
-      e.transform_error(l);
+      (void)e.transform_error(l);
   }
 
   // Test const&
   {
       const std::expected<int, MoveOnlyErrorType> e;
       auto l = [](const MoveOnlyErrorType&) { return 0; };
-      e.transform_error(l);
+      (void)e.transform_error(l);
   }
 
   // Test &&
   {
       std::expected<int, MoveOnlyErrorType> e;
       auto l = [](MoveOnlyErrorType&&) { return 0; };
-      std::move(e).transform_error(l);
+      (void)std::move(e).transform_error(l);
   }
 
   // Test const&&
   {
       const std::expected<int, MoveOnlyErrorType> e;
       auto l = [](const MoveOnlyErrorType&&) { return 0; };
-      std::move(e).transform_error(l);
+      (void)std::move(e).transform_error(l);
   }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -263,23 +263,23 @@ constexpr void test_val_types() {`
`263`	`263`	`constexpr void test_sfinae() {`
`264`	`264`	`std::expected<NonConst, int> e(std::unexpected<int>(2));`
`265`	`265`	`auto l = [](auto&& x) { return x.non_const(); };`
`266`		`- e.and_then(l);`
`267`		`- std::move(e).and_then(l);`
	`266`	`+ (void)e.and_then(l);`
	`267`	`+ (void)std::move(e).and_then(l);`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`constexpr void test_move_only_error_type() {`
`271`	`271`	`// Test &&`
`272`	`272`	`{`
`273`	`273`	`std::expected<int, MoveOnlyErrorType> e;`
`274`	`274`	`auto l = [](int) { return std::expected<int, MoveOnlyErrorType>{}; };`
`275`		`- std::move(e).and_then(l);`
	`275`	`+ (void)std::move(e).and_then(l);`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`// Test const&&`
`279`	`279`	`{`
`280`	`280`	`const std::expected<int, MoveOnlyErrorType> e;`
`281`	`281`	`auto l = [](const int) { return std::expected<int, MoveOnlyErrorType>{}; };`
`282`		`- std::move(e).and_then(l);`
	`282`	`+ (void)std::move(e).and_then(l);`
`283`	`283`	`}`
`284`	`284`	`}`
`285`	`285`
`@@ -296,10 +296,10 @@ constexpr bool test() {`
`296`	`296`	`return std::expected<int, int>();`
`297`	`297`	`};`
`298`	`298`
`299`		`- e.and_then(never_called);`
`300`		`- std::move(e).and_then(never_called);`
`301`		`- ce.and_then(never_called);`
`302`		`- std::move(ce).and_then(never_called);`
	`299`	`+ (void)e.and_then(never_called);`
	`300`	`+ (void)std::move(e).and_then(never_called);`
	`301`	`+ (void)ce.and_then(never_called);`
	`302`	`+ (void)std::move(ce).and_then(never_called);`
`303`	`303`
`304`	`304`	`return true;`
`305`	`305`	`}`
Original file line number	Diff line number	Diff line change
`@@ -178,37 +178,37 @@ struct NonConst {`
`178`	`178`	`constexpr void test_sfinae() {`
`179`	`179`	`std::expected<int, NonConst> e{1};`
`180`	`180`	`auto l = [](auto&& x) { return x.non_const(); };`
`181`		`- e.or_else(l);`
`182`		`- std::move(e).or_else(l);`
	`181`	`+ (void)e.or_else(l);`
	`182`	`+ (void)std::move(e).or_else(l);`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`constexpr void test_move_only_error_type() {`
`186`	`186`	`// Test &`
`187`	`187`	`{`
`188`	`188`	`std::expected<int, MoveOnlyErrorType> e;`
`189`	`189`	`auto l = [](MoveOnlyErrorType&) { return std::expected<int, int>{}; };`
`190`		`- e.or_else(l);`
	`190`	`+ (void)e.or_else(l);`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`// Test const&`
`194`	`194`	`{`
`195`	`195`	`const std::expected<int, MoveOnlyErrorType> e;`
`196`	`196`	`auto l = [](const MoveOnlyErrorType&) { return std::expected<int, int>{}; };`
`197`		`- e.or_else(l);`
	`197`	`+ (void)e.or_else(l);`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`// Test &&`
`201`	`201`	`{`
`202`	`202`	`std::expected<int, MoveOnlyErrorType> e;`
`203`	`203`	`auto l = [](MoveOnlyErrorType&&) { return std::expected<int, int>{}; };`
`204`		`- std::move(e).or_else(l);`
	`204`	`+ (void)std::move(e).or_else(l);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`// Test const&&`
`208`	`208`	`{`
`209`	`209`	`const std::expected<int, MoveOnlyErrorType> e;`
`210`	`210`	`auto l = [](const MoveOnlyErrorType&&) { return std::expected<int, int>{}; };`
`211`		`- std::move(e).or_else(l);`
	`211`	`+ (void)std::move(e).or_else(l);`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`
`@@ -225,10 +225,10 @@ constexpr bool test() {`
`225`	`225`	`return std::expected<int, int>();`
`226`	`226`	`};`
`227`	`227`
`228`		`- e.or_else(never_called);`
`229`		`- std::move(e).or_else(never_called);`
`230`		`- ce.or_else(never_called);`
`231`		`- std::move(ce).or_else(never_called);`
	`228`	`+ (void)e.or_else(never_called);`
	`229`	`+ (void)std::move(e).or_else(never_called);`
	`230`	`+ (void)ce.or_else(never_called);`
	`231`	`+ (void)std::move(ce).or_else(never_called);`
`232`	`232`	`return true;`
`233`	`233`	`}`
`234`	`234`
Original file line number	Diff line number	Diff line change
`@@ -197,8 +197,8 @@ constexpr void test_direct_non_list_init() {`
`197`	`197`	`constexpr void test_sfinae() {`
`198`	`198`	`std::expected<int, NonConst> e(2);`
`199`	`199`	`auto l = [](auto&& x) { return x.non_const(); };`
`200`		`- e.transform_error(l);`
`201`		`- std::move(e).transform_error(l);`
	`200`	`+ (void)e.transform_error(l);`
	`201`	`+ (void)std::move(e).transform_error(l);`
`202`	`202`
`203`	`203`	`std::expected<int, int> e1;`
`204`	`204`	`const auto& ce1 = e1;`
`@@ -208,39 +208,39 @@ constexpr void test_sfinae() {`
`208`	`208`	`return 0;`
`209`	`209`	`};`
`210`	`210`
`211`		`- e1.transform_error(never_called);`
`212`		`- std::move(e1).transform_error(never_called);`
`213`		`- ce1.transform_error(never_called);`
`214`		`- std::move(ce1).transform_error(never_called);`
	`211`	`+ (void)e1.transform_error(never_called);`
	`212`	`+ (void)std::move(e1).transform_error(never_called);`
	`213`	`+ (void)ce1.transform_error(never_called);`
	`214`	`+ (void)std::move(ce1).transform_error(never_called);`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`constexpr void test_move_only_error_type() {`
`218`	`218`	`// Test &`
`219`	`219`	`{`
`220`	`220`	`std::expected<int, MoveOnlyErrorType> e;`
`221`	`221`	`auto l = [](MoveOnlyErrorType&) { return 0; };`
`222`		`- e.transform_error(l);`
	`222`	`+ (void)e.transform_error(l);`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`// Test const&`
`226`	`226`	`{`
`227`	`227`	`const std::expected<int, MoveOnlyErrorType> e;`
`228`	`228`	`auto l = [](const MoveOnlyErrorType&) { return 0; };`
`229`		`- e.transform_error(l);`
	`229`	`+ (void)e.transform_error(l);`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`// Test &&`
`233`	`233`	`{`
`234`	`234`	`std::expected<int, MoveOnlyErrorType> e;`
`235`	`235`	`auto l = [](MoveOnlyErrorType&&) { return 0; };`
`236`		`- std::move(e).transform_error(l);`
	`236`	`+ (void)std::move(e).transform_error(l);`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`// Test const&&`
`240`	`240`	`{`
`241`	`241`	`const std::expected<int, MoveOnlyErrorType> e;`
`242`	`242`	`auto l = [](const MoveOnlyErrorType&&) { return 0; };`
`243`		`- std::move(e).transform_error(l);`
	`243`	`+ (void)std::move(e).transform_error(l);`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`