diff --git a/stl/inc/__msvc_bit_utils.hpp b/stl/inc/__msvc_bit_utils.hpp
index 37135c09b04..ca2fec13d1a 100644
--- a/stl/inc/__msvc_bit_utils.hpp
+++ b/stl/inc/__msvc_bit_utils.hpp
@@ -177,7 +177,7 @@ _NODISCARD int _Checked_arm_arm64_countl_zero(const _Ty _Val) noexcept {
     } else {
         return static_cast<int>(_CountLeadingZeros64(_Val));
     }
-#endif // TRANSITION, GH-1586
+#endif // ^^^ no workaround ^^^
 }
 #endif // defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
 #endif // _HAS_COUNTL_ZERO_INTRINSICS
diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index 186e526fe94..6e6ff115103 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -408,7 +408,7 @@ concept weakly_incrementable = movable<_Ty>
     }
 #ifdef __clang__ // TRANSITION, LLVM-48173
     && !same_as<_Ty, bool>
-#endif // TRANSITION, LLVM-48173
+#endif // ^^^ workaround ^^^
     ;
 
 _EXPORT_STD template <class _It>
diff --git a/stl/inc/chrono b/stl/inc/chrono
index 0dc7548bcbe..fc3abc16c08 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -2756,7 +2756,7 @@ namespace chrono {
     _EXPORT_STD template <class _Duration>
     using file_time = time_point<file_clock, _Duration>;
 } // namespace chrono
-#endif // ^^^ _HAS_CXX20
+#endif // ^^^ _HAS_CXX20 ^^^
 
 #if _HAS_CXX17
 namespace filesystem {
@@ -2810,10 +2810,10 @@ namespace filesystem {
 
             return _File_time;
         }
-#endif // ^^^ _HAS_CXX20
+#endif // ^^^ _HAS_CXX20 ^^^
     };
 } // namespace filesystem
-#endif // ^^^ _HAS_CXX17
+#endif // ^^^ _HAS_CXX17 ^^^
 
 #if _HAS_CXX20
 namespace chrono {
@@ -5438,7 +5438,7 @@ namespace chrono {
                             continue;
                         }
                     }
-#endif // defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET == 65001
+#endif // ^^^ no workaround ^^^
 
                     _CharT _Fmt_str[4];
                     _Stream << _STD put_time<_CharT>(&_Time, _Fmt_string(_Spec, _Fmt_str));
diff --git a/stl/inc/expected b/stl/inc/expected
index 2d29ec71392..a8399d7380d 100644
--- a/stl/inc/expected
+++ b/stl/inc/expected
@@ -352,7 +352,7 @@ public:
     constexpr ~expected()
 #ifndef __clang__ // TRANSITION, LLVM-59854
         noexcept
-#endif // !defined(__clang__)
+#endif // ^^^ no workaround ^^^
     {
         if (_Has_value) {
             if constexpr (!is_trivially_destructible_v<_Ty>) {
@@ -1300,7 +1300,7 @@ public:
     constexpr ~expected()
 #ifndef __clang__ // TRANSITION, LLVM-59854
         noexcept
-#endif // !defined(__clang__)
+#endif // ^^^ no workaround ^^^
     {
         if (!_Has_value) {
             _Unexpected.~_Err();
diff --git a/stl/inc/filesystem b/stl/inc/filesystem
index f8bd450813e..2be38683047 100644
--- a/stl/inc/filesystem
+++ b/stl/inc/filesystem
@@ -2125,7 +2125,7 @@ namespace filesystem {
     _EXPORT_STD using file_time_type = _CHRONO time_point<_CHRONO file_clock>;
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
     using file_time_type = _CHRONO time_point<filesystem::_File_time_clock>;
-#endif // ^^^ !_HAS_CXX20
+#endif // ^^^ !_HAS_CXX20 ^^^
 
     struct _Dir_enum_impl;
     struct _Recursive_dir_enum_impl;
diff --git a/stl/inc/format b/stl/inc/format
index 0ac31c5f6d2..2146f12b5c5 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -1174,7 +1174,7 @@ public:
                 __std_fs_convert_narrow_to_wide(__std_code_page{_MSVC_EXECUTION_CHARACTER_SET}, _First, 1, &_Wide, 1);
             _Val = _Wide;
             return {_First + 1, _Res._Len != 0};
-#endif // defined(_MSVC_EXECUTION_CHARACTER_SET)
+#endif // ^^^ no workaround ^^^
         } else {
             if (*_First == '\0') {
                 _Val = U'\0';
diff --git a/stl/inc/ranges b/stl/inc/ranges
index ad6b899e94f..5e820d13bf9 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -1167,14 +1167,14 @@ namespace ranges {
         static constexpr bool _Nothrow_minus_equal<_Left, _Right> = true;
 
     public:
-#endif // TRANSITION, DevCom-1347136
+#endif // ^^^ workaround ^^^
 
         constexpr _Ioterator& operator+=(const difference_type _Off)
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1347136
             noexcept(noexcept(_Current += _Off)) /* strengthened */
 #else // ^^^ no workaround / workaround vvv
             noexcept(_Nothrow_plus_equal<_Wi, difference_type>) /* strengthened */
-#endif // TRANSITION, DevCom-1347136
+#endif // ^^^ workaround ^^^
             requires _Advanceable<_Wi>
         {
             if constexpr (_Integer_like<_Wi>) {
@@ -1198,7 +1198,7 @@ namespace ranges {
             noexcept(noexcept(_Current -= _Off)) /* strengthened */
 #else // ^^^ no workaround / workaround vvv
             noexcept(_Nothrow_minus_equal<_Wi, difference_type>) /* strengthened */
-#endif // TRANSITION, DevCom-1347136
+#endif // ^^^ workaround ^^^
             requires _Advanceable<_Wi>
         {
             if constexpr (_Integer_like<_Wi>) {
diff --git a/stl/inc/tuple b/stl/inc/tuple
index 8a5df17a956..5ec6a1f7db8 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -195,7 +195,7 @@ concept _Can_construct_from_tuple_like =
     && (tuple_size_v<_Tuple> != 1
         || (!is_convertible_v<_TupleLike, tuple_element_t<0, _Tuple>>
             && !is_constructible_v<tuple_element_t<0, _Tuple>, _TupleLike>) );
-#endif // defined(__clang__) || defined(__EDG__)
+#endif // ^^^ workaround ^^^
 
 template <class _TTuple, class _UTuple, class _Indices = make_index_sequence<tuple_size_v<_UTuple>>>
 struct _Three_way_comparison_result_with_tuple_like {};
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index cd840076383..0eeecdc7cbe 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -327,7 +327,7 @@ struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
 _EXPORT_STD template <class _From, class _To>
 _INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
 
-#if !defined(__EDG__) && !defined(__clang__) // TRANSITION, DevCom-1627396
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1627396
 template <class _Ty>
 struct is_convertible<_Ty&, volatile _Ty&> : true_type {};
 
@@ -351,7 +351,7 @@ _INLINE_VAR constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;
 
 template <class _Ty>
 _INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
-#endif // ^^^ workaround
+#endif // ^^^ workaround ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type
@@ -700,7 +700,7 @@ struct is_trivial : bool_constant<__is_trivial(_Ty)> {}; // determine whether _T
 
 _EXPORT_STD template <class _Ty>
 _INLINE_VAR constexpr bool is_trivial_v = __is_trivial(_Ty);
-#endif // TRANSITION
+#endif // ^^^ no workaround ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
@@ -1409,7 +1409,7 @@ struct _Add_qualifiers<_Ty1&&> {
     using _Apply = add_rvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
 };
 
-#if !defined(__EDG__) && !defined(__clang__) // TRANSITION, DevCom-10095944
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10095944
 template <class _Ty1, class _Ty2>
 using _Cond_res_if_right = // N4950 [meta.trans.other]/2.4
     decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());
@@ -1953,7 +1953,7 @@ _EXPORT_STD template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class
 _NODISCARD constexpr bool is_corresponding_member(_MemberTy1 _ClassTy1::*_Pm1, _MemberTy2 _ClassTy2::*_Pm2) noexcept {
     return __is_corresponding_member(_ClassTy1, _ClassTy2, _Pm1, _Pm2);
 }
-#endif // !defined(__clang__)
+#endif // ^^^ no workaround ^^^
 #endif // _HAS_CXX20
 
 template <class _Ty>
@@ -2239,7 +2239,7 @@ struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
 #if _HAS_CXX20
 _EXPORT_STD template <class _From, class _To>
 concept convertible_to =
-#if !defined(__EDG__) && !defined(__clang__) // TRANSITION, DevCom-1627396
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1627396
     is_convertible_v<_From, _To>
 #else // ^^^ workaround / no workaround vvv
     __is_convertible_to(_From, _To)
diff --git a/stl/inc/utility b/stl/inc/utility
index 8442f53c23c..ea7f440dbf4 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -211,7 +211,7 @@ template <class _PairLike, class _Ty1, class _Ty2>
 concept _Can_construct_from_pair_like = _Pair_like<_PairLike> && !_Is_subrange_v<remove_cvref_t<_PairLike>>
                                      && is_constructible_v<_Ty1, decltype(_STD get<0>(_STD declval<_PairLike>()))>
                                      && is_constructible_v<_Ty2, decltype(_STD get<1>(_STD declval<_PairLike>()))>;
-#endif // defined(__clang__) || defined(__EDG__)
+#endif // ^^^ workaround ^^^
 #endif // _HAS_CXX23
 #endif // _HAS_CXX20
 
diff --git a/stl/inc/variant b/stl/inc/variant
index a8b7d80c1d6..0c32c892a19 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -509,7 +509,7 @@ public:
         return _STD move(_Head)._Item;
     }
 };
-#endif // defined(__cplusplus_winrt)
+#endif // ^^^ workaround ^^^
 
 template <size_t _Idx, class _Storage>
 _NODISCARD constexpr decltype(auto) _Variant_raw_get(_Storage&& _Obj) noexcept {
@@ -1088,7 +1088,7 @@ public:
 #ifdef __clang__ // TRANSITION, LLVM-45398
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-lambda-capture"
-#endif // TRANSITION, LLVM-45398
+#endif // ^^^ workaround ^^^
     _CONSTEXPR20 void swap(variant& _That) noexcept(
         conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
         // exchange the contained values if *this and _That hold the same alternative, otherwise exchange the values of
@@ -1149,7 +1149,7 @@ public:
     }
 #ifdef __clang__ // TRANSITION, LLVM-45398
 #pragma clang diagnostic pop
-#endif // TRANSITION, LLVM-45398
+#endif // ^^^ workaround ^^^
 
 private:
     template <size_t _Idx, class... _ArgTypes>
@@ -1425,7 +1425,9 @@ struct _Variant_dispatcher<index_sequence<_Is...>> {
     template <class _Ret, class _Callable, class... _Types, bool _Any_valueless = ((_Is == 0) || ...)>
     _NODISCARD static constexpr _Ret _Dispatch2(_Callable&& _Obj, _Types&&... _Args) {
         if constexpr (_Any_valueless) {
-            ((void) _Args, ...); // TRANSITION, VSO-1513409
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1513409
+            ((void) _Args, ...);
+#endif // ^^^ workaround ^^^
             _STD _Throw_bad_variant_access();
         }
 #if _HAS_CXX20
diff --git a/stl/inc/xstring b/stl/inc/xstring
index f1c3ee4ae09..5db569ed96b 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -346,7 +346,7 @@ template <>
 struct char_traits<unsigned short> : _WChar_traits<unsigned short> {};
 #endif // defined(_CRTBLD)
 
-#if defined(__cpp_char8_t) && !defined(__EDG__) && !defined(__clang__)
+#if defined(__cpp_char8_t) && !defined(__clang__) && !defined(__EDG__)
 #define _HAS_U8_INTRINSICS 1
 #else // ^^^ Use intrinsics for char8_t / don't use said intrinsics vvv
 #define _HAS_U8_INTRINSICS 0
diff --git a/stl/inc/xutility b/stl/inc/xutility
index c0f37e2b545..08e73238dff 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -238,7 +238,7 @@ _EXPORT_STD template <class _Ty, class... _Types,
 // per LWG-3888
 _EXPORT_STD template <class _Ty, class... _Types,
     void_t<decltype(::new(static_cast<void*>(_STD declval<_Ty*>())) _Ty(_STD declval<_Types>()...))>* = nullptr>
-#endif // TRANSITION, DevCom-1691516
+#endif // ^^^ workaround ^^^
 constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
     noexcept(::new(static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
     _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...);
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index db28a57567e..3b7b1b402be 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1758,13 +1758,13 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 
 #ifndef __clang__ // TRANSITION, LLVM-48860
 #define __cpp_lib_is_layout_compatible 201907L
-#endif // !defined(__clang__)
+#endif // ^^^ no workaround ^^^
 
 #define __cpp_lib_is_nothrow_convertible 201806L
 
 #ifndef __clang__ // TRANSITION, LLVM-48860
 #define __cpp_lib_is_pointer_interconvertible 201907L
-#endif // !defined(__clang__)
+#endif // ^^^ no workaround ^^^
 
 #define __cpp_lib_jthread                 201911L
 #define __cpp_lib_latch                   201907L
@@ -1773,7 +1773,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 
 #if !defined(__clang__) && !defined(__EDG__) // TRANSITION, Clang and EDG support for modules
 #define __cpp_lib_modules 202207L
-#endif // !defined(__clang__) && !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
 #define __cpp_lib_move_iterator_concept   202207L
 #define __cpp_lib_polymorphic_allocator   201902L
diff --git a/stl/src/atomic_wait.cpp b/stl/src/atomic_wait.cpp
index 123e8dcf57b..b45ed197403 100644
--- a/stl/src/atomic_wait.cpp
+++ b/stl/src/atomic_wait.cpp
@@ -410,7 +410,7 @@ _Smtx_t* __stdcall __std_atomic_get_mutex(const void* const _Key) noexcept {
     }
 
     return __std_atomic_compare_exchange_128_fallback(_Destination, _ExchangeHigh, _ExchangeLow, _ComparandResult);
-#endif // ^^^ _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 0
+#endif // ^^^ _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 0 ^^^
 }
 
 [[nodiscard]] char __stdcall __std_atomic_has_cmpxchg16b() noexcept {
@@ -432,6 +432,6 @@ _Smtx_t* __stdcall __std_atomic_get_mutex(const void* const _Key) noexcept {
     }
 
     return _Value;
-#endif // ^^^ _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 0
+#endif // ^^^ _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 0 ^^^
 }
 } // extern "C"
diff --git a/tests/std/include/test_atomic_wait.hpp b/tests/std/include/test_atomic_wait.hpp
index 9322cd5454a..2999cb57100 100644
--- a/tests/std/include/test_atomic_wait.hpp
+++ b/tests/std/include/test_atomic_wait.hpp
@@ -291,5 +291,5 @@ inline void test_atomic_wait() {
     test_pad_bits<with_padding_bits<16>>(waiting_duration);
     test_pad_bits<with_padding_bits<32>>(waiting_duration);
 #endif // ^^^ !ARM ^^^
-#endif // __clang__, TRANSITION, LLVM-46685
+#endif // ^^^ no workaround ^^^
 }
diff --git a/tests/std/tests/Dev11_0235721_async_and_packaged_task/test.cpp b/tests/std/tests/Dev11_0235721_async_and_packaged_task/test.cpp
index 95bb8f044e6..e4672fe3ed0 100644
--- a/tests/std/tests/Dev11_0235721_async_and_packaged_task/test.cpp
+++ b/tests/std/tests/Dev11_0235721_async_and_packaged_task/test.cpp
@@ -354,7 +354,7 @@ struct use_async_in_a_global_tester {
 };
 
 use_async_in_a_global_tester use_async_in_a_global_instance;
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 int main() {
     test_DevDiv_235721();
diff --git a/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp b/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
index c5ea48f6893..492030269dc 100644
--- a/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
+++ b/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
@@ -1395,7 +1395,7 @@ _CONSTEXPR20 bool test_mem_fn() {
     assert(mem_fn(&Widget::unary_lv)(&w, 6) == 1061);
 
     assert(mem_fn(&Widget::unary_rv)(move(w), 7) == 1404);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
     return true;
 }
diff --git a/tests/std/tests/GH_000140_adl_proof_comparison/test.compile.pass.cpp b/tests/std/tests/GH_000140_adl_proof_comparison/test.compile.pass.cpp
index 0f79ab7635d..70c5665ca46 100644
--- a/tests/std/tests/GH_000140_adl_proof_comparison/test.compile.pass.cpp
+++ b/tests/std/tests/GH_000140_adl_proof_comparison/test.compile.pass.cpp
@@ -288,4 +288,4 @@ void test_adl_proof_basic_const_iterator_comparison() {
 }
 #endif // _HAS_CXX23
 
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/GH_000431_equal_family/test.cpp b/tests/std/tests/GH_000431_equal_family/test.cpp
index b01b0b8b56a..00c835d9ad1 100644
--- a/tests/std/tests/GH_000431_equal_family/test.cpp
+++ b/tests/std/tests/GH_000431_equal_family/test.cpp
@@ -661,7 +661,7 @@ void test_algorithms(EqualFn equal_fn) {
         assert(!equal_fn(begin(arr6), end(arr6), begin(arr7), end(arr7), equal_to<>{}));
         assert(!equal_fn(begin(arr6), end(arr6), begin(arr7), end(arr7), equal_to<mfn_ptr2>{}));
     }
-#endif // _M_CEE_PURE
+#endif // ^^^ no workaround ^^^
 
     { // Test vector
         vector<int> arr1 = {3, 6, 4, 7, 3};
diff --git a/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp b/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
index 0bbddc0e17b..d8d6189b82d 100644
--- a/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
+++ b/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
@@ -115,7 +115,7 @@ int main() {
 
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-10416247
     STATIC_ASSERT(std::is_nothrow_default_constructible_v<std::gslice>); // strengthened
-#endif // defined(__clang__) || defined(__EDG__)
+#endif // ^^^ no workaround ^^^
     std::gslice gs{};
     STATIC_ASSERT(noexcept(gs.start())); // strengthened
 }
diff --git a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp
index 07ed0ee1e3a..0af0bbb1cff 100644
--- a/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp
+++ b/tests/std/tests/GH_001596_adl_proof_algorithms/test.compile.pass.cpp
@@ -632,4 +632,4 @@ void test_ranges_non_projected_algorithms() {
 #endif // _HAS_CXX23
 }
 #endif // _HAS_CXX20
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/GH_002030_asan_annotate_string/test.cpp b/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
index 7b5259955af..5d869884177 100644
--- a/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
+++ b/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
@@ -1850,7 +1850,7 @@ void run_tests() {
     test_sstream<Alloc>();
 #if !(defined(__clang__) && defined(_M_IX86)) // TRANSITION, LLVM-54804
     test_exceptions<Alloc>();
-#endif // !(defined(__clang__) && defined(_M_IX86))
+#endif // ^^^ no workaround ^^^
 }
 
 template <class CharType, template <class, class, class> class Alloc>
diff --git a/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp b/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
index d2a5f1e7676..93ac83e275b 100644
--- a/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
+++ b/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
@@ -1019,8 +1019,7 @@ int main() {
     run_allocator_matrix<non_trivial_can_throw>();
     run_allocator_matrix<non_trivial_cannot_throw>();
 
-// TRANSITION, LLVM-35365
-#ifndef __clang__
+#ifndef __clang__ // TRANSITION, LLVM-35365
     test_push_back_throw();
     test_emplace_back_throw();
     test_insert_range_throw();
@@ -1028,6 +1027,6 @@ int main() {
     test_emplace_throw();
     test_resize_throw();
     test_insert_n_throw();
-#endif // !__clang__
+#endif // ^^^ no workaround ^^^
 #endif // ASan instrumentation enabled
 }
diff --git a/tests/std/tests/GH_002488_promise_not_default_constructible_types/test.cpp b/tests/std/tests/GH_002488_promise_not_default_constructible_types/test.cpp
index 1aafc7bfa90..51b5f20438e 100644
--- a/tests/std/tests/GH_002488_promise_not_default_constructible_types/test.cpp
+++ b/tests/std/tests/GH_002488_promise_not_default_constructible_types/test.cpp
@@ -156,7 +156,7 @@ void run_tests() {
         assert(failures == 7);
         assert(succeeded != -1 && f.get().x == succeeded);
     }
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
     {
         (void) std::async(std::launch::async, [] { return T(16); });
diff --git a/tests/std/tests/GH_002620_construct_at_workaround/test.cpp b/tests/std/tests/GH_002620_construct_at_workaround/test.cpp
index 2b90c2d13ba..8ccab2f5193 100644
--- a/tests/std/tests/GH_002620_construct_at_workaround/test.cpp
+++ b/tests/std/tests/GH_002620_construct_at_workaround/test.cpp
@@ -29,5 +29,5 @@ int main() {
     // GH-2620: <xutility>: SFINAE constraint on construct_at prevents emplacing immovable objects with copy elision
 #ifndef __EDG__ // TRANSITION, DevCom-10000388
     construct_at(&u.s, copy_elider{});
-#endif // TRANSITION, DevCom-10000388
+#endif // ^^^ no workaround ^^^
 }
diff --git a/tests/std/tests/GH_003022_substr_allocator/test.cpp b/tests/std/tests/GH_003022_substr_allocator/test.cpp
index d6d26b36370..3ea2b0b0cbb 100644
--- a/tests/std/tests/GH_003022_substr_allocator/test.cpp
+++ b/tests/std/tests/GH_003022_substr_allocator/test.cpp
@@ -174,11 +174,13 @@ CONSTEXPR20 bool test_substr_allocator() {
         }
     };
 
-#if _HAS_CXX23 && !defined(__EDG__) // TRANSITION, VSO-1601179
+#if _HAS_CXX23
+#ifndef __EDG__ // TRANSITION, VSO-1601179
     static_assert(!is_constructible_v<string_type, ambiguator&, size_t, size_t>, "This should be ambiguous");
-#else // _HAS_CXX23 && !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
     static_assert(is_constructible_v<string_type, ambiguator&, size_t, size_t>, "This should be unambiguous");
-#endif // _HAS_CXX23 && !defined(__EDG__)
+#endif // ^^^ !_HAS_CXX23 ^^^
 
     return true;
 }
diff --git a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
index 7966582bcda..e2efe8de0b6 100644
--- a/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
+++ b/tests/std/tests/P0009R18_mdspan_default_accessor/test.cpp
@@ -71,6 +71,6 @@ constexpr bool test() {
 int main() {
 #if !(defined(_DEBUG) && defined(__EDG__)) // TRANSITION, VSO-1898962
     static_assert(test());
-#endif // !(defined(_DEBUG) && defined(__EDG__))
+#endif // ^^^ no workaround ^^^
     test();
 }
diff --git a/tests/std/tests/P0019R8_atomic_ref/test.cpp b/tests/std/tests/P0019R8_atomic_ref/test.cpp
index a5aee42c08d..c5ecce949ed 100644
--- a/tests/std/tests/P0019R8_atomic_ref/test.cpp
+++ b/tests/std/tests/P0019R8_atomic_ref/test.cpp
@@ -371,7 +371,7 @@ void test_incomplete_associated_class_all() { // COMPILE-ONLY
     test_incomplete_associated_class<tagged_trivial<uint32_t[3], holder<incomplete>>*>();
     test_incomplete_associated_class<tagged_trivial<uint64_t[3], holder<incomplete>>*>();
 }
-#endif // !defined(_M_CEE)
+#endif // ^^^ no workaround ^^^
 
 int main() {
     test_ops<false, char>();
diff --git a/tests/std/tests/P0083R3_splicing_maps_and_sets/test.cpp b/tests/std/tests/P0083R3_splicing_maps_and_sets/test.cpp
index e43e22a6538..5d1c50b6056 100644
--- a/tests/std/tests/P0083R3_splicing_maps_and_sets/test.cpp
+++ b/tests/std/tests/P0083R3_splicing_maps_and_sets/test.cpp
@@ -158,7 +158,7 @@ void test_node_handle(NodeHandle& nh1, NodeHandle& nh2, Validator1 v1, Validator
 #pragma warning(suppress : 4640) // C4640 emitted by MSVC because 'NodeHandle' type has non-trivial dtor
     { static constinit NodeHandle static_handle{}; }
 #endif // ^^^ _HAS_CXX20 ^^^
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
     // No copies!
     static_assert(!std::is_copy_constructible_v<NodeHandle>);
diff --git a/tests/std/tests/P0323R12_expected/test.cpp b/tests/std/tests/P0323R12_expected/test.cpp
index 46a9c6e4273..381e49bfa1c 100644
--- a/tests/std/tests/P0323R12_expected/test.cpp
+++ b/tests/std/tests/P0323R12_expected/test.cpp
@@ -226,7 +226,7 @@ namespace test_expected {
             assert(defaulted);
             assert(defaulted.value() == 42);
         }
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
     }
 
     template <IsTriviallyCopyConstructible triviallyCopyConstructible,
@@ -303,7 +303,7 @@ namespace test_expected {
             assert(from_error.error() == (should_be_trivial ? 0 : 42));
             static_assert(noexcept(Expected{with_error}) == should_be_noexcept);
         }
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
         { // ensure we are not copy constructible if either the payload or the error are not
             struct not_copy_constructible {
@@ -391,7 +391,7 @@ namespace test_expected {
             assert(from_error.error() == (should_be_trivial ? 0 : 42));
             static_assert(noexcept(Expected{move(error_input)}) == should_be_noexcept);
         }
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
         { // ensure we are not move constructible if either the payload or the error are not
             struct not_move_constructible {
diff --git a/tests/std/tests/P0325R4_to_array/test.cpp b/tests/std/tests/P0325R4_to_array/test.cpp
index adf4c3ae531..79c0a02f6d9 100644
--- a/tests/std/tests/P0325R4_to_array/test.cpp
+++ b/tests/std/tests/P0325R4_to_array/test.cpp
@@ -66,7 +66,7 @@ void test_adl_proof() { // COMPILE-ONLY
     (void) std::to_array(a); // intentionally qualified to avoid ADL
     (void) std::to_array(std::move(a)); // intentionally qualified to avoid ADL
 }
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 int main() {
     assert(assert_constexpr());
diff --git a/tests/std/tests/P0339R6_polymorphic_allocator/test.cpp b/tests/std/tests/P0339R6_polymorphic_allocator/test.cpp
index 0245ba354bd..4d62371bc4c 100644
--- a/tests/std/tests/P0339R6_polymorphic_allocator/test.cpp
+++ b/tests/std/tests/P0339R6_polymorphic_allocator/test.cpp
@@ -77,7 +77,7 @@ void allocate_object_overflow_test() {
     } catch (...) {
         assert(false);
     }
-#endif // TRANSITION, VSO-1854243
+#endif // ^^^ no workaround ^^^
 
     try {
         [[maybe_unused]] int* vp = alloc.allocate_object<int>(threshold + 1);
diff --git a/tests/std/tests/P0415R1_constexpr_complex/test.cpp b/tests/std/tests/P0415R1_constexpr_complex/test.cpp
index b750a2ea5ad..5ba0fb1fa99 100644
--- a/tests/std/tests/P0415R1_constexpr_complex/test.cpp
+++ b/tests/std/tests/P0415R1_constexpr_complex/test.cpp
@@ -63,7 +63,7 @@ constexpr void test_type() {
     c /= complex<F>{f1, f3};
 #ifndef _M_CEE // TRANSITION, VSO-1665481
     assert(c == complex<F>{f1});
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
     {
         using Other = conditional_t<is_same_v<F, float>, double, float>;
@@ -83,7 +83,7 @@ constexpr void test_type() {
         c /= complex<Other>{Other{1}, Other{3}};
 #ifndef _M_CEE // TRANSITION, VSO-1665481
         assert(c == complex<F>{f1});
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
     }
 
     assert((complex<F>{f1, f1} + complex<F>{f1, f2} == complex<F>{f2, f3}));
diff --git a/tests/std/tests/P0466R5_layout_compatibility_and_pointer_interconvertibility_traits/test.cpp b/tests/std/tests/P0466R5_layout_compatibility_and_pointer_interconvertibility_traits/test.cpp
index 14d6bafb99b..55333fccfcd 100644
--- a/tests/std/tests/P0466R5_layout_compatibility_and_pointer_interconvertibility_traits/test.cpp
+++ b/tests/std/tests/P0466R5_layout_compatibility_and_pointer_interconvertibility_traits/test.cpp
@@ -14,7 +14,7 @@ struct S { // Must be declared at namespace scope due to static data member
 };
 
 constexpr bool test() {
-#ifndef __clang__ // TRANSITION, LLVM-48860
+#if defined(__cpp_lib_is_layout_compatible) && defined(__cpp_lib_is_pointer_interconvertible) // TRANSITION, LLVM-48860
     // is_layout_compatible tests
     {
         struct S0 {
@@ -201,7 +201,7 @@ constexpr bool test() {
         ASSERT(!is_corresponding_member(&S5::v3, &S6::v3));
 #ifndef _M_CEE // TRANSITION, VSO-1664293
         ASSERT(!is_corresponding_member<NS, NS>(&NS::v1, &NS::w1));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         ASSERT(!is_corresponding_member(&S7::f1, &S7::f1));
         ASSERT(!is_corresponding_member(static_cast<int S1::*>(nullptr), static_cast<int S2::*>(nullptr)));
         ASSERT(!is_corresponding_member(&S1::v1, static_cast<int S2::*>(nullptr)));
@@ -238,11 +238,11 @@ constexpr bool test() {
         ASSERT(!is_pointer_interconvertible_with_class<NS>(&NS::a));
 #ifndef _M_CEE // TRANSITION, VSO-1664293
         ASSERT(!is_pointer_interconvertible_with_class<NS>(&NS::b));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         ASSERT(!is_pointer_interconvertible_with_class(&C::f1));
         ASSERT(!is_pointer_interconvertible_with_class(static_cast<int A::*>(nullptr)));
     }
-#endif // __clang__
+#endif // ^^^ defined(__cpp_lib_is_layout_compatible) && defined(__cpp_lib_is_pointer_interconvertible) ^^^
     return true;
 }
 
diff --git a/tests/std/tests/P0476R2_bit_cast/test.cpp b/tests/std/tests/P0476R2_bit_cast/test.cpp
index 1abee26ce00..637181fe7d4 100644
--- a/tests/std/tests/P0476R2_bit_cast/test.cpp
+++ b/tests/std/tests/P0476R2_bit_cast/test.cpp
@@ -225,7 +225,7 @@ constexpr bool test_float() {
     as_int     = 0x7fc00001;
     float snan = std::bit_cast<float>(as_int);
     assert(as_int == std::bit_cast<unsigned int>(snan));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
     as_int = std::bit_cast<unsigned int>(std::numeric_limits<float>::infinity());
     assert(as_int == 0x7f800000);
diff --git a/tests/std/tests/P0528R3_cmpxchg_pad/test.cpp b/tests/std/tests/P0528R3_cmpxchg_pad/test.cpp
index 5c17d82d1eb..6a186046d1e 100644
--- a/tests/std/tests/P0528R3_cmpxchg_pad/test.cpp
+++ b/tests/std/tests/P0528R3_cmpxchg_pad/test.cpp
@@ -321,6 +321,6 @@ int main() {
     test<X9, 9>();
     test<X16, 16>();
     test<X20, 20>();
-#endif // !__clang__, TRANSITION, LLVM-46685
+#endif // ^^^ no workaround ^^^
     return 0;
 }
diff --git a/tests/std/tests/P0718R2_atomic_smart_ptrs/test.cpp b/tests/std/tests/P0718R2_atomic_smart_ptrs/test.cpp
index b1fc41d8d46..bcd062b31e7 100644
--- a/tests/std/tests/P0718R2_atomic_smart_ptrs/test.cpp
+++ b/tests/std/tests/P0718R2_atomic_smart_ptrs/test.cpp
@@ -586,7 +586,7 @@ void ensure_member_calls_compile() {
 // LWG-3661: constinit atomic<shared_ptr<T>> a(nullptr); should work
 constinit atomic<shared_ptr<bool>> a{};
 constinit atomic<shared_ptr<bool>> b{nullptr};
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 int main() {
     // These values for is_always_lock_free are not required by the standard, but they are true for our implementation.
diff --git a/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp b/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
index 06dfe28844d..ac615057e00 100644
--- a/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
+++ b/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
@@ -79,7 +79,7 @@ STATIC_ASSERT(!is_nothrow_convertible_v<int(int, long) const, int(int, long) con
 STATIC_ASSERT(is_nothrow_convertible_v<int (Cat::*)(int, int (*)(int, long)), int (Cat::*)(int, int (*)(int, long))>);
 #ifndef __EDG__ // TRANSITION, VSO-892694
 STATIC_ASSERT(!is_nothrow_convertible_v<Cat, Cat&>);
-#endif
+#endif // ^^^ no workaround ^^^
 STATIC_ASSERT(is_nothrow_convertible_v<Cat&, Cat>);
 STATIC_ASSERT(is_nothrow_convertible_v<Cat, const Cat&>);
 STATIC_ASSERT(is_nothrow_convertible_v<Cat, const Cat>);
@@ -100,7 +100,7 @@ STATIC_ASSERT(is_nothrow_convertible_v<bool, int>);
 STATIC_ASSERT(is_nothrow_convertible_v<int, long long>);
 #ifndef __EDG__ // TRANSITION, VSO-892705
 STATIC_ASSERT(is_nothrow_convertible_v<int[], int*>);
-#endif
+#endif // ^^^ no workaround ^^^
 STATIC_ASSERT(is_nothrow_convertible_v<int[1], int*>);
 STATIC_ASSERT(!is_nothrow_convertible_v<int[], int[]>);
 STATIC_ASSERT(!is_nothrow_convertible_v<int[], int[1]>);
@@ -130,7 +130,7 @@ struct incomplete;
 
 STATIC_ASSERT(is_nothrow_convertible<holder<incomplete>*, holder<incomplete>*>::value);
 STATIC_ASSERT(is_nothrow_convertible_v<holder<incomplete>*, holder<incomplete>*>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 // VSO_0105317_expression_sfinae and VSO_0000000_type_traits provide
 // additional coverage of this machinery
diff --git a/tests/std/tests/P0768R1_spaceship_cpos/test.cpp b/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
index 5181f6ca63c..b21ccd0efa6 100644
--- a/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
+++ b/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
@@ -505,7 +505,7 @@ constexpr void test_floating() {
             {10, bit_cast<float>(0xFFFFFFFFu)}, // negative quiet NaN, all payload bits set
             {10, bit_cast<float>(0xFFC01234u)}, // negative quiet NaN, some payload bits set
             {10, bit_cast<float>(0xFFC00000u)}, // negative quiet NaN, no payload bits set
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 #ifdef __clang__ // TRANSITION, MSVC "quiets" signaling NaNs into quiet NaNs when constant evaluated
             {10, bit_cast<float>(0xFFBFFFFFu)}, // negative signaling NaN, all payload bits set
             {10, bit_cast<float>(0xFF801234u)}, // negative signaling NaN, some payload bits set
@@ -532,7 +532,7 @@ constexpr void test_floating() {
             {90, bit_cast<float>(0x7FC00000u)}, // quiet NaN, no payload bits set
             {90, bit_cast<float>(0x7FC01234u)}, // quiet NaN, some payload bits set
             {90, bit_cast<float>(0x7FFFFFFFu)}, // quiet NaN, all payload bits set
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         };
 
         test_ranked_values(rank_value_pairs);
diff --git a/tests/std/tests/P0811R3_midpoint_lerp/test.cpp b/tests/std/tests/P0811R3_midpoint_lerp/test.cpp
index 4ad620c3719..130a41576fd 100644
--- a/tests/std/tests/P0811R3_midpoint_lerp/test.cpp
+++ b/tests/std/tests/P0811R3_midpoint_lerp/test.cpp
@@ -520,7 +520,7 @@ void test_midpoint_floating() {
         assert_bitwise_equal(mint_nan<Ty>(0, 1), midpoint(mint_nan<Ty>(0, 1), limits<Ty>::max()));
         assert_bitwise_equal(mint_nan<Ty>(0, 1), midpoint(limits<Ty>::max(), mint_nan<Ty>(0, 1)));
         assert_bitwise_equal(mint_nan<Ty>(0, 1), midpoint(mint_nan<Ty>(0, 1), mint_nan<Ty>(0, 1)));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
         assert(isnan(midpoint(limits<Ty>::quiet_NaN(), Ty(2.0))));
         assert(isnan(midpoint(Ty(2.0), limits<Ty>::quiet_NaN())));
diff --git a/tests/std/tests/P0896R4_P1614R2_comparisons/test.cpp b/tests/std/tests/P0896R4_P1614R2_comparisons/test.cpp
index 974da08fa27..f44a8d332a8 100644
--- a/tests/std/tests/P0896R4_P1614R2_comparisons/test.cpp
+++ b/tests/std/tests/P0896R4_P1614R2_comparisons/test.cpp
@@ -256,7 +256,7 @@ STATIC_ASSERT(test_compare_three_way<float, double, partial_ordering>());
 STATIC_ASSERT(test_compare_three_way<long, double, partial_ordering>());
 #ifndef __EDG__ // TRANSITION, VSO-1898915
 STATIC_ASSERT(test_compare_three_way<bool, int, void>());
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
 STATIC_ASSERT(test_compare_three_way<some_enum, some_enum, strong_ordering>());
 STATIC_ASSERT(test_compare_three_way<some_enum, int, void>());
@@ -426,7 +426,7 @@ constexpr void ordering_test_cases() {
     test_strongly_ordered(&some_deriveds[0], &some_deriveds[1]);
 #if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1168721
     if (!std::is_constant_evaluated())
-#endif // TRANSITION, VSO-1168721
+#endif // ^^^ workaround ^^^
     {
         test_strongly_ordered(static_cast<base const*>(&some_deriveds[0]), &some_deriveds[1]);
         test_strongly_ordered(&some_deriveds[0], static_cast<base const*>(&some_deriveds[1]));
@@ -448,7 +448,7 @@ constexpr void ordering_test_cases() {
     test_partially_ordered(31.625f, 31.625, partial_ordering::equivalent);
 #if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1062601
     if (!std::is_constant_evaluated())
-#endif // TRANSITION, VSO-1062601
+#endif // ^^^ workaround ^^^
     {
         test_partially_ordered(3.14, NaN, partial_ordering::unordered);
         test_partially_ordered(3.14f, NaN, partial_ordering::unordered);
diff --git a/tests/std/tests/P0896R4_counted_iterator_death/test.cpp b/tests/std/tests/P0896R4_counted_iterator_death/test.cpp
index c8846a01b8c..dce76063cb5 100644
--- a/tests/std/tests/P0896R4_counted_iterator_death/test.cpp
+++ b/tests/std/tests/P0896R4_counted_iterator_death/test.cpp
@@ -243,7 +243,7 @@ int main(int argc, char* argv[]) {
         test_case_operator_spaceship_incompatible_different_data,
         test_case_operator_spaceship_incompatible_different_size,
         test_case_operator_spaceship_incompatible_value_initialized,
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
     });
 #endif // _ITERATOR_DEBUG_LEVEL != 0
 
diff --git a/tests/std/tests/P0896R4_ranges_alg_equal/test.cpp b/tests/std/tests/P0896R4_ranges_alg_equal/test.cpp
index b986c2be9a0..99fb4193c14 100644
--- a/tests/std/tests/P0896R4_ranges_alg_equal/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_alg_equal/test.cpp
@@ -123,4 +123,4 @@ struct instantiator {
 
 #if !defined(_PREFAST_) && !defined(__EDG__) // TRANSITION, GH-1030 and GH-3567
 template void test_in_in<instantiator, const int, const int>();
-#endif // TRANSITION, GH-1030 and GH-3567
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/P0896R4_ranges_alg_mismatch/test.cpp b/tests/std/tests/P0896R4_ranges_alg_mismatch/test.cpp
index b064eaee236..d4b58f6fd7b 100644
--- a/tests/std/tests/P0896R4_ranges_alg_mismatch/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_alg_mismatch/test.cpp
@@ -108,4 +108,4 @@ struct instantiator {
 };
 
 template void test_in_in<instantiator, const int, const int>();
-#endif // TRANSITION, GH-1030 and GH-3567
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
index 01e59381daa..fdef67d884c 100644
--- a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
+++ b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
@@ -825,7 +825,7 @@ namespace mergeable_test {
             using Bad_I1 = readable_archetype<int, readable_status::not_input_iter>;
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!input_iterator<Bad_I1>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
             STATIC_ASSERT(input_iterator<I2>);
             STATIC_ASSERT(weakly_incrementable<O>);
             STATIC_ASSERT(indirectly_copyable<Bad_I1, O>);
@@ -833,7 +833,7 @@ namespace mergeable_test {
             STATIC_ASSERT(indirect_strict_weak_order<Pr, projected<Bad_I1, Pj1>, projected<I2, Pj2>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!mergeable<Bad_I1, I2, O, Pr, Pj1, Pj2>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         }
 
         {
@@ -841,14 +841,14 @@ namespace mergeable_test {
             STATIC_ASSERT(input_iterator<I1>);
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!input_iterator<Bad_I2>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
             STATIC_ASSERT(weakly_incrementable<O>);
             STATIC_ASSERT(indirectly_copyable<I1, O>);
             STATIC_ASSERT(indirectly_copyable<Bad_I2, O>);
             STATIC_ASSERT(indirect_strict_weak_order<Pr, projected<I1, Pj1>, projected<Bad_I2, Pj2>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!mergeable<I1, Bad_I2, O, Pr, Pj1, Pj2>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         }
 
         {
@@ -857,13 +857,13 @@ namespace mergeable_test {
             STATIC_ASSERT(input_iterator<I2>);
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!weakly_incrementable<Bad_O>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
             STATIC_ASSERT(indirectly_copyable<I1, Bad_O>);
             STATIC_ASSERT(indirectly_copyable<I2, Bad_O>);
             STATIC_ASSERT(indirect_strict_weak_order<Pr, projected<I1, Pj1>, projected<I2, Pj2>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665670
             STATIC_ASSERT(!mergeable<I1, I2, Bad_O, Pr, Pj1, Pj2>);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         }
 
         {
diff --git a/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
index 7427def1c3d..73c0948a5ba 100644
--- a/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
@@ -1077,7 +1077,7 @@ namespace iterator_cust_move_test {
     STATIC_ASSERT(same_as<iter_rvalue_reference_t<int(int)>, int (&)(int)>);
 #else // ^^^ no workaround / workaround vvv
     STATIC_ASSERT(same_as<iter_rvalue_reference_t<int(int)>, int (*)(int)>);
-#endif // TRANSITION, VSO-1008447
+#endif // ^^^ workaround ^^^
 
     STATIC_ASSERT(same_as<iter_rvalue_reference_t<int[4]>, int&&>);
     STATIC_ASSERT(ranges::iter_move(some_ints) == 0);
@@ -1090,7 +1090,7 @@ namespace iterator_cust_move_test {
     STATIC_ASSERT(same_as<iter_rvalue_reference_t<int (*)(int)>, int (&)(int)>);
 #else // ^^^ no workaround / workaround vvv
     STATIC_ASSERT(same_as<iter_rvalue_reference_t<int (*)(int)>, int (&&)(int)>);
-#endif // TRANSITION, VSO-1008447
+#endif // ^^^ workaround ^^^
     STATIC_ASSERT(ranges::iter_move (&f)(42) == 43);
     STATIC_ASSERT(noexcept(ranges::iter_move(&f)));
 
@@ -1442,7 +1442,7 @@ namespace iterator_concept_winc_test {
             std::same_as<std::index_sequence<Is...>, std::make_index_sequence<weakly_incrementable_archetype_max>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         STATIC_ASSERT((!weakly_incrementable<weakly_incrementable_archetype<Is>> && ...));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         STATIC_ASSERT(weakly_incrementable<weakly_incrementable_archetype<weakly_incrementable_archetype_max>>);
         return true;
     }
@@ -1483,7 +1483,7 @@ namespace iterator_concept_iterator_test {
         STATIC_ASSERT(std::same_as<std::index_sequence<Is...>, std::make_index_sequence<iterator_archetype_max>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         STATIC_ASSERT((!input_or_output_iterator<iterator_archetype<Is>> && ...));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         STATIC_ASSERT(input_or_output_iterator<iterator_archetype<iterator_archetype_max>>);
         return true;
     }
@@ -1516,7 +1516,7 @@ namespace iterator_concept_sentinel_test {
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         constexpr bool expected = I >= sentinel_archetype_max && J >= iterator_archetype_max;
         STATIC_ASSERT(sentinel_for<sentinel_archetype<I>, iterator_archetype<J>> == expected);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         return true;
     }
 
@@ -1546,7 +1546,7 @@ namespace iterator_concept_sizedsentinel_test {
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         constexpr bool expected = I >= sized_sentinel_archetype_max && J >= iterator_archetype_max;
         STATIC_ASSERT(sized_sentinel_for<sized_sentinel_archetype<I>, iterator_archetype<J>> == expected);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         return true;
     }
 
@@ -1574,7 +1574,7 @@ namespace iterator_concept_input_test {
         STATIC_ASSERT(std::same_as<std::index_sequence<Is...>, std::make_index_sequence<input_iterator_archetype_max>>);
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         STATIC_ASSERT((!input_iterator<input_iterator_archetype<Is>> && ...));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         STATIC_ASSERT(input_iterator<input_iterator_archetype<input_iterator_archetype_max>>);
         return true;
     }
@@ -1602,7 +1602,7 @@ namespace iterator_concept_output_test {
         STATIC_ASSERT((!output_iterator<output_iterator_archetype<Is>, int const> && ...));
         STATIC_ASSERT((!output_iterator<output_iterator_archetype<Is>, int&> && ...));
         STATIC_ASSERT((!output_iterator<output_iterator_archetype<Is>, int const&> && ...));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         STATIC_ASSERT(output_iterator<output_iterator_archetype<output_iterator_archetype_max>, int>);
         STATIC_ASSERT(output_iterator<output_iterator_archetype<output_iterator_archetype_max>, int const>);
         STATIC_ASSERT(output_iterator<output_iterator_archetype<output_iterator_archetype_max>, int&>);
@@ -1800,7 +1800,7 @@ namespace unreachable_sentinel_test {
 
 #ifndef _M_CEE // TRANSITION, VSO-1665674
         STATIC_ASSERT((!Comparable<weakly_incrementable_archetype<Is>> && ...));
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
         STATIC_ASSERT(Comparable<weakly_incrementable_archetype<weakly_incrementable_archetype_max>>);
 
         return true;
@@ -3064,7 +3064,7 @@ namespace iter_ops {
             STATIC_ASSERT(noexcept(distance(const_ints + 1, const_ints)));
             assert(distance(const_ints, const_ints) == 0);
             STATIC_ASSERT(noexcept(distance(const_ints, const_ints)));
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
         }
 
         return true;
diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index 2b7d02ff42e..1df793aa12d 100644
--- a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
@@ -2135,7 +2135,7 @@ namespace adl_proof_test {
     STATIC_ASSERT(CanSize<validating_nonmember_range>);
     STATIC_ASSERT(!CanSize<nonsizable_type>);
 } // namespace adl_proof_test
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 namespace unwrapped_begin_end {
     // Validate the iterator-unwrapping range access CPOs ranges::_Ubegin and ranges::_Uend
diff --git a/tests/std/tests/P0896R4_views_iota/test.cpp b/tests/std/tests/P0896R4_views_iota/test.cpp
index f401c42cdd5..8582547bf67 100644
--- a/tests/std/tests/P0896R4_views_iota/test.cpp
+++ b/tests/std/tests/P0896R4_views_iota/test.cpp
@@ -361,7 +361,7 @@ int main() {
     // Validate other integer types
 #ifndef __clang__ // TRANSITION, LLVM-48173
     static_assert(!CanViewIota<bool, bool>);
-#endif // TRANSITION, LLVM-48173
+#endif // ^^^ no workaround ^^^
     static_assert((test_integral<char>(), true));
     test_integral<char>();
     static_assert((test_integral<wchar_t>(), true));
diff --git a/tests/std/tests/P0896R4_views_join/test.cpp b/tests/std/tests/P0896R4_views_join/test.cpp
index acb3ff830f0..43c2d8f8df9 100644
--- a/tests/std/tests/P0896R4_views_join/test.cpp
+++ b/tests/std/tests/P0896R4_views_join/test.cpp
@@ -710,7 +710,7 @@ int main() {
         static constexpr int join_me[5][2] = {{0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}};
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-934264
         static_assert(test_one(join_me, expected_ints));
-#endif // TRANSITION, VSO-934264
+#endif // ^^^ no workaround ^^^
         test_one(join_me, expected_ints);
     }
     { // ... fwd container
@@ -757,7 +757,7 @@ int main() {
         assert(ranges::equal(views::iota(0u, 5u) | views::transform(ToString) | views::join, expected));
 #if !(defined(_DEBUG) && defined(__EDG__)) // TRANSITION, VSO-1948896, see also GH-1566
         static_assert(ranges::equal(views::iota(0u, 5u) | views::transform(ToString) | views::join, expected));
-#endif // !(defined(_DEBUG) && defined(__EDG__))
+#endif // ^^^ no workaround ^^^
     }
 
     { // P2328 range of prvalue string using lambda
@@ -765,7 +765,7 @@ int main() {
         assert(ranges::equal(views::iota(0u, 5u) | views::transform(ToStringLambda) | views::join, expected));
 #if !(defined(_DEBUG) && defined(__EDG__)) // TRANSITION, VSO-1948896, see also GH-1566
         static_assert(ranges::equal(views::iota(0u, 5u) | views::transform(ToStringLambda) | views::join, expected));
-#endif // !(defined(_DEBUG) && defined(__EDG__))
+#endif // ^^^ no workaround ^^^
     }
 
     { // Immovable type
diff --git a/tests/std/tests/P0896R4_views_split/test.cpp b/tests/std/tests/P0896R4_views_split/test.cpp
index 34f8b58d92a..47ed4e17892 100644
--- a/tests/std/tests/P0896R4_views_split/test.cpp
+++ b/tests/std/tests/P0896R4_views_split/test.cpp
@@ -357,7 +357,7 @@ int main() {
 
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1516290
     STATIC_ASSERT(test_devcom_1559808());
-#endif // TRANSITION, DevCom-1516290
+#endif // ^^^ no workaround ^^^
     test_devcom_1559808();
 
     STATIC_ASSERT(test_LWG_3590());
diff --git a/tests/std/tests/P0896R4_views_take/test.cpp b/tests/std/tests/P0896R4_views_take/test.cpp
index 3b1a845e42a..bf3a3209956 100644
--- a/tests/std/tests/P0896R4_views_take/test.cpp
+++ b/tests/std/tests/P0896R4_views_take/test.cpp
@@ -563,7 +563,7 @@ constexpr void move_only_test() {
 constexpr void output_range_test() {
 #if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1132704
     if (!is_constant_evaluated())
-#endif // TRANSITION, VSO-1132704
+#endif // ^^^ workaround ^^^
     {
         using R = test::range<output_iterator_tag, int, test::Sized::no, test::CanDifference::no, test::Common::no,
             test::CanCompare::no, test::ProxyRef::yes, test::CanView::yes, test::Copyability::move_only>;
diff --git a/tests/std/tests/P0898R3_concepts/test.cpp b/tests/std/tests/P0898R3_concepts/test.cpp
index 0b95510c7da..032953fcb22 100644
--- a/tests/std/tests/P0898R3_concepts/test.cpp
+++ b/tests/std/tests/P0898R3_concepts/test.cpp
@@ -540,7 +540,7 @@ namespace test_convertible_to {
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1627396
     STATIC_ASSERT(convertible_to<int volatile (&)[42], int volatile (&)[42]>);
     STATIC_ASSERT(convertible_to<int volatile (&)[42][13], int volatile (&)[42][13]>);
-#endif // TRANSITION, DevCom-1627396
+#endif // ^^^ no workaround ^^^
     STATIC_ASSERT(convertible_to<int volatile (&&)[42], int volatile (&&)[42]>);
     STATIC_ASSERT(convertible_to<int volatile (&&)[42][13], int volatile (&&)[42][13]>);
 
@@ -723,7 +723,7 @@ namespace test_common_reference_with {
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1627396
     STATIC_ASSERT(test<int volatile (&)[42], int volatile (&)[42]>());
     STATIC_ASSERT(test<int volatile (&)[42][13], int volatile (&)[42][13]>());
-#endif // TRANSITION, DevCom-1627396
+#endif // ^^^ no workaround ^^^
     STATIC_ASSERT(test<int volatile (&&)[42], int volatile (&&)[42]>());
     STATIC_ASSERT(test<int volatile (&&)[42][13], int volatile (&&)[42][13]>());
 } // namespace test_common_reference_with
@@ -1480,7 +1480,7 @@ namespace test_constructible_from {
 #ifndef __clang__ // TRANSITION, LLVM-44688
     STATIC_ASSERT(!test<int const&, ExplicitTo<int>>());
     STATIC_ASSERT(!test<int&&, ExplicitTo<int>>());
-#endif // TRANSITION, LLVM-44688
+#endif // ^^^ no workaround ^^^
     STATIC_ASSERT(!test<int const&, ExplicitTo<double&&>>());
     STATIC_ASSERT(!test<int&&, ExplicitTo<double&&>>());
 
@@ -2049,7 +2049,7 @@ namespace test_swappable_with {
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1627396
     STATIC_ASSERT(test<int volatile (&)[4], int volatile (&)[4]>());
     STATIC_ASSERT(test<int volatile (&)[3][4], int volatile (&)[3][4]>());
-#endif // TRANSITION, DevCom-1627396
+#endif // ^^^ no workaround ^^^
 
     STATIC_ASSERT(test<MovableFriendSwap, MovableFriendSwap>() == is_permissive);
     STATIC_ASSERT(test<MovableFriendSwap&, MovableFriendSwap&>());
@@ -2259,7 +2259,7 @@ namespace test_copy_constructible {
 
     STATIC_ASSERT(!copy_constructible<NotMutableRef>);
     STATIC_ASSERT(!copy_constructible<NotConstRefRef>);
-#endif // TRANSITION, VSO-119526
+#endif // ^^^ no workaround ^^^
 
     struct UserProvidedCopy {
         UserProvidedCopy(UserProvidedCopy const&);
diff --git a/tests/std/tests/P0912R5_coroutine/test.cpp b/tests/std/tests/P0912R5_coroutine/test.cpp
index e86c429c0f6..287e68dcc19 100644
--- a/tests/std/tests/P0912R5_coroutine/test.cpp
+++ b/tests/std/tests/P0912R5_coroutine/test.cpp
@@ -97,7 +97,7 @@ Task triangular_number(const int n) {
 
     co_return n + co_await triangular_number(n - 1);
 }
-#endif // TRANSITION, LLVM-56507
+#endif // ^^^ no workaround ^^^
 
 void test_noop_handle() { // Validate noop_coroutine_handle
     const noop_coroutine_handle noop = noop_coroutine();
@@ -182,7 +182,7 @@ int main() {
     }
 
     assert(g_tasks_destroyed == 11); // triangular_number() called for [0, 10]
-#endif // TRANSITION, LLVM-56507
+#endif // ^^^ no workaround ^^^
 
     {
         // Also test GH-1422: hash<coroutine_handle<>>::operator() must be const
diff --git a/tests/std/tests/P1135R6_atomic_wait/test.cpp b/tests/std/tests/P1135R6_atomic_wait/test.cpp
index e3284bd4ea4..2c62d15e1b2 100644
--- a/tests/std/tests/P1135R6_atomic_wait/test.cpp
+++ b/tests/std/tests/P1135R6_atomic_wait/test.cpp
@@ -54,7 +54,7 @@ void test_incomplete_associated_class_all() { // COMPILE-ONLY
     test_incomplete_associated_class<tagged_trivial<uint32_t[3], holder<incomplete>>*>();
     test_incomplete_associated_class<tagged_trivial<uint64_t[3], holder<incomplete>>*>();
 }
-#endif // !defined(_M_CEE)
+#endif // ^^^ no workaround ^^^
 
 int main() {
     assert(__std_atomic_set_api_level(__std_atomic_api_level::__has_wait_on_address)
diff --git a/tests/std/tests/P1206R7_ranges_to_misc/test.cpp b/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
index 9ddf8f153aa..8e4e7ece696 100644
--- a/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
@@ -210,7 +210,7 @@ int main() {
     test_nested_range();
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1588614
     static_assert(test_nested_range());
-#endif // defined(__clang__) || defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
     test_lwg3733();
     static_assert(test_lwg3733());
diff --git a/tests/std/tests/P1614R2_spaceship/test.cpp b/tests/std/tests/P1614R2_spaceship/test.cpp
index 92d819d8a0f..6b7ba2df1d4 100644
--- a/tests/std/tests/P1614R2_spaceship/test.cpp
+++ b/tests/std/tests/P1614R2_spaceship/test.cpp
@@ -1061,9 +1061,9 @@ void ordering_test_cases() {
         spaceship_test<std::partial_ordering>(double_seconds{1}, float_milliseconds{1000}, ntsc_fields{60});
 
         constexpr double_seconds nan_s{std::numeric_limits<double>::quiet_NaN()};
-#ifdef __clang__ // TRANSITION, DevCom-445462
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-445462
         static_assert(nan_s <=> nan_s == std::partial_ordering::unordered);
-#endif // defined(__clang__)
+#endif // ^^^ no workaround ^^^
         assert(nan_s <=> nan_s == std::partial_ordering::unordered);
     }
     { // chrono::time_point
@@ -1077,9 +1077,9 @@ void ordering_test_cases() {
         spaceship_test<std::partial_ordering>(sys_tp{}, sys_double_s{}, sys_double_s{double_seconds{1}});
 
         constexpr sys_double_s nan_tp{double_seconds{std::numeric_limits<double>::quiet_NaN()}};
-#ifdef __clang__ // TRANSITION, DevCom-445462
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-445462
         static_assert(nan_tp <=> nan_tp == std::partial_ordering::unordered);
-#endif // defined(__clang__)
+#endif // ^^^ no workaround ^^^
         assert(nan_tp <=> nan_tp == std::partial_ordering::unordered);
 
         using steady_tp = std::chrono::steady_clock::time_point;
diff --git a/tests/std/tests/P1659R3_ranges_alg_ends_with/test.cpp b/tests/std/tests/P1659R3_ranges_alg_ends_with/test.cpp
index 155357d7542..fa6c84fcd23 100644
--- a/tests/std/tests/P1659R3_ranges_alg_ends_with/test.cpp
+++ b/tests/std/tests/P1659R3_ranges_alg_ends_with/test.cpp
@@ -116,5 +116,5 @@ struct instantiator {
 int main() {
 #if !defined(_PREFAST_) && !defined(__EDG__) // TRANSITION, GH-1030 and GH-3567
     test_in_in<instantiator, const pair<int, int>, const pair<long, long>>();
-#endif // TRANSITION, GH-1030 and GH-3567
+#endif // ^^^ no workaround ^^^
 }
diff --git a/tests/std/tests/P1659R3_ranges_alg_starts_with/test.cpp b/tests/std/tests/P1659R3_ranges_alg_starts_with/test.cpp
index 9ab28717380..f259144a9fa 100644
--- a/tests/std/tests/P1659R3_ranges_alg_starts_with/test.cpp
+++ b/tests/std/tests/P1659R3_ranges_alg_starts_with/test.cpp
@@ -80,5 +80,5 @@ int main() {
 
 #if !defined(_PREFAST_) && !defined(__EDG__) // TRANSITION, GH-1030 and GH-3567
     test_in_in<instantiator, const pair<int, int>, const pair<long, long>>();
-#endif // TRANSITION, GH-1030 and GH-3567
+#endif // ^^^ no workaround ^^^
 }
diff --git a/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp
index 6f5b4f4d1a1..bbc422c22b6 100644
--- a/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp
+++ b/tests/std/tests/P2165R4_tuple_like_operations/test.compile.pass.cpp
@@ -169,7 +169,7 @@ namespace test_tuple_cat {
     static_assert(!CanTupleCat<int, tuple<int>>);
     static_assert(!CanTupleCat<int, array<int, 1>>);
     static_assert(!CanTupleCat<tuple<>, tuple<int>, int>);
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
     constexpr bool test() {
         // Test tuple_cat with empty tuple-like types
diff --git a/tests/std/tests/P2273R3_constexpr_unique_ptr/test.compile.pass.cpp b/tests/std/tests/P2273R3_constexpr_unique_ptr/test.compile.pass.cpp
index 6ec147cb59a..ee5696d7400 100644
--- a/tests/std/tests/P2273R3_constexpr_unique_ptr/test.compile.pass.cpp
+++ b/tests/std/tests/P2273R3_constexpr_unique_ptr/test.compile.pass.cpp
@@ -23,13 +23,13 @@ constexpr bool test_P2273R3_constexpr_unique_ptr() {
         assert(p1 == p1);
         assert(p1 != p2);
 
-#if defined(__EDG__) || defined(__clang__) // TRANSITION, DevCom-1436243
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1436243
         auto p3 = make_unique<int[]>(10);
         auto p4 = make_unique_for_overwrite<int[]>(4);
         swap(p3, p4);
         assert(p3 == p3);
         assert(p3 != p4);
-#endif // defined(__EDG__) || defined(__clang__)
+#endif // ^^^ no workaround ^^^
 
         auto p5 = unique_ptr<int>{nullptr};
         assert(p5 == nullptr);
@@ -47,7 +47,7 @@ constexpr bool test_P2273R3_constexpr_unique_ptr() {
         assert(nullptr >= p5);
         assert((p5 <=> nullptr) == strong_ordering::equal);
         assert((nullptr <=> p5) == strong_ordering::equal);
-#endif // !__EDG__
+#endif // ^^^ no workaround ^^^
     }
 
     // changes in [unique.ptr.dltr.dflt] and [unique.ptr.dltr.dflt1]
diff --git a/tests/std/tests/P2278R4_views_as_const/test.cpp b/tests/std/tests/P2278R4_views_as_const/test.cpp
index e2a12168627..3b819e2ad4a 100644
--- a/tests/std/tests/P2278R4_views_as_const/test.cpp
+++ b/tests/std/tests/P2278R4_views_as_const/test.cpp
@@ -627,7 +627,7 @@ int main() {
         STATIC_ASSERT(test_one(s, some_ints));
         test_one(s, some_ints);
     }
-#endif // TRANSITION, LLVM-62096 and VSO-1901430
+#endif // ^^^ no workaround ^^^
 
     { // ... move-only
         test_one(move_only_view<input_iterator_tag, test::Common::no>{some_ints}, some_ints);
@@ -644,7 +644,7 @@ int main() {
 #ifndef __EDG__ // TRANSITION, VSO-1900291
         STATIC_ASSERT(test_one(some_ints, some_ints));
         test_one(some_ints, some_ints);
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
         // Test with lvalue, rvalue, and wrapped in ref_view non-views
         auto vec = some_ints | ranges::to<vector>();
@@ -663,7 +663,7 @@ int main() {
         static constexpr int one_int[1] = {333};
         STATIC_ASSERT(test_one(views::single(333), one_int));
         test_one(views::single(333), one_int);
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
     }
 
     { // Validate empty_view
@@ -696,7 +696,7 @@ int main() {
         STATIC_ASSERT(test_one(Span{}, Span{}));
         test_one(Span{}, Span{});
     }
-#endif // TRANSITION, LLVM-62096 and VSO-1901430
+#endif // ^^^ no workaround ^^^
 
     STATIC_ASSERT(instantiation_test());
     instantiation_test();
diff --git a/tests/std/tests/P2322R6_ranges_alg_fold/test.cpp b/tests/std/tests/P2322R6_ranges_alg_fold/test.cpp
index d77a3e3fb10..57b470ed3f7 100644
--- a/tests/std/tests/P2322R6_ranges_alg_fold/test.cpp
+++ b/tests/std/tests/P2322R6_ranges_alg_fold/test.cpp
@@ -285,7 +285,7 @@ int main() {
 
 #if !(defined(_DEBUG) && defined(__EDG__)) // TRANSITION, VSO-1949414, see also GH-1566
     STATIC_ASSERT(instantiator::non_dependent());
-#endif // !(defined(_DEBUG) && defined(__EDG__))
+#endif // ^^^ no workaround ^^^
     instantiator::non_dependent();
 
     STATIC_ASSERT(test_in_value_result());
diff --git a/tests/std/tests/P2374R4_views_cartesian_product/test.cpp b/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
index ba802574ea2..c2fdd90885d 100644
--- a/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
+++ b/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
@@ -863,7 +863,7 @@ struct instantiator {
         typename R::template type<const int> r0{get<0>(some_ranges)};
 #ifndef __EDG__ // TRANSITION, VSO-1900293
         test_one(expected_result_0, r0);
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
         if constexpr (ranges::forward_range<typename R::template type<const int>>) {
             typename R::template type<const int> r1{get<1>(some_ranges)};
@@ -948,7 +948,7 @@ int main() {
         span<int> s{arr};
         test_one(expected_result_0, s);
     }
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
     { // ... move-only
         using test::Common, test::Sized;
@@ -978,7 +978,7 @@ int main() {
 #ifndef __EDG__ // TRANSITION, VSO-1900293
         STATIC_ASSERT(test_one(expected_result_0, r0));
         test_one(expected_result_0, r0);
-#endif // !defined(__EDG__)
+#endif // ^^^ no workaround ^^^
 
         auto r1 = get<1>(some_ranges) | ranges::to<vector>();
         test_one(expected_result_1, r0, r1);
diff --git a/tests/std/tests/P2441R2_views_join_with/test.cpp b/tests/std/tests/P2441R2_views_join_with/test.cpp
index c2fe5a86f4d..9e3acf46cb0 100644
--- a/tests/std/tests/P2441R2_views_join_with/test.cpp
+++ b/tests/std/tests/P2441R2_views_join_with/test.cpp
@@ -376,7 +376,7 @@ struct instantiator {
         }
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-60293 and VSO-1900294
         if constexpr (ranges::forward_range<Outer> || ranges::common_range<Outer>)
-#endif // defined(__clang__) || defined(__EDG__)
+#endif // ^^^ workaround ^^^
         { // Range-of-rvalue delimiter
             Inner inner_ranges[] = {Inner{span{input[0]}}, Inner{span{input[1]}}, Inner{span{input[2]}},
                 Inner{span{input[3]}}, Inner{span{input[4]}}, Inner{span{input[5]}}, Inner{span{input[6]}},
diff --git a/tests/std/tests/P2474R2_views_repeat/test.cpp b/tests/std/tests/P2474R2_views_repeat/test.cpp
index 915abbf209b..ed198b9ab03 100644
--- a/tests/std/tests/P2474R2_views_repeat/test.cpp
+++ b/tests/std/tests/P2474R2_views_repeat/test.cpp
@@ -287,7 +287,7 @@ struct tuple_tester {
 #ifdef __EDG__ // TRANSITION, VSO-1898933
     template <class Arg1, class Arg2>
     constexpr tuple_tester(Arg1&& arg1, Arg2&& arg2) : y(forward<Arg1>(arg1)), z(forward<Arg2>(arg2)) {}
-#endif // defined(__EDG__)
+#endif // ^^^ workaround ^^^
     forward_tester y;
     forward_tester z;
 };
diff --git a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp
index c9ec1c4ae15..6f636646273 100644
--- a/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp
+++ b/tests/std/tests/P2538R1_adl_proof_std_projected/test.compile.pass.cpp
@@ -416,4 +416,4 @@ constexpr bool test_ranges_count() {
     return true;
 }
 static_assert(test_ranges_count());
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/VSO_0000000_instantiate_containers/test.compile.pass.cpp b/tests/std/tests/VSO_0000000_instantiate_containers/test.compile.pass.cpp
index 303c44dace3..88df48590d7 100644
--- a/tests/std/tests/VSO_0000000_instantiate_containers/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0000000_instantiate_containers/test.compile.pass.cpp
@@ -103,7 +103,7 @@ struct incomplete;
 using validating_falsity   = tagged_falsity<holder<incomplete>>;
 using validating_less      = tagged_less<holder<incomplete>>;
 using validating_converter = tagged_converter<holder<incomplete>>;
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 
 template <typename T, typename U>
 void math_operators_test(T lhs, U rhs) {
@@ -177,7 +177,7 @@ void construct_from_iterators_test(T value) {
         validating_converter arr[1]{};
         T another_no_adl(+arr, +arr);
         T another_no_adl2(+arr, +arr, value.get_allocator());
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
     });
 }
 
@@ -194,7 +194,7 @@ void construct_tree_containers_from_iterators_test(T value) {
         T another_no_adl(+arr, +arr);
         T another_no_adl2(+arr, +arr, value.key_comp());
         T another_no_adl3(+arr, +arr, value.key_comp(), value.get_allocator());
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
     });
 }
 
@@ -217,7 +217,7 @@ void construct_hash_containers_from_iterators_test(T value) {
         T another_no_adl4(+arr, +arr, value.bucket_count(), value.hash_function(), value.key_eq());
         T another_no_adl5(
             +arr, +arr, value.bucket_count(), value.hash_function(), value.key_eq(), value.get_allocator());
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
     });
 }
 
@@ -267,7 +267,7 @@ void assign_test(T value) {
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     validating_converter arr[1]{};
     another.assign(+arr, +arr);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 template <typename T>
@@ -277,7 +277,7 @@ void insert_with_iterator_test(T value) {
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     validating_converter arr[1]{};
     another.insert(+arr, +arr);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 template <typename T>
@@ -286,12 +286,12 @@ void erase_if_test(T value) {
     std::experimental::fundamentals_v2::erase_if(value, pr1);
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     std::experimental::fundamentals_v2::erase_if(value, validating_falsity{});
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 #if _HAS_CXX20
     std::erase_if(value, pr1);
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     std::erase_if(value, validating_falsity{});
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 #endif // _HAS_CXX20
 }
 
@@ -310,7 +310,7 @@ void insert_with_iterator_specific_location_test(T value) {
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     validating_converter arr[1]{};
     another.insert(cbegin(another), +arr, +arr);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 template <typename T>
@@ -337,7 +337,7 @@ void list_operation_test(T value) {
     value.merge(another, validating_less{});
     value.merge(move(another), validating_less{});
     value.sort(validating_less{});
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 template <typename T>
@@ -460,7 +460,7 @@ void forward_list_test() {
 #ifndef _M_CEE // TRANSITION, VSO-1659496
     validating_converter arr[1]{};
     another.insert_after(cbegin(another), +arr, +arr);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 // Note about hash*_test:
@@ -690,7 +690,7 @@ void string_test_impl(const CharType* data) {
     validating_converter arr[1]{};
     another.append(+arr, +arr);
     another.replace(cbegin(another), cend(another), +arr, +arr);
-#endif // _M_CEE
+#endif // ^^^ no workaround ^^^
 }
 
 void string_test() {
diff --git a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
index 238419a844d..2524cd51c6c 100644
--- a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
+++ b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
@@ -106,7 +106,7 @@ void test_case_sequence_container() {
     assert(dec.beginCalled);
     assert(dec.endCalled);
 
-#if !defined(__EDG__) && !defined(__clang__)
+#if !defined(__clang__) && !defined(__EDG__)
     StlLikeContainer<Container<char>> stlLike;
     stlLike.assign(elementsArray.begin(), elementsArray.end());
     for (auto&& x : stlLike) {
@@ -114,7 +114,7 @@ void test_case_sequence_container() {
     }
     assert(!stlLike.beginCalled);
     assert(!stlLike.endCalled);
-#endif // !defined(__EDG__) && !defined(__clang__)
+#endif // !defined(__clang__) && !defined(__EDG__)
 }
 
 template <template <class...> class Container>
diff --git a/tests/std/tests/VSO_0971246_legacy_await_headers/test.cpp b/tests/std/tests/VSO_0971246_legacy_await_headers/test.cpp
index db91e58c62f..8bab6fc16a8 100644
--- a/tests/std/tests/VSO_0971246_legacy_await_headers/test.cpp
+++ b/tests/std/tests/VSO_0971246_legacy_await_headers/test.cpp
@@ -98,7 +98,7 @@ future<int> f1() {
     auto& imm = imm1;
 #else // ^^^ workaround / no workaround vvv
     auto& imm = co_await fimm();
-#endif // TRANSITION, VSO-974870
+#endif // ^^^ no workaround ^^^
     if (&imm != &imm1) {
         puts("&imm != &imm1");
         co_return 1984;
diff --git a/tests/std/tests/VSO_1925201_iter_traits/test.compile.pass.cpp b/tests/std/tests/VSO_1925201_iter_traits/test.compile.pass.cpp
index 35d0eeff053..5ba8ef1050f 100644
--- a/tests/std/tests/VSO_1925201_iter_traits/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_1925201_iter_traits/test.compile.pass.cpp
@@ -45,4 +45,4 @@ static_assert(same_as<void, decltype(prev(nil, 42))>);
 #ifndef __clang__ // TRANSITION, LLVM-75404
 static_assert(same_as<void, decltype(shift_left(nil, nil, 42))>);
 static_assert(same_as<void, decltype(shift_right(nil, nil, 42))>);
-#endif // TRANSITION, LLVM-75404
+#endif // ^^^ no workaround ^^^