Gate ref tests, use std::same_as suggestion

smallp-o-p · smallp-o-p · commit c12481f0eefe · 2025-09-24T23:58:47.000-04:00
diff --git a/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp b/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp
@@ -16,6 +16,7 @@
 // template<class F> constexpr auto and_then(F&&) const&&;
 
 #include <cassert>
+#include <concepts>
 #include <optional>
 
 #include "test_macros.h"
@@ -265,20 +266,22 @@ constexpr bool test_ref() {
     {
       int j = 42;
       std::optional<int&> i{j};
-      assert(i.and_then(LVal{}) == 1);
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(LVal{});
+
+      assert(r == 1);
       assert(i.and_then(NOLVal{}) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(LVal{})), std::optional<int>);
     }
 
     //With & qualifier on F's operator()
     {
       int j = 42;
       std::optional<int&> i{j};
       RefQual l{};
-      assert(i.and_then(l) == 1);
       NORefQual nl{};
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(l);
+
+      assert(r == 1);
       assert(i.and_then(nl) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(l)), std::optional<int>);
     }
   }
 
@@ -288,20 +291,22 @@ constexpr bool test_ref() {
     {
       int j = 42;
       std::optional<const int&> i{j};
-      assert(i.and_then(CLVal{}) == 1);
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(CLVal{});
+
+      assert(r == 1);
       assert(i.and_then(NOCLVal{}) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(CLVal{})), std::optional<int>);
     }
 
     //With & qualifier on F's operator()
     {
       int j = 42;
       const std::optional<int&> i{j};
       const CRefQual l{};
-      assert(i.and_then(l) == 1);
       const NOCRefQual nl{};
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(l);
+
+      assert(r == 1);
       assert(i.and_then(nl) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(l)), std::optional<int>);
     }
   }
   // Test && overload
@@ -310,9 +315,10 @@ constexpr bool test_ref() {
     {
       int j = 42;
       std::optional<int&> i{j};
-      assert(i.and_then(RVRefQual{}) == 1);
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(RVRefQual{});
+
+      assert(r == 1);
       assert(i.and_then(NORVRefQual{}) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(RVRefQual{})), std::optional<int>);
     }
   }
 
@@ -323,10 +329,11 @@ constexpr bool test_ref() {
       int j = 42;
       const std::optional<int&> i{j};
       const RVCRefQual l{};
-      assert(i.and_then(std::move(l)) == 1);
       const NORVCRefQual nl{};
+      std::same_as<std::optional<int>> decltype(auto) r = i.and_then(std::move(l));
+
+      assert(r == 1);
       assert(i.and_then(std::move(nl)) == std::nullopt);
-      ASSERT_SAME_TYPE(decltype(i.and_then(std::move(l))), std::optional<int>);
     }
   }
   return true;
@@ -336,7 +343,9 @@ constexpr bool test_ref() {
 int main(int, char**) {
   test();
   static_assert(test());
+#if TEST_STD_VER >= 26
   test_ref();
   static_assert(test_ref());
+#endif
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp b/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp
@@ -17,6 +17,7 @@
 
 #include "test_macros.h"
 #include <cassert>
+#include <concepts>
 #include <optional>
 #include <type_traits>
 #include <utility>
@@ -201,40 +202,41 @@ constexpr bool test() {
   return true;
 }
 
+#if TEST_STD_VER >= 26
 constexpr bool test_ref() {
   {
     std::optional<int&> opt1;
-    auto opt1r = opt1.transform([](int i) { return i + 2; });
+    std::same_as<std::optional<int>> decltype(auto) opt1r = opt1.transform([](int i) { return i + 2; });
     assert(!opt1);
-    ASSERT_SAME_TYPE(decltype(opt1r), std::optional<int>);
+    assert(!opt1r);
   }
 
   {
     int i = 42;
     std::optional<int&> opt{i};
-    auto o2 = opt.transform([](int j) { return j + 2; });
+    std::same_as<std::optional<int>> decltype(auto) o2 = opt.transform([](int i) { return i + 2; });
+
     assert(*o2 == 44);
-    ASSERT_SAME_TYPE(decltype(o2), std::optional<int>);
   }
   // Test & overload
   {
     // Without & qualifier on F's operator()
     {
       int i = 42;
       std::optional<int&> opt{i};
-      auto o3 = opt.transform(LVal{});
+      std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(LVal{});
+
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
 
     //With & qualifier on F's operator()
     {
       int i = 42;
       std::optional<int&> opt{i};
       RefQual l{};
-      auto o3 = opt.transform(l);
+      std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(l);
+
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
   }
   // const& overload
@@ -243,19 +245,19 @@ constexpr bool test_ref() {
     {
       int i = 42;
       std::optional<const int&> opt{i};
-      auto o3 = std::as_const(opt).transform(CLVal{});
+      std::same_as<std::optional<int>> decltype(auto) o3 = std::as_const(opt).transform(CLVal{});
+
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
 
     //With & qualifier on F's operator()
     {
       int i = 42;
       const std::optional<int&> opt{i};
       const CRefQual l{};
-      auto o3 = opt.transform(l);
+      std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(l);
+
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
   }
 
@@ -265,18 +267,17 @@ constexpr bool test_ref() {
     {
       int i = 42;
       std::optional<int> opt{i};
-      auto o3 = std::move(opt).transform(RVal{});
+      std::same_as<std::optional<int>> decltype(auto) o3 = std::move(opt).transform(RVal{});
+
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
 
     //With & qualifier on F's operator()
     {
       int i = 42;
       std::optional<int&> opt{i};
-      auto o3 = std::move(opt).transform(RVRefQual{});
+      std::same_as<std::optional<int>> decltype(auto) o3 = std::move(opt).transform(RVRefQual{});
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
   }
 
@@ -287,9 +288,8 @@ constexpr bool test_ref() {
       int i = 42;
       std::optional<int&> opt{i};
       const RVCRefQual rvc{};
-      auto o3 = opt.transform(std::move(rvc));
+      std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(std::move(rvc));
       assert(*o3 == 1);
-      ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);
     }
   }
   {
@@ -299,11 +299,14 @@ constexpr bool test_ref() {
   }
   return true;
 }
+#endif
 
 int main(int, char**) {
   test();
   static_assert(test());
+#if TEST_STD_VER >= 26
   test_ref();
   static_assert(test_ref());
+#endif
   return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`
`18`	`18`	`#include "test_macros.h"`
`19`	`19`	`#include <cassert>`
	`20`	`+#include <concepts>`
`20`	`21`	`#include <optional>`
`21`	`22`	`#include <type_traits>`
`22`	`23`	`#include <utility>`
`@@ -201,40 +202,41 @@ constexpr bool test() {`
`201`	`202`	`return true;`
`202`	`203`	`}`
`203`	`204`
	`205`	`+#if TEST_STD_VER >= 26`
`204`	`206`	`constexpr bool test_ref() {`
`205`	`207`	`{`
`206`	`208`	`std::optional<int&> opt1;`
`207`		`- auto opt1r = opt1.transform([](int i) { return i + 2; });`
	`209`	`+ std::same_as<std::optional<int>> decltype(auto) opt1r = opt1.transform([](int i) { return i + 2; });`
`208`	`210`	`assert(!opt1);`
`209`		`- ASSERT_SAME_TYPE(decltype(opt1r), std::optional<int>);`
	`211`	`+ assert(!opt1r);`
`210`	`212`	`}`
`211`	`213`
`212`	`214`	`{`
`213`	`215`	`int i = 42;`
`214`	`216`	`std::optional<int&> opt{i};`
`215`		`- auto o2 = opt.transform([](int j) { return j + 2; });`
	`217`	`+ std::same_as<std::optional<int>> decltype(auto) o2 = opt.transform([](int i) { return i + 2; });`
	`218`	`+`
`216`	`219`	`assert(*o2 == 44);`
`217`		`- ASSERT_SAME_TYPE(decltype(o2), std::optional<int>);`
`218`	`220`	`}`
`219`	`221`	`// Test & overload`
`220`	`222`	`{`
`221`	`223`	`// Without & qualifier on F's operator()`
`222`	`224`	`{`
`223`	`225`	`int i = 42;`
`224`	`226`	`std::optional<int&> opt{i};`
`225`		`- auto o3 = opt.transform(LVal{});`
	`227`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(LVal{});`
	`228`	`+`
`226`	`229`	`assert(*o3 == 1);`
`227`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`228`	`230`	`}`
`229`	`231`
`230`	`232`	`//With & qualifier on F's operator()`
`231`	`233`	`{`
`232`	`234`	`int i = 42;`
`233`	`235`	`std::optional<int&> opt{i};`
`234`	`236`	`RefQual l{};`
`235`		`- auto o3 = opt.transform(l);`
	`237`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(l);`
	`238`	`+`
`236`	`239`	`assert(*o3 == 1);`
`237`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`238`	`240`	`}`
`239`	`241`	`}`
`240`	`242`	`// const& overload`
`@@ -243,19 +245,19 @@ constexpr bool test_ref() {`
`243`	`245`	`{`
`244`	`246`	`int i = 42;`
`245`	`247`	`std::optional<const int&> opt{i};`
`246`		`- auto o3 = std::as_const(opt).transform(CLVal{});`
	`248`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = std::as_const(opt).transform(CLVal{});`
	`249`	`+`
`247`	`250`	`assert(*o3 == 1);`
`248`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`249`	`251`	`}`
`250`	`252`
`251`	`253`	`//With & qualifier on F's operator()`
`252`	`254`	`{`
`253`	`255`	`int i = 42;`
`254`	`256`	`const std::optional<int&> opt{i};`
`255`	`257`	`const CRefQual l{};`
`256`		`- auto o3 = opt.transform(l);`
	`258`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(l);`
	`259`	`+`
`257`	`260`	`assert(*o3 == 1);`
`258`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`259`	`261`	`}`
`260`	`262`	`}`
`261`	`263`
`@@ -265,18 +267,17 @@ constexpr bool test_ref() {`
`265`	`267`	`{`
`266`	`268`	`int i = 42;`
`267`	`269`	`std::optional<int> opt{i};`
`268`		`- auto o3 = std::move(opt).transform(RVal{});`
	`270`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = std::move(opt).transform(RVal{});`
	`271`	`+`
`269`	`272`	`assert(*o3 == 1);`
`270`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`271`	`273`	`}`
`272`	`274`
`273`	`275`	`//With & qualifier on F's operator()`
`274`	`276`	`{`
`275`	`277`	`int i = 42;`
`276`	`278`	`std::optional<int&> opt{i};`
`277`		`- auto o3 = std::move(opt).transform(RVRefQual{});`
	`279`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = std::move(opt).transform(RVRefQual{});`
`278`	`280`	`assert(*o3 == 1);`
`279`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`280`	`281`	`}`
`281`	`282`	`}`
`282`	`283`
`@@ -287,9 +288,8 @@ constexpr bool test_ref() {`
`287`	`288`	`int i = 42;`
`288`	`289`	`std::optional<int&> opt{i};`
`289`	`290`	`const RVCRefQual rvc{};`
`290`		`- auto o3 = opt.transform(std::move(rvc));`
	`291`	`+ std::same_as<std::optional<int>> decltype(auto) o3 = opt.transform(std::move(rvc));`
`291`	`292`	`assert(*o3 == 1);`
`292`		`- ASSERT_SAME_TYPE(decltype(o3), std::optional<int>);`
`293`	`293`	`}`
`294`	`294`	`}`
`295`	`295`	`{`
`@@ -299,11 +299,14 @@ constexpr bool test_ref() {`
`299`	`299`	`}`
`300`	`300`	`return true;`
`301`	`301`	`}`
	`302`	`+#endif`
`302`	`303`
`303`	`304`	`int main(int, char**) {`
`304`	`305`	`test();`
`305`	`306`	`static_assert(test());`
	`307`	`+#if TEST_STD_VER >= 26`
`306`	`308`	`test_ref();`
`307`	`309`	`static_assert(test_ref());`
	`310`	`+#endif`
`308`	`311`	`return 0;`
`309`	`312`	`}`