Workaround Intellisense bug in some ranges::to tests (#4895)

CaseyCarter · web-flow · commit 62205ab155d0 · 2024-08-19T05:22:26.000-07:00
diff --git a/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp b/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
@@ -156,11 +156,13 @@ struct mappish_instantiator {
             assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected, any_pair_eq));
         }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
         {
             std::same_as<T> auto c6 = R{some_pairs} | ranges::to<T>(Alloc{13});
             assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected, any_pair_eq));
         }
+#endif // ^^^ no workaround ^^^
         {
             std::same_as<T> auto c7 = R{some_pairs} | ranges::to<C>(Alloc{13});
             assert(c7.get_allocator().state == 13);
diff --git a/tests/std/tests/P1206R7_ranges_to_misc/test.cpp b/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
@@ -54,13 +54,15 @@ struct reservable {
 };
 
 constexpr bool test_reservable() {
+#ifndef __EDG__ // TRANSITION, VSO-2208356
     int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     {
         std::same_as<reservable> auto r = some_ints | ranges::to<reservable>(secret_key);
         assert(r.size_ == ranges::size(some_ints));
         assert(r.cap_ == ranges::size(some_ints));
         assert(r.reserved_ == ranges::size(some_ints));
     }
+#endif // ^^^ no workaround ^^^
 
     return true;
 }
@@ -91,12 +93,14 @@ constexpr bool test_common_constructible() {
         assert(c0.last_ == ranges::end(some_ints));
         assert(c0.args_ == 3);
     }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
     {
         std::same_as<common_constructible> auto c1 = some_ints | ranges::to<common_constructible>(secret_key);
         assert(c1.first_ == ranges::begin(some_ints));
         assert(c1.last_ == ranges::end(some_ints));
         assert(c1.args_ == 3);
     }
+#endif // ^^^ no workaround ^^^
 
     // Verify that more than one argument can be passed after the range:
     {
@@ -105,12 +109,14 @@ constexpr bool test_common_constructible() {
         assert(c2.last_ == ranges::end(some_ints));
         assert(c2.args_ == 4);
     }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
     {
         std::same_as<common_constructible> auto c3 = some_ints | ranges::to<common_constructible>(secret_key, 3.14);
         assert(c3.first_ == ranges::begin(some_ints));
         assert(c3.last_ == ranges::end(some_ints));
         assert(c3.args_ == 4);
     }
+#endif // ^^^ no workaround ^^^
 
     return true;
 }
@@ -296,6 +302,7 @@ constexpr void test_lwg4016_per_kind() {
         std::same_as<V> auto vec = std::views::iota(0, 42) | ranges::to<V>();
         assert(ranges::equal(vec, std::views::iota(0, 42)));
     }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
     {
         std::same_as<V> auto vec = std::views::iota(0, 42) | ranges::to<V>(std::allocator<int>{});
         assert(ranges::equal(vec, std::views::iota(0, 42)));
@@ -308,6 +315,7 @@ constexpr void test_lwg4016_per_kind() {
         std::same_as<V> auto vec = std::views::empty<int> | ranges::to<V>(std::size_t{42}, std::allocator<int>{});
         assert(ranges::equal(vec, std::views::repeat(0, 42)));
     }
+#endif // ^^^ no workaround ^^^
     {
         std::same_as<V> auto vec = ranges::to<V>(std::views::iota(0, 42), std::initializer_list<int>{-3, -2, -1});
         assert(ranges::equal(vec, std::views::iota(-3, 42)));
diff --git a/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp b/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp
@@ -145,11 +145,13 @@ struct sequence_instantiator {
             assert(c5.get_allocator().state == 13);
             assert(ranges::equal(c5, meow));
         }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
         {
             std::same_as<T> auto c6 = R{meow} | ranges::to<T>(Alloc{13});
             assert(c6.get_allocator().state == 13);
             assert(ranges::equal(c6, meow));
         }
+#endif // ^^^ no workaround ^^^
         {
             std::same_as<T> auto c7 = R{meow} | ranges::to<C>(Alloc{13});
             assert(c7.get_allocator().state == 13);
diff --git a/tests/std/tests/P1206R7_ranges_to_settish/test.cpp b/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
@@ -150,11 +150,13 @@ struct settish_instantiator {
             assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected));
         }
+#ifndef __EDG__ // TRANSITION, VSO-2208356
         {
             std::same_as<T> auto c6 = R{some_ints} | ranges::to<T>(Alloc{13});
             assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected));
         }
+#endif // ^^^ no workaround ^^^
         {
             std::same_as<T> auto c7 = R{some_ints} | ranges::to<C>(Alloc{13});
             assert(c7.get_allocator().state == 13);

Original file line number	Diff line number	Diff line change
`@@ -156,11 +156,13 @@ struct mappish_instantiator {`
`156`	`156`	`assert(c5.get_allocator().state == 13);`
`157`	`157`	`assert(ranges::is_permutation(c5, expected, any_pair_eq));`
`158`	`158`	`}`
	`159`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`159`	`160`	`{`
`160`	`161`	`std::same_as<T> auto c6 = R{some_pairs} \| ranges::to<T>(Alloc{13});`
`161`	`162`	`assert(c6.get_allocator().state == 13);`
`162`	`163`	`assert(ranges::is_permutation(c6, expected, any_pair_eq));`
`163`	`164`	`}`
	`165`	`+#endif // ^^^ no workaround ^^^`
`164`	`166`	`{`
`165`	`167`	`std::same_as<T> auto c7 = R{some_pairs} \| ranges::to<C>(Alloc{13});`
`166`	`168`	`assert(c7.get_allocator().state == 13);`
Original file line number	Diff line number	Diff line change
`@@ -54,13 +54,15 @@ struct reservable {`
`54`	`54`	`};`
`55`	`55`
`56`	`56`	`constexpr bool test_reservable() {`
	`57`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`57`	`58`	`int some_ints[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};`
`58`	`59`	`{`
`59`	`60`	`std::same_as<reservable> auto r = some_ints \| ranges::to<reservable>(secret_key);`
`60`	`61`	`assert(r.size_ == ranges::size(some_ints));`
`61`	`62`	`assert(r.cap_ == ranges::size(some_ints));`
`62`	`63`	`assert(r.reserved_ == ranges::size(some_ints));`
`63`	`64`	`}`
	`65`	`+#endif // ^^^ no workaround ^^^`
`64`	`66`
`65`	`67`	`return true;`
`66`	`68`	`}`
`@@ -91,12 +93,14 @@ constexpr bool test_common_constructible() {`
`91`	`93`	`assert(c0.last_ == ranges::end(some_ints));`
`92`	`94`	`assert(c0.args_ == 3);`
`93`	`95`	`}`
	`96`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`94`	`97`	`{`
`95`	`98`	`std::same_as<common_constructible> auto c1 = some_ints \| ranges::to<common_constructible>(secret_key);`
`96`	`99`	`assert(c1.first_ == ranges::begin(some_ints));`
`97`	`100`	`assert(c1.last_ == ranges::end(some_ints));`
`98`	`101`	`assert(c1.args_ == 3);`
`99`	`102`	`}`
	`103`	`+#endif // ^^^ no workaround ^^^`
`100`	`104`
`101`	`105`	`// Verify that more than one argument can be passed after the range:`
`102`	`106`	`{`
`@@ -105,12 +109,14 @@ constexpr bool test_common_constructible() {`
`105`	`109`	`assert(c2.last_ == ranges::end(some_ints));`
`106`	`110`	`assert(c2.args_ == 4);`
`107`	`111`	`}`
	`112`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`108`	`113`	`{`
`109`	`114`	`std::same_as<common_constructible> auto c3 = some_ints \| ranges::to<common_constructible>(secret_key, 3.14);`
`110`	`115`	`assert(c3.first_ == ranges::begin(some_ints));`
`111`	`116`	`assert(c3.last_ == ranges::end(some_ints));`
`112`	`117`	`assert(c3.args_ == 4);`
`113`	`118`	`}`
	`119`	`+#endif // ^^^ no workaround ^^^`
`114`	`120`
`115`	`121`	`return true;`
`116`	`122`	`}`
`@@ -296,6 +302,7 @@ constexpr void test_lwg4016_per_kind() {`
`296`	`302`	`std::same_as<V> auto vec = std::views::iota(0, 42) \| ranges::to<V>();`
`297`	`303`	`assert(ranges::equal(vec, std::views::iota(0, 42)));`
`298`	`304`	`}`
	`305`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`299`	`306`	`{`
`300`	`307`	`std::same_as<V> auto vec = std::views::iota(0, 42) \| ranges::to<V>(std::allocator<int>{});`
`301`	`308`	`assert(ranges::equal(vec, std::views::iota(0, 42)));`
`@@ -308,6 +315,7 @@ constexpr void test_lwg4016_per_kind() {`
`308`	`315`	`std::same_as<V> auto vec = std::views::empty<int> \| ranges::to<V>(std::size_t{42}, std::allocator<int>{});`
`309`	`316`	`assert(ranges::equal(vec, std::views::repeat(0, 42)));`
`310`	`317`	`}`
	`318`	`+#endif // ^^^ no workaround ^^^`
`311`	`319`	`{`
`312`	`320`	`std::same_as<V> auto vec = ranges::to<V>(std::views::iota(0, 42), std::initializer_list<int>{-3, -2, -1});`
`313`	`321`	`assert(ranges::equal(vec, std::views::iota(-3, 42)));`
Original file line number	Diff line number	Diff line change
`@@ -145,11 +145,13 @@ struct sequence_instantiator {`
`145`	`145`	`assert(c5.get_allocator().state == 13);`
`146`	`146`	`assert(ranges::equal(c5, meow));`
`147`	`147`	`}`
	`148`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`148`	`149`	`{`
`149`	`150`	`std::same_as<T> auto c6 = R{meow} \| ranges::to<T>(Alloc{13});`
`150`	`151`	`assert(c6.get_allocator().state == 13);`
`151`	`152`	`assert(ranges::equal(c6, meow));`
`152`	`153`	`}`
	`154`	`+#endif // ^^^ no workaround ^^^`
`153`	`155`	`{`
`154`	`156`	`std::same_as<T> auto c7 = R{meow} \| ranges::to<C>(Alloc{13});`
`155`	`157`	`assert(c7.get_allocator().state == 13);`
Original file line number	Diff line number	Diff line change
`@@ -150,11 +150,13 @@ struct settish_instantiator {`
`150`	`150`	`assert(c5.get_allocator().state == 13);`
`151`	`151`	`assert(ranges::is_permutation(c5, expected));`
`152`	`152`	`}`
	`153`	`+#ifndef __EDG__ // TRANSITION, VSO-2208356`
`153`	`154`	`{`
`154`	`155`	`std::same_as<T> auto c6 = R{some_ints} \| ranges::to<T>(Alloc{13});`
`155`	`156`	`assert(c6.get_allocator().state == 13);`
`156`	`157`	`assert(ranges::is_permutation(c6, expected));`
`157`	`158`	`}`
	`159`	`+#endif // ^^^ no workaround ^^^`
`158`	`160`	`{`
`159`	`161`	`std::same_as<T> auto c7 = R{some_ints} \| ranges::to<C>(Alloc{13});`
`160`	`162`	`assert(c7.get_allocator().state == 13);`