From 9d7c420ad1f32ec60ed076799618cf809aa5781e Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne.2@gmail.com>
Date: Wed, 1 Sep 2021 21:48:24 -0400
Subject: [PATCH] [libc++][NFC] Replace uses of stdr:: by just std::ranges::

Differential Revision: https://reviews.llvm.org/D109121
---
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 33 +++++------
 ...range_concept_conformance.compile.pass.cpp | 38 ++++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 58 +++++++++----------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 .../helper_aliases.compile.pass.cpp           | 10 ++--
 .../range.range/iterator_t.compile.pass.cpp   | 14 ++---
 .../range.range/range.compile.pass.cpp        | 12 ++--
 .../range.range/sentinel_t.compile.pass.cpp   | 14 ++---
 .../bidirectional_range.compile.pass.cpp      | 18 +++---
 .../common_range.compile.pass.cpp             | 30 +++++-----
 .../forward_range.compile.pass.cpp            | 18 +++---
 .../input_range.compile.pass.cpp              | 34 +++++------
 .../range.sized/sized_range.compile.pass.cpp  | 42 +++++++-------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 ...range_concept_conformance.compile.pass.cpp | 34 +++++------
 29 files changed, 449 insertions(+), 450 deletions(-)

diff --git a/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp
index e399e1c5bf87..d48ce88a15a7 100644
--- a/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::map<int, int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(!stdr::random_access_range<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(!stdr::random_access_range<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(!std::ranges::random_access_range<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(!std::ranges::random_access_range<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp
index 31f4840d17f2..0c008e71df50 100644
--- a/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::multimap<int, int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(!stdr::random_access_range<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(!stdr::random_access_range<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(!std::ranges::random_access_range<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(!std::ranges::random_access_range<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
index 27896c108760..84c41274a313 100644
--- a/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,21 @@
 #include <ranges>
 
 using range = std::multiset<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(!stdr::random_access_range<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(!std::ranges::random_access_range<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(!stdr::random_access_range<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(!std::ranges::random_access_range<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp
index 32cdfda81640..5853d9c2a1d9 100644
--- a/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp
@@ -18,24 +18,24 @@
 #include <ranges>
 
 using range = std::set<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::bidirectional_range<range>);
-static_assert(!stdr::random_access_range<range>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::input_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::bidirectional_range<range const>);
-static_assert(!stdr::random_access_range<range const>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::input_range<range>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::random_access_range<range>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::input_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::random_access_range<range const>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::input_range<range>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
index 9c3c6a2c0490..8fdd9869f939 100644
--- a/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/array/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::array<int, 10>;
-namespace stdr = std::ranges;
 
-static_assert(!stdr::view<range>);
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::random_access_range<range>);
-static_assert(stdr::contiguous_range<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(!stdr::view<range const>);
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::random_access_range<range const>);
-static_assert(stdr::contiguous_range<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::random_access_range<range>);
+static_assert(std::ranges::contiguous_range<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(!std::ranges::view<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::random_access_range<range const>);
+static_assert(std::ranges::contiguous_range<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
index 70ec37573f50..ce3eea3c30c6 100644
--- a/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::deque<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::random_access_range<range>);
-static_assert(!stdr::contiguous_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::random_access_range<range const>);
-static_assert(!stdr::contiguous_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::random_access_range<range>);
+static_assert(!std::ranges::contiguous_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::random_access_range<range const>);
+static_assert(!std::ranges::contiguous_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
index cd00c60979c1..8c29c2a223bc 100644
--- a/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::forward_list<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::forward_range<range>);
-static_assert(!stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(!stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::forward_range<range const>);
-static_assert(!stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(!stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::forward_range<range>);
+static_assert(!std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(!std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::forward_range<range const>);
+static_assert(!std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(!std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
index 9c0d4c961b0f..7354563fe4f4 100644
--- a/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::list<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(!stdr::random_access_range<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(!stdr::random_access_range<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(!std::ranges::random_access_range<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(!std::ranges::random_access_range<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
index 7b76861224e3..b19c4afbe175 100644
--- a/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::vector<bool>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::random_access_range<range>);
-static_assert(!stdr::contiguous_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::random_access_range<range const>);
-static_assert(!stdr::contiguous_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::random_access_range<range>);
+static_assert(!std::ranges::contiguous_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::random_access_range<range const>);
+static_assert(!std::ranges::contiguous_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
index 7a8525e2db1a..fe0053236ed3 100644
--- a/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::vector<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::random_access_range<range>);
-static_assert(stdr::contiguous_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::random_access_range<range const>);
-static_assert(stdr::contiguous_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::random_access_range<range>);
+static_assert(std::ranges::contiguous_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::random_access_range<range const>);
+static_assert(std::ranges::contiguous_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp
index 26efc4453114..32e834691abf 100644
--- a/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::unordered_map<int, int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::forward_range<range>);
-static_assert(!stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::forward_range<range const>);
-static_assert(!stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::forward_range<range>);
+static_assert(!std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::forward_range<range const>);
+static_assert(!std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp
index 1cfceb86112e..01a1d34808dc 100644
--- a/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::unordered_multimap<int, int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::forward_range<range>);
-static_assert(!stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::forward_range<range const>);
-static_assert(!stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::forward_range<range>);
+static_assert(!std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::forward_range<range const>);
+static_assert(!std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp
index 198003b9d4da..1557c99e31c0 100644
--- a/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::unordered_multiset<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::forward_range<range>);
-static_assert(!stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::forward_range<range const>);
-static_assert(!stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::forward_range<range>);
+static_assert(!std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::forward_range<range const>);
+static_assert(!std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp
index 762c7636db44..b9c96c7c317c 100644
--- a/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::unordered_set<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::forward_range<range>);
-static_assert(!stdr::bidirectional_range<range>);
-static_assert(!stdr::view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(!stdr::borrowed_range<range>);
-static_assert(!stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::const_iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::forward_range<range const>);
-static_assert(!stdr::bidirectional_range<range const>);
-static_assert(!stdr::view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(!stdr::borrowed_range<range const>);
-static_assert(!stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::forward_range<range>);
+static_assert(!std::ranges::bidirectional_range<range>);
+static_assert(!std::ranges::view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(!std::ranges::borrowed_range<range>);
+static_assert(!std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::forward_range<range const>);
+static_assert(!std::ranges::bidirectional_range<range const>);
+static_assert(!std::ranges::view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(!std::ranges::borrowed_range<range const>);
+static_assert(!std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
index b331ba8db231..caad2767bf94 100644
--- a/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/containers/views/range_concept_conformance.compile.pass.cpp
@@ -18,22 +18,22 @@
 #include <ranges>
 
 using range = std::span<int>;
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<range>, range::iterator>);
-static_assert(stdr::common_range<range>);
-static_assert(stdr::random_access_range<range>);
-static_assert(stdr::contiguous_range<range>);
-static_assert(stdr::view<range> && stdr::enable_view<range>);
-static_assert(stdr::sized_range<range>);
-static_assert(stdr::borrowed_range<range>);
-static_assert(stdr::viewable_range<range>);
 
-static_assert(std::same_as<stdr::iterator_t<range const>, range::iterator>);
-static_assert(stdr::common_range<range const>);
-static_assert(stdr::random_access_range<range const>);
-static_assert(stdr::contiguous_range<range const>);
-static_assert(!stdr::view<range const> && !stdr::enable_view<range const>);
-static_assert(stdr::sized_range<range const>);
-static_assert(stdr::borrowed_range<range const>);
-static_assert(stdr::viewable_range<range const>);
+static_assert(std::same_as<std::ranges::iterator_t<range>, range::iterator>);
+static_assert(std::ranges::common_range<range>);
+static_assert(std::ranges::random_access_range<range>);
+static_assert(std::ranges::contiguous_range<range>);
+static_assert(std::ranges::view<range> && std::ranges::enable_view<range>);
+static_assert(std::ranges::sized_range<range>);
+static_assert(std::ranges::borrowed_range<range>);
+static_assert(std::ranges::viewable_range<range>);
+
+static_assert(std::same_as<std::ranges::iterator_t<range const>, range::iterator>);
+static_assert(std::ranges::common_range<range const>);
+static_assert(std::ranges::random_access_range<range const>);
+static_assert(std::ranges::contiguous_range<range const>);
+static_assert(!std::ranges::view<range const> && !std::ranges::enable_view<range const>);
+static_assert(std::ranges::sized_range<range const>);
+static_assert(std::ranges::borrowed_range<range const>);
+static_assert(std::ranges::viewable_range<range const>);
diff --git a/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp
index b932d4919d9a..3218f20c7fb6 100644
--- a/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.pass.cpp
@@ -18,36 +18,36 @@
 #include <concepts>
 #include <ranges>
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
-static_assert(stdr::common_range<fs::directory_iterator>);
-static_assert(stdr::input_range<fs::directory_iterator>);
-static_assert(!stdr::view<fs::directory_iterator>);
-static_assert(!stdr::sized_range<fs::directory_iterator>);
-static_assert(!stdr::borrowed_range<fs::directory_iterator>);
-static_assert(!stdr::viewable_range<fs::directory_iterator>);
 
-static_assert(std::same_as<stdr::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
-static_assert(stdr::common_range<fs::directory_iterator const>);
-static_assert(stdr::input_range<fs::directory_iterator const>);
-static_assert(!stdr::view<fs::directory_iterator const>);
-static_assert(!stdr::sized_range<fs::directory_iterator const>);
-static_assert(!stdr::borrowed_range<fs::directory_iterator const>);
-static_assert(!stdr::viewable_range<fs::directory_iterator const>);
+static_assert(std::same_as<std::ranges::iterator_t<fs::directory_iterator>, fs::directory_iterator>);
+static_assert(std::ranges::common_range<fs::directory_iterator>);
+static_assert(std::ranges::input_range<fs::directory_iterator>);
+static_assert(!std::ranges::view<fs::directory_iterator>);
+static_assert(!std::ranges::sized_range<fs::directory_iterator>);
+static_assert(!std::ranges::borrowed_range<fs::directory_iterator>);
+static_assert(!std::ranges::viewable_range<fs::directory_iterator>);
 
-static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
-static_assert(stdr::common_range<fs::recursive_directory_iterator>);
-static_assert(stdr::input_range<fs::recursive_directory_iterator>);
-static_assert(!stdr::view<fs::recursive_directory_iterator>);
-static_assert(!stdr::sized_range<fs::recursive_directory_iterator>);
-static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator>);
-static_assert(!stdr::viewable_range<fs::recursive_directory_iterator>);
+static_assert(std::same_as<std::ranges::iterator_t<fs::directory_iterator const>, fs::directory_iterator>);
+static_assert(std::ranges::common_range<fs::directory_iterator const>);
+static_assert(std::ranges::input_range<fs::directory_iterator const>);
+static_assert(!std::ranges::view<fs::directory_iterator const>);
+static_assert(!std::ranges::sized_range<fs::directory_iterator const>);
+static_assert(!std::ranges::borrowed_range<fs::directory_iterator const>);
+static_assert(!std::ranges::viewable_range<fs::directory_iterator const>);
 
-static_assert(std::same_as<stdr::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
-static_assert(stdr::common_range<fs::recursive_directory_iterator const>);
-static_assert(stdr::input_range<fs::recursive_directory_iterator const>);
-static_assert(!stdr::view<fs::recursive_directory_iterator const>);
-static_assert(!stdr::sized_range<fs::recursive_directory_iterator const>);
-static_assert(!stdr::borrowed_range<fs::recursive_directory_iterator const>);
-static_assert(!stdr::viewable_range<fs::recursive_directory_iterator const>);
+static_assert(std::same_as<std::ranges::iterator_t<fs::recursive_directory_iterator>, fs::recursive_directory_iterator>);
+static_assert(std::ranges::common_range<fs::recursive_directory_iterator>);
+static_assert(std::ranges::input_range<fs::recursive_directory_iterator>);
+static_assert(!std::ranges::view<fs::recursive_directory_iterator>);
+static_assert(!std::ranges::sized_range<fs::recursive_directory_iterator>);
+static_assert(!std::ranges::borrowed_range<fs::recursive_directory_iterator>);
+static_assert(!std::ranges::viewable_range<fs::recursive_directory_iterator>);
+
+static_assert(std::same_as<std::ranges::iterator_t<fs::recursive_directory_iterator const>, fs::recursive_directory_iterator>);
+static_assert(std::ranges::common_range<fs::recursive_directory_iterator const>);
+static_assert(std::ranges::input_range<fs::recursive_directory_iterator const>);
+static_assert(!std::ranges::view<fs::recursive_directory_iterator const>);
+static_assert(!std::ranges::sized_range<fs::recursive_directory_iterator const>);
+static_assert(!std::ranges::borrowed_range<fs::recursive_directory_iterator const>);
+static_assert(!std::ranges::viewable_range<fs::recursive_directory_iterator const>);
diff --git a/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp
index 63cafc046a7c..77b46ab04a8b 100644
--- a/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp
@@ -17,22 +17,22 @@
 #include <concepts>
 #include <ranges>
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<fs::path>, fs::path::iterator>);
-static_assert(stdr::common_range<fs::path>);
-static_assert(stdr::bidirectional_range<fs::path>);
-static_assert(!stdr::view<fs::path>);
-static_assert(!stdr::random_access_range<fs::path>);
-static_assert(!stdr::sized_range<fs::path>);
-static_assert(!stdr::borrowed_range<fs::path>);
-static_assert(!stdr::viewable_range<fs::path>);
 
-static_assert(std::same_as<stdr::iterator_t<fs::path const>, fs::path::const_iterator>);
-static_assert(stdr::common_range<fs::path const>);
-static_assert(stdr::bidirectional_range<fs::path const>);
-static_assert(!stdr::view<fs::path const>);
-static_assert(!stdr::random_access_range<fs::path const>);
-static_assert(!stdr::sized_range<fs::path const>);
-static_assert(!stdr::borrowed_range<fs::path const>);
-static_assert(!stdr::viewable_range<fs::path const>);
+static_assert(std::same_as<std::ranges::iterator_t<fs::path>, fs::path::iterator>);
+static_assert(std::ranges::common_range<fs::path>);
+static_assert(std::ranges::bidirectional_range<fs::path>);
+static_assert(!std::ranges::view<fs::path>);
+static_assert(!std::ranges::random_access_range<fs::path>);
+static_assert(!std::ranges::sized_range<fs::path>);
+static_assert(!std::ranges::borrowed_range<fs::path>);
+static_assert(!std::ranges::viewable_range<fs::path>);
+
+static_assert(std::same_as<std::ranges::iterator_t<fs::path const>, fs::path::const_iterator>);
+static_assert(std::ranges::common_range<fs::path const>);
+static_assert(std::ranges::bidirectional_range<fs::path const>);
+static_assert(!std::ranges::view<fs::path const>);
+static_assert(!std::ranges::random_access_range<fs::path const>);
+static_assert(!std::ranges::sized_range<fs::path const>);
+static_assert(!std::ranges::borrowed_range<fs::path const>);
+static_assert(!std::ranges::viewable_range<fs::path const>);
diff --git a/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
index bea28f6e350f..e7dad952fe46 100644
--- a/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp
@@ -29,9 +29,9 @@
 #include "test_iterators.h"
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
-static_assert(std::same_as<stdr::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
-static_assert(std::same_as<stdr::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
-static_assert(std::same_as<stdr::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);
+
+static_assert(std::same_as<std::ranges::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
+static_assert(std::same_as<std::ranges::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
+static_assert(std::same_as<std::ranges::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
+static_assert(std::same_as<std::ranges::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);
diff --git a/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
index 9e43bee05edd..d4d3603bf0f0 100644
--- a/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp
@@ -19,14 +19,14 @@
 
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<stdr::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
 
-static_assert(std::same_as<stdr::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
 
-static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<stdr::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
+static_assert(std::same_as<std::ranges::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
 
-static_assert(std::same_as<stdr::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
+
+static_assert(std::same_as<std::ranges::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
diff --git a/libcxx/test/std/ranges/range.req/range.range/range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/range.compile.pass.cpp
index 46b375772ed0..ecc8048a9586 100644
--- a/libcxx/test/std/ranges/range.req/range.range/range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/range.compile.pass.cpp
@@ -19,30 +19,30 @@
 
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(stdr::range<test_range<cpp20_input_iterator> >);
+
+static_assert(std::ranges::range<test_range<cpp20_input_iterator> >);
 
 struct incompatible_iterators {
   int* begin();
   long* end();
 };
-static_assert(!stdr::range<incompatible_iterators>);
+static_assert(!std::ranges::range<incompatible_iterators>);
 
 struct int_begin_int_end {
   int begin();
   int end();
 };
-static_assert(!stdr::range<int_begin_int_end>);
+static_assert(!std::ranges::range<int_begin_int_end>);
 
 struct iterator_begin_int_end {
   int* begin();
   int end();
 };
-static_assert(!stdr::range<iterator_begin_int_end>);
+static_assert(!std::ranges::range<iterator_begin_int_end>);
 
 struct int_begin_iterator_end {
   int begin();
   int* end();
 };
-static_assert(!stdr::range<int_begin_iterator_end>);
+static_assert(!std::ranges::range<int_begin_iterator_end>);
diff --git a/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
index 092dd03a4262..5288ed684407 100644
--- a/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp
@@ -20,11 +20,11 @@
 #include "test_iterators.h"
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<stdr::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<stdr::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+
+static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
+static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
+static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
+static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
+static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
diff --git a/libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp
index da937c28c01a..d0fb9373b917 100644
--- a/libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.refinements/bidirectional_range.compile.pass.cpp
@@ -17,18 +17,18 @@
 
 #include "test_range.h"
 
-namespace stdr = std::ranges;
+
 
 template <template <class...> class I>
 constexpr bool check_bidirectional_range() {
-  constexpr bool result = stdr::bidirectional_range<test_range<I> >;
-  static_assert(stdr::bidirectional_range<test_range<I> const> == result);
-  static_assert(stdr::bidirectional_range<test_non_const_common_range<I> > == result);
-  static_assert(stdr::bidirectional_range<test_non_const_range<I> > == result);
-  static_assert(stdr::bidirectional_range<test_common_range<I> > == result);
-  static_assert(stdr::bidirectional_range<test_common_range<I> const> == result);
-  static_assert(!stdr::bidirectional_range<test_non_const_common_range<I> const>);
-  static_assert(!stdr::bidirectional_range<test_non_const_range<I> const>);
+  constexpr bool result = std::ranges::bidirectional_range<test_range<I> >;
+  static_assert(std::ranges::bidirectional_range<test_range<I> const> == result);
+  static_assert(std::ranges::bidirectional_range<test_non_const_common_range<I> > == result);
+  static_assert(std::ranges::bidirectional_range<test_non_const_range<I> > == result);
+  static_assert(std::ranges::bidirectional_range<test_common_range<I> > == result);
+  static_assert(std::ranges::bidirectional_range<test_common_range<I> const> == result);
+  static_assert(!std::ranges::bidirectional_range<test_non_const_common_range<I> const>);
+  static_assert(!std::ranges::bidirectional_range<test_non_const_range<I> const>);
   return result;
 }
 
diff --git a/libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp
index 693ee8195cc8..dd606be1cd5d 100644
--- a/libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.refinements/common_range.compile.pass.cpp
@@ -18,39 +18,39 @@
 #include "test_iterators.h"
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(!stdr::common_range<test_range<cpp17_input_iterator> >);
-static_assert(!stdr::common_range<test_range<cpp17_input_iterator> const>);
 
-static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> >);
-static_assert(!stdr::common_range<test_non_const_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> >);
+static_assert(!std::ranges::common_range<test_range<cpp17_input_iterator> const>);
 
-static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> >);
-static_assert(stdr::common_range<test_common_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> >);
+static_assert(!std::ranges::common_range<test_non_const_range<cpp17_input_iterator> const>);
 
-static_assert(stdr::common_range<test_non_const_common_range<cpp17_input_iterator> >);
-static_assert(!stdr::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
+static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> >);
+static_assert(std::ranges::common_range<test_common_range<cpp17_input_iterator> const>);
+
+static_assert(std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> >);
+static_assert(!std::ranges::common_range<test_non_const_common_range<cpp17_input_iterator> const>);
 
 struct subtly_not_common {
   int* begin() const;
   int const* end() const;
 };
-static_assert(stdr::range<subtly_not_common> && !stdr::common_range<subtly_not_common>);
-static_assert(stdr::range<subtly_not_common const> && !stdr::common_range<subtly_not_common const>);
+static_assert(std::ranges::range<subtly_not_common> && !std::ranges::common_range<subtly_not_common>);
+static_assert(std::ranges::range<subtly_not_common const> && !std::ranges::common_range<subtly_not_common const>);
 
 struct common_range_non_const_only {
   int* begin() const;
   int* end();
   int const* end() const;
 };
-static_assert(stdr::range<common_range_non_const_only>&& stdr::common_range<common_range_non_const_only>);
-static_assert(stdr::range<common_range_non_const_only const> && !stdr::common_range<common_range_non_const_only const>);
+static_assert(std::ranges::range<common_range_non_const_only>&& std::ranges::common_range<common_range_non_const_only>);
+static_assert(std::ranges::range<common_range_non_const_only const> && !std::ranges::common_range<common_range_non_const_only const>);
 
 struct common_range_const_only {
   int* begin();
   int const* begin() const;
   int const* end() const;
 };
-static_assert(stdr::range<common_range_const_only> && !stdr::common_range<common_range_const_only>);
-static_assert(stdr::range<common_range_const_only const>&& stdr::common_range<common_range_const_only const>);
+static_assert(std::ranges::range<common_range_const_only> && !std::ranges::common_range<common_range_const_only>);
+static_assert(std::ranges::range<common_range_const_only const>&& std::ranges::common_range<common_range_const_only const>);
diff --git a/libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp
index dd6b2a345dd5..9f25e232df6d 100644
--- a/libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.refinements/forward_range.compile.pass.cpp
@@ -18,18 +18,18 @@
 #include "test_iterators.h"
 #include "test_range.h"
 
-namespace stdr = std::ranges;
+
 
 template <template <class...> class I>
 constexpr bool check_forward_range() {
-  constexpr bool result = stdr::forward_range<test_range<I> >;
-  static_assert(stdr::forward_range<test_range<I> const> == result);
-  static_assert(stdr::forward_range<test_non_const_common_range<I> > == result);
-  static_assert(stdr::forward_range<test_non_const_range<I> > == result);
-  static_assert(stdr::forward_range<test_common_range<I> > == result);
-  static_assert(stdr::forward_range<test_common_range<I> const> == result);
-  static_assert(!stdr::forward_range<test_non_const_common_range<I> const>);
-  static_assert(!stdr::forward_range<test_non_const_range<I> const>);
+  constexpr bool result = std::ranges::forward_range<test_range<I> >;
+  static_assert(std::ranges::forward_range<test_range<I> const> == result);
+  static_assert(std::ranges::forward_range<test_non_const_common_range<I> > == result);
+  static_assert(std::ranges::forward_range<test_non_const_range<I> > == result);
+  static_assert(std::ranges::forward_range<test_common_range<I> > == result);
+  static_assert(std::ranges::forward_range<test_common_range<I> const> == result);
+  static_assert(!std::ranges::forward_range<test_non_const_common_range<I> const>);
+  static_assert(!std::ranges::forward_range<test_non_const_range<I> const>);
   return result;
 }
 
diff --git a/libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp
index eefc5617b8b4..1a2b66cb3837 100644
--- a/libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.refinements/input_range.compile.pass.cpp
@@ -18,28 +18,28 @@
 #include "test_iterators.h"
 #include "test_range.h"
 
-namespace stdr = std::ranges;
 
-static_assert(stdr::input_range<test_range<cpp17_input_iterator> >);
-static_assert(stdr::input_range<test_range<cpp17_input_iterator> const>);
 
-static_assert(stdr::input_range<test_range<cpp20_input_iterator> >);
-static_assert(stdr::input_range<test_range<cpp20_input_iterator> const>);
+static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> >);
+static_assert(std::ranges::input_range<test_range<cpp17_input_iterator> const>);
 
-static_assert(stdr::input_range<test_non_const_range<cpp17_input_iterator> >);
-static_assert(stdr::input_range<test_non_const_range<cpp20_input_iterator> >);
+static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> >);
+static_assert(std::ranges::input_range<test_range<cpp20_input_iterator> const>);
 
-static_assert(!stdr::input_range<test_non_const_range<cpp17_input_iterator> const>);
-static_assert(!stdr::input_range<test_non_const_range<cpp20_input_iterator> const>);
+static_assert(std::ranges::input_range<test_non_const_range<cpp17_input_iterator> >);
+static_assert(std::ranges::input_range<test_non_const_range<cpp20_input_iterator> >);
 
-static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> >);
-static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> >);
+static_assert(!std::ranges::input_range<test_non_const_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::input_range<test_non_const_range<cpp20_input_iterator> const>);
 
-static_assert(stdr::input_range<test_common_range<cpp17_input_iterator> const>);
-static_assert(!stdr::input_range<test_common_range<cpp20_input_iterator> const>);
+static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> >);
+static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> >);
 
-static_assert(stdr::input_range<test_non_const_common_range<cpp17_input_iterator> >);
-static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> >);
+static_assert(std::ranges::input_range<test_common_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::input_range<test_common_range<cpp20_input_iterator> const>);
 
-static_assert(!stdr::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
-static_assert(!stdr::input_range<test_non_const_common_range<cpp20_input_iterator> const>);
+static_assert(std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> >);
+static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> >);
+
+static_assert(!std::ranges::input_range<test_non_const_common_range<cpp17_input_iterator> const>);
+static_assert(!std::ranges::input_range<test_non_const_common_range<cpp20_input_iterator> const>);
diff --git a/libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp
index d5a45455c118..b6184f4e56c4 100644
--- a/libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.req/range.sized/sized_range.compile.pass.cpp
@@ -17,63 +17,63 @@
 
 #include "test_iterators.h"
 
-namespace stdr = std::ranges;
 
-static_assert(stdr::sized_range<int[5]>);
-static_assert(stdr::sized_range<int (&)[5]>);
-static_assert(!stdr::sized_range<int (&)[]>);
-static_assert(!stdr::sized_range<int[]>);
+
+static_assert(std::ranges::sized_range<int[5]>);
+static_assert(std::ranges::sized_range<int (&)[5]>);
+static_assert(!std::ranges::sized_range<int (&)[]>);
+static_assert(!std::ranges::sized_range<int[]>);
 
 struct range_has_size {
   bidirectional_iterator<int*> begin();
   bidirectional_iterator<int*> end();
   int size();
 };
-static_assert(stdr::sized_range<range_has_size>);
-static_assert(!stdr::sized_range<range_has_size const>);
+static_assert(std::ranges::sized_range<range_has_size>);
+static_assert(!std::ranges::sized_range<range_has_size const>);
 
 struct range_has_const_size {
   bidirectional_iterator<int*> begin();
   bidirectional_iterator<int*> end();
   int size() const;
 };
-static_assert(stdr::sized_range<range_has_const_size>);
-static_assert(!stdr::sized_range<range_has_const_size const>);
+static_assert(std::ranges::sized_range<range_has_const_size>);
+static_assert(!std::ranges::sized_range<range_has_const_size const>);
 
 struct const_range_has_size {
   bidirectional_iterator<int*> begin() const;
   bidirectional_iterator<int*> end() const;
   int size();
 };
-static_assert(stdr::sized_range<const_range_has_size>);
-static_assert(stdr::range<const_range_has_size const>);
-static_assert(!stdr::sized_range<const_range_has_size const>);
+static_assert(std::ranges::sized_range<const_range_has_size>);
+static_assert(std::ranges::range<const_range_has_size const>);
+static_assert(!std::ranges::sized_range<const_range_has_size const>);
 
 struct const_range_has_const_size {
   bidirectional_iterator<int*> begin() const;
   bidirectional_iterator<int*> end() const;
   int size() const;
 };
-static_assert(stdr::sized_range<const_range_has_const_size>);
-static_assert(stdr::sized_range<const_range_has_const_size const>);
+static_assert(std::ranges::sized_range<const_range_has_const_size>);
+static_assert(std::ranges::sized_range<const_range_has_const_size const>);
 
 struct sized_sentinel_range_has_size {
   int* begin();
   int* end();
 };
-static_assert(stdr::sized_range<sized_sentinel_range_has_size>);
-static_assert(!stdr::sized_range<sized_sentinel_range_has_size const>);
+static_assert(std::ranges::sized_range<sized_sentinel_range_has_size>);
+static_assert(!std::ranges::sized_range<sized_sentinel_range_has_size const>);
 
 struct const_sized_sentinel_range_has_size {
   int* begin() const;
   int* end() const;
 };
-static_assert(stdr::sized_range<const_sized_sentinel_range_has_size>);
-static_assert(stdr::sized_range<const_sized_sentinel_range_has_size const>);
+static_assert(std::ranges::sized_range<const_sized_sentinel_range_has_size>);
+static_assert(std::ranges::sized_range<const_sized_sentinel_range_has_size const>);
 
 struct non_range_has_size {
   int size() const;
 };
-static_assert(requires(non_range_has_size const x) { stdr::size(x); });
-static_assert(!stdr::sized_range<non_range_has_size>);
-static_assert(!stdr::sized_range<non_range_has_size const>);
+static_assert(requires(non_range_has_size const x) { std::ranges::size(x); });
+static_assert(!std::ranges::sized_range<non_range_has_size>);
+static_assert(!std::ranges::sized_range<non_range_has_size const>);
diff --git a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
index ec03d06a54ff..ec1b9b205fd2 100644
--- a/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/re/re.results/range_concept_conformance.compile.pass.cpp
@@ -17,22 +17,22 @@
 #include <concepts>
 #include <ranges>
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<std::cmatch>, std::cmatch::iterator>);
-static_assert(stdr::common_range<std::cmatch>);
-static_assert(stdr::random_access_range<std::cmatch>);
-static_assert(stdr::contiguous_range<std::cmatch>);
-static_assert(!stdr::view<std::cmatch>);
-static_assert(stdr::sized_range<std::cmatch>);
-static_assert(!stdr::borrowed_range<std::cmatch>);
-static_assert(!stdr::viewable_range<std::cmatch>);
 
-static_assert(std::same_as<stdr::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
-static_assert(stdr::common_range<std::cmatch const>);
-static_assert(stdr::random_access_range<std::cmatch const>);
-static_assert(stdr::contiguous_range<std::cmatch const>);
-static_assert(!stdr::view<std::cmatch const>);
-static_assert(stdr::sized_range<std::cmatch const>);
-static_assert(!stdr::borrowed_range<std::cmatch const>);
-static_assert(!stdr::viewable_range<std::cmatch const>);
+static_assert(std::same_as<std::ranges::iterator_t<std::cmatch>, std::cmatch::iterator>);
+static_assert(std::ranges::common_range<std::cmatch>);
+static_assert(std::ranges::random_access_range<std::cmatch>);
+static_assert(std::ranges::contiguous_range<std::cmatch>);
+static_assert(!std::ranges::view<std::cmatch>);
+static_assert(std::ranges::sized_range<std::cmatch>);
+static_assert(!std::ranges::borrowed_range<std::cmatch>);
+static_assert(!std::ranges::viewable_range<std::cmatch>);
+
+static_assert(std::same_as<std::ranges::iterator_t<std::cmatch const>, std::cmatch::const_iterator>);
+static_assert(std::ranges::common_range<std::cmatch const>);
+static_assert(std::ranges::random_access_range<std::cmatch const>);
+static_assert(std::ranges::contiguous_range<std::cmatch const>);
+static_assert(!std::ranges::view<std::cmatch const>);
+static_assert(std::ranges::sized_range<std::cmatch const>);
+static_assert(!std::ranges::borrowed_range<std::cmatch const>);
+static_assert(!std::ranges::viewable_range<std::cmatch const>);
diff --git a/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
index 51be9b3ef6bc..0e34ded705f6 100644
--- a/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/range_concept_conformance.compile.pass.cpp
@@ -17,22 +17,22 @@
 #include <concepts>
 #include <ranges>
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<std::string>, std::string::iterator>);
-static_assert(stdr::common_range<std::string>);
-static_assert(stdr::random_access_range<std::string>);
-static_assert(stdr::contiguous_range<std::string>);
-static_assert(!stdr::view<std::string>);
-static_assert(stdr::sized_range<std::string>);
-static_assert(!stdr::borrowed_range<std::string>);
-static_assert(!stdr::viewable_range<std::string>);
 
-static_assert(std::same_as<stdr::iterator_t<std::string const>, std::string::const_iterator>);
-static_assert(stdr::common_range<std::string const>);
-static_assert(stdr::random_access_range<std::string const>);
-static_assert(stdr::contiguous_range<std::string const>);
-static_assert(!stdr::view<std::string const>);
-static_assert(stdr::sized_range<std::string const>);
-static_assert(!stdr::borrowed_range<std::string const>);
-static_assert(!stdr::viewable_range<std::string const>);
+static_assert(std::same_as<std::ranges::iterator_t<std::string>, std::string::iterator>);
+static_assert(std::ranges::common_range<std::string>);
+static_assert(std::ranges::random_access_range<std::string>);
+static_assert(std::ranges::contiguous_range<std::string>);
+static_assert(!std::ranges::view<std::string>);
+static_assert(std::ranges::sized_range<std::string>);
+static_assert(!std::ranges::borrowed_range<std::string>);
+static_assert(!std::ranges::viewable_range<std::string>);
+
+static_assert(std::same_as<std::ranges::iterator_t<std::string const>, std::string::const_iterator>);
+static_assert(std::ranges::common_range<std::string const>);
+static_assert(std::ranges::random_access_range<std::string const>);
+static_assert(std::ranges::contiguous_range<std::string const>);
+static_assert(!std::ranges::view<std::string const>);
+static_assert(std::ranges::sized_range<std::string const>);
+static_assert(!std::ranges::borrowed_range<std::string const>);
+static_assert(!std::ranges::viewable_range<std::string const>);
diff --git a/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
index 230d1f38831c..7212d9be3bd7 100644
--- a/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
+++ b/libcxx/test/std/strings/string.view/range_concept_conformance.compile.pass.cpp
@@ -17,22 +17,22 @@
 #include <concepts>
 #include <ranges>
 
-namespace stdr = std::ranges;
 
-static_assert(std::same_as<stdr::iterator_t<std::string_view>, std::string_view::iterator>);
-static_assert(stdr::common_range<std::string_view>);
-static_assert(stdr::random_access_range<std::string_view>);
-static_assert(stdr::contiguous_range<std::string_view>);
-static_assert(stdr::view<std::string_view> && stdr::enable_view<std::string_view>);
-static_assert(stdr::sized_range<std::string_view>);
-static_assert(stdr::borrowed_range<std::string_view>);
-static_assert(stdr::viewable_range<std::string_view>);
 
-static_assert(std::same_as<stdr::iterator_t<std::string_view const>, std::string_view::const_iterator>);
-static_assert(stdr::common_range<std::string_view const>);
-static_assert(stdr::random_access_range<std::string_view const>);
-static_assert(stdr::contiguous_range<std::string_view const>);
-static_assert(!stdr::view<std::string_view const> && !stdr::enable_view<std::string_view const>);
-static_assert(stdr::sized_range<std::string_view const>);
-static_assert(stdr::borrowed_range<std::string_view const>);
-static_assert(stdr::viewable_range<std::string_view const>);
+static_assert(std::same_as<std::ranges::iterator_t<std::string_view>, std::string_view::iterator>);
+static_assert(std::ranges::common_range<std::string_view>);
+static_assert(std::ranges::random_access_range<std::string_view>);
+static_assert(std::ranges::contiguous_range<std::string_view>);
+static_assert(std::ranges::view<std::string_view> && std::ranges::enable_view<std::string_view>);
+static_assert(std::ranges::sized_range<std::string_view>);
+static_assert(std::ranges::borrowed_range<std::string_view>);
+static_assert(std::ranges::viewable_range<std::string_view>);
+
+static_assert(std::same_as<std::ranges::iterator_t<std::string_view const>, std::string_view::const_iterator>);
+static_assert(std::ranges::common_range<std::string_view const>);
+static_assert(std::ranges::random_access_range<std::string_view const>);
+static_assert(std::ranges::contiguous_range<std::string_view const>);
+static_assert(!std::ranges::view<std::string_view const> && !std::ranges::enable_view<std::string_view const>);
+static_assert(std::ranges::sized_range<std::string_view const>);
+static_assert(std::ranges::borrowed_range<std::string_view const>);
+static_assert(std::ranges::viewable_range<std::string_view const>);