diff --git a/libcxx/benchmarks/filesystem.bench.cpp b/libcxx/benchmarks/filesystem.bench.cpp
--- a/libcxx/benchmarks/filesystem.bench.cpp
+++ b/libcxx/benchmarks/filesystem.bench.cpp
@@ -62,11 +62,11 @@
 }
 template <class GenInputs>
 void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) {
-  BM_PathConstructIter<input_iterator>(st, gen);
+  BM_PathConstructIter<legacy_input_iterator>(st, gen);
 }
 template <class GenInputs>
 void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) {
-  BM_PathConstructIter<forward_iterator>(st, gen);
+  BM_PathConstructIter<legacy_forward_iterator>(st, gen);
 }
 BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string,
   getRandomStringInputs)->Range(8, TestNumInputs)->Complexity();
diff --git a/libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp b/libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
--- a/libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
+++ b/libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp
@@ -30,8 +30,8 @@
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
         std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10),
-                                        input_iterator<const int*>(a),
-                                       input_iterator<const int*>(a+N));
+                                        legacy_input_iterator<const int*>(a),
+                                       legacy_input_iterator<const int*>(a+N));
         assert(false);
     }
 
diff --git a/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp b/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp
--- a/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp
+++ b/libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp
@@ -42,7 +42,7 @@
 #endif
 
     {
-        typedef input_iterator<int*> MyInputIter;
+        typedef legacy_input_iterator<int*> MyInputIter;
         // Sould not trigger ASan.
         std::vector<int> v;
         v.reserve(1);
diff --git a/libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp b/libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
--- a/libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
+++ b/libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp
@@ -63,8 +63,8 @@
   using const_cstr_type = const CharT*;
   using array_type = CharT[25];
   using const_array_type = const CharT[25];
-  using iter_type = input_iterator<CharT*>;
-  using bad_iter_type = input_iterator<signed char*>;
+  using iter_type = legacy_input_iterator<CharT*>;
+  using bad_iter_type = legacy_input_iterator<signed char*>;
 
   template <class TestT>
   static void AssertPathable() {
diff --git a/libcxx/test/libcxx/iterators/advance.debug1.pass.cpp b/libcxx/test/libcxx/iterators/advance.debug1.pass.cpp
--- a/libcxx/test/libcxx/iterators/advance.debug1.pass.cpp
+++ b/libcxx/test/libcxx/iterators/advance.debug1.pass.cpp
@@ -25,12 +25,12 @@
 {
     int a[] = {1, 2, 3};
 
-    bidirectional_iterator<int *> bidi(a+1);
+    legacy_bidirectional_iterator<int *> bidi(a+1);
 	std::advance(bidi,  1);  // should work fine
 	std::advance(bidi,  0);  // should work fine
     std::advance(bidi, -1);  // should work fine
 
-    forward_iterator<int *> it(a+1);
+    legacy_forward_iterator<int *> it(a+1);
 	std::advance(it, 1);  // should work fine
 	std::advance(it, 0);  // should work fine
     EXPECT_DEATH( std::advance(it, -1) ); // can't go backwards on a FwdIter
diff --git a/libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp b/libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp
--- a/libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp
+++ b/libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp
@@ -192,12 +192,12 @@
 
 //  iterators in the libc++ test suite
     static_assert((!std::__is_cpp17_contiguous_iterator<output_iterator       <char *> >::value), "");
-    static_assert((!std::__is_cpp17_contiguous_iterator<input_iterator        <char *> >::value), "");
-    static_assert((!std::__is_cpp17_contiguous_iterator<forward_iterator      <char *> >::value), "");
-    static_assert((!std::__is_cpp17_contiguous_iterator<bidirectional_iterator<char *> >::value), "");
-    static_assert((!std::__is_cpp17_contiguous_iterator<random_access_iterator<char *> >::value), "");
+    static_assert((!std::__is_cpp17_contiguous_iterator<legacy_input_iterator        <char *> >::value), "");
+    static_assert((!std::__is_cpp17_contiguous_iterator<legacy_forward_iterator      <char *> >::value), "");
+    static_assert((!std::__is_cpp17_contiguous_iterator<legacy_bidirectional_iterator<char *> >::value), "");
+    static_assert((!std::__is_cpp17_contiguous_iterator<legacy_random_access_iterator<char *> >::value), "");
 #if TEST_STD_VER >= 20
-    static_assert(( std::__is_cpp17_contiguous_iterator<contiguous_iterator   <char *> >::value), "");
+    static_assert(( std::__is_cpp17_contiguous_iterator<legacy_contiguous_iterator   <char *> >::value), "");
 #endif
     static_assert((!std::__is_cpp17_contiguous_iterator<ThrowingIterator      <char *> >::value), "");
     static_assert((!std::__is_cpp17_contiguous_iterator<NonThrowingIterator   <char *> >::value), "");
diff --git a/libcxx/test/libcxx/iterators/next.debug1.pass.cpp b/libcxx/test/libcxx/iterators/next.debug1.pass.cpp
--- a/libcxx/test/libcxx/iterators/next.debug1.pass.cpp
+++ b/libcxx/test/libcxx/iterators/next.debug1.pass.cpp
@@ -26,7 +26,7 @@
     int a[] = {1, 2, 3};
 
 
-    forward_iterator<int *> it(a+1);
+    legacy_forward_iterator<int *> it(a+1);
 	std::next(it, 1);  // should work fine
 	std::next(it, 0);  // should work fine
     EXPECT_DEATH( std::next(it, -1) ); // can't go backwards on a FwdIter
diff --git a/libcxx/test/libcxx/iterators/prev.debug1.pass.cpp b/libcxx/test/libcxx/iterators/prev.debug1.pass.cpp
--- a/libcxx/test/libcxx/iterators/prev.debug1.pass.cpp
+++ b/libcxx/test/libcxx/iterators/prev.debug1.pass.cpp
@@ -13,7 +13,7 @@
 
 // <list>
 
-// Call prev(forward_iterator, -1)
+// Call prev(legacy_forward_iterator, -1)
 
 #include <iterator>
 #include "test_macros.h"
@@ -25,12 +25,12 @@
 {
     int a[] = {1, 2, 3};
 
-    bidirectional_iterator<int *> bidi(a+1);
+    legacy_bidirectional_iterator<int *> bidi(a+1);
 	std::prev(bidi, -1);  // should work fine
 	std::prev(bidi,  0);  // should work fine
     std::prev(bidi,  1);  // should work fine
 
-    forward_iterator<int *> it(a+1);
+    legacy_forward_iterator<int *> it(a+1);
     std::prev(it, -1); // should work fine
     std::prev(it,  0); // should work fine
     EXPECT_DEATH( std::prev(it, 1) ); // can't go backwards on a FwdIter
diff --git a/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp b/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp
--- a/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -117,10 +117,10 @@
 
 //  iterators in the libc++ test suite
     static_assert((!std::__libcpp_is_trivial_iterator<output_iterator       <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<input_iterator        <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<forward_iterator      <char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<bidirectional_iterator<char *> >::value), "");
-    static_assert((!std::__libcpp_is_trivial_iterator<random_access_iterator<char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<legacy_input_iterator        <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<legacy_forward_iterator      <char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<legacy_bidirectional_iterator<char *> >::value), "");
+    static_assert((!std::__libcpp_is_trivial_iterator<legacy_random_access_iterator<char *> >::value), "");
     static_assert((!std::__libcpp_is_trivial_iterator<ThrowingIterator      <char *> >::value), "");
     static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");
 
@@ -133,33 +133,33 @@
     static_assert(( std::__is_cpp17_contiguous_iterator   <char *>::value), "" );
     static_assert((!std::__is_exactly_cpp17_input_iterator<char *>::value), "" );
 
-    static_assert(( std::__is_cpp17_input_iterator        <input_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_forward_iterator      <input_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_bidirectional_iterator<input_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_random_access_iterator<input_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_contiguous_iterator   <input_iterator<char *> >::value), "" );
-    static_assert(( std::__is_exactly_cpp17_input_iterator<input_iterator<char *> >::value), "" );
-
-    static_assert(( std::__is_cpp17_input_iterator        <forward_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_forward_iterator      <forward_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_bidirectional_iterator<forward_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_random_access_iterator<forward_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_contiguous_iterator   <forward_iterator<char *> >::value), "" );
-    static_assert((!std::__is_exactly_cpp17_input_iterator<forward_iterator<char *> >::value), "" );
-
-    static_assert(( std::__is_cpp17_input_iterator        <bidirectional_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_forward_iterator      <bidirectional_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_contiguous_iterator   <bidirectional_iterator<char *> >::value), "" );
-    static_assert((!std::__is_exactly_cpp17_input_iterator<bidirectional_iterator<char *> >::value), "" );
-
-    static_assert(( std::__is_cpp17_input_iterator        <random_access_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_forward_iterator      <random_access_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
-    static_assert(( std::__is_cpp17_random_access_iterator<random_access_iterator<char *> >::value), "" );
-    static_assert((!std::__is_cpp17_contiguous_iterator   <random_access_iterator<char *> >::value), "" );
-    static_assert((!std::__is_exactly_cpp17_input_iterator<random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_input_iterator        <legacy_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_forward_iterator      <legacy_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_bidirectional_iterator<legacy_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_random_access_iterator<legacy_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_contiguous_iterator   <legacy_input_iterator<char *> >::value), "" );
+    static_assert(( std::__is_exactly_cpp17_input_iterator<legacy_input_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_cpp17_input_iterator        <legacy_forward_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_forward_iterator      <legacy_forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_bidirectional_iterator<legacy_forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_random_access_iterator<legacy_forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_contiguous_iterator   <legacy_forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_cpp17_input_iterator<legacy_forward_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_cpp17_input_iterator        <legacy_bidirectional_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_forward_iterator      <legacy_bidirectional_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_bidirectional_iterator<legacy_bidirectional_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_random_access_iterator<legacy_bidirectional_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_contiguous_iterator   <legacy_bidirectional_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_cpp17_input_iterator<legacy_bidirectional_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_cpp17_input_iterator        <legacy_random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_forward_iterator      <legacy_random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_bidirectional_iterator<legacy_random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_cpp17_random_access_iterator<legacy_random_access_iterator<char *> >::value), "" );
+    static_assert((!std::__is_cpp17_contiguous_iterator   <legacy_random_access_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_cpp17_input_iterator<legacy_random_access_iterator<char *> >::value), "" );
 
     static_assert(( std::__is_cpp17_input_iterator        <my_input_iterator<char *> >::value), "" );
     static_assert((!std::__is_cpp17_forward_iterator      <my_input_iterator<char *> >::value), "" );
diff --git a/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp b/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp
--- a/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp
+++ b/libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp
@@ -51,10 +51,10 @@
 
 //  iterators in the libc++ test suite
     static_assert(std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value == expected, "");
-    static_assert(std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value == expected, "");
-    static_assert(std::__libcpp_string_gets_noexcept_iterator<forward_iterator      <char *> >::value == expected, "");
-    static_assert(std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value == expected, "");
-    static_assert(std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value == expected, "");
+    static_assert(std::__libcpp_string_gets_noexcept_iterator<legacy_input_iterator        <char *> >::value == expected, "");
+    static_assert(std::__libcpp_string_gets_noexcept_iterator<legacy_forward_iterator      <char *> >::value == expected, "");
+    static_assert(std::__libcpp_string_gets_noexcept_iterator<legacy_bidirectional_iterator<char *> >::value == expected, "");
+    static_assert(std::__libcpp_string_gets_noexcept_iterator<legacy_random_access_iterator<char *> >::value == expected, "");
     static_assert(std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value == expected, "");
 
 #if TEST_STD_VER >= 11
diff --git a/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp b/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp
--- a/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -47,10 +47,10 @@
 
 //  iterators in the libc++ test suite
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<output_iterator       <char *> >::value), "");
-    static_assert(( std::__libcpp_string_gets_noexcept_iterator<input_iterator        <char *> >::value), "");
-    static_assert(( std::__libcpp_string_gets_noexcept_iterator<forward_iterator      <char *> >::value), "");
-    static_assert(( std::__libcpp_string_gets_noexcept_iterator<bidirectional_iterator<char *> >::value), "");
-    static_assert(( std::__libcpp_string_gets_noexcept_iterator<random_access_iterator<char *> >::value), "");
+    static_assert(( std::__libcpp_string_gets_noexcept_iterator<legacy_input_iterator        <char *> >::value), "");
+    static_assert(( std::__libcpp_string_gets_noexcept_iterator<legacy_forward_iterator      <char *> >::value), "");
+    static_assert(( std::__libcpp_string_gets_noexcept_iterator<legacy_bidirectional_iterator<char *> >::value), "");
+    static_assert(( std::__libcpp_string_gets_noexcept_iterator<legacy_random_access_iterator<char *> >::value), "");
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<ThrowingIterator      <char *> >::value), "");
 
     static_assert(( std::__libcpp_string_gets_noexcept_iterator<NonThrowingIterator   <char *> >::value), "");
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp
@@ -39,48 +39,48 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test_copy<input_iterator<const int*>, output_iterator<int*> >();
-    test_copy<input_iterator<const int*>, forward_iterator<int*> >();
-    test_copy<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy<input_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy<input_iterator<const int*>, int*>();
-
-    test_copy<forward_iterator<const int*>, output_iterator<int*> >();
-    test_copy<forward_iterator<const int*>, forward_iterator<int*> >();
-    test_copy<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy<forward_iterator<const int*>, int*>();
-
-    test_copy<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test_copy<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test_copy<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy<bidirectional_iterator<const int*>, int*>();
-
-    test_copy<random_access_iterator<const int*>, output_iterator<int*> >();
-    test_copy<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test_copy<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy<random_access_iterator<const int*>, int*>();
+    test_copy<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test_copy<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy<legacy_input_iterator<const int*>, int*>();
+
+    test_copy<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test_copy<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy<legacy_forward_iterator<const int*>, int*>();
+
+    test_copy<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test_copy<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test_copy<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test_copy<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy<legacy_random_access_iterator<const int*>, int*>();
 
     test_copy<const int*, output_iterator<int*> >();
-    test_copy<const int*, forward_iterator<int*> >();
-    test_copy<const int*, bidirectional_iterator<int*> >();
-    test_copy<const int*, random_access_iterator<int*> >();
+    test_copy<const int*, legacy_forward_iterator<int*> >();
+    test_copy<const int*, legacy_bidirectional_iterator<int*> >();
+    test_copy<const int*, legacy_random_access_iterator<int*> >();
     test_copy<const int*, int*>();
 
 #if TEST_STD_VER > 17
-    test_copy<input_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy<forward_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy<random_access_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy<const int*, contiguous_iterator<int*>>();
-
-    test_copy<contiguous_iterator<const int*>, output_iterator<int*>>();
-    test_copy<contiguous_iterator<const int*>, forward_iterator<int*>>();
-    test_copy<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
-    test_copy<contiguous_iterator<const int*>, random_access_iterator<int*>>();
-    test_copy<contiguous_iterator<const int*>, int*>();
+    test_copy<legacy_input_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy<legacy_forward_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy<const int*, legacy_contiguous_iterator<int*>>();
+
+    test_copy<legacy_contiguous_iterator<const int*>, output_iterator<int*>>();
+    test_copy<legacy_contiguous_iterator<const int*>, legacy_forward_iterator<int*>>();
+    test_copy<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*>>();
+    test_copy<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*>>();
+    test_copy<legacy_contiguous_iterator<const int*>, int*>();
 #endif
 
   return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp
@@ -41,27 +41,27 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test_copy_backward<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_backward<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_backward<bidirectional_iterator<const int*>, int*>();
+    test_copy_backward<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_backward<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_backward<legacy_bidirectional_iterator<const int*>, int*>();
 
-    test_copy_backward<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_backward<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_backward<random_access_iterator<const int*>, int*>();
+    test_copy_backward<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_backward<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_backward<legacy_random_access_iterator<const int*>, int*>();
 
-    test_copy_backward<const int*, bidirectional_iterator<int*> >();
-    test_copy_backward<const int*, random_access_iterator<int*> >();
+    test_copy_backward<const int*, legacy_bidirectional_iterator<int*> >();
+    test_copy_backward<const int*, legacy_random_access_iterator<int*> >();
     test_copy_backward<const int*, int*>();
 
 #if TEST_STD_VER > 17
-    test_copy_backward<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
-    test_copy_backward<contiguous_iterator<const int*>, random_access_iterator<int*>>();
-    test_copy_backward<contiguous_iterator<const int*>, int*>();
-
-    test_copy_backward<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy_backward<random_access_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy_backward<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
-    test_copy_backward<const int*, contiguous_iterator<int*>>();
+    test_copy_backward<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*>>();
+    test_copy_backward<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*>>();
+    test_copy_backward<legacy_contiguous_iterator<const int*>, int*>();
+
+    test_copy_backward<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy_backward<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy_backward<legacy_contiguous_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test_copy_backward<const int*, legacy_contiguous_iterator<int*>>();
 #endif
 
     return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -44,39 +44,39 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test_copy_if<input_iterator<const int*>, output_iterator<int*> >();
-    test_copy_if<input_iterator<const int*>, input_iterator<int*> >();
-    test_copy_if<input_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_if<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_if<input_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_if<input_iterator<const int*>, int*>();
-
-    test_copy_if<forward_iterator<const int*>, output_iterator<int*> >();
-    test_copy_if<forward_iterator<const int*>, input_iterator<int*> >();
-    test_copy_if<forward_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_if<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_if<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_if<forward_iterator<const int*>, int*>();
-
-    test_copy_if<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test_copy_if<bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test_copy_if<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_if<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_if<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_if<bidirectional_iterator<const int*>, int*>();
-
-    test_copy_if<random_access_iterator<const int*>, output_iterator<int*> >();
-    test_copy_if<random_access_iterator<const int*>, input_iterator<int*> >();
-    test_copy_if<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_if<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_if<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_if<random_access_iterator<const int*>, int*>();
+    test_copy_if<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test_copy_if<legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_if<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_if<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_if<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_if<legacy_input_iterator<const int*>, int*>();
+
+    test_copy_if<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test_copy_if<legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_if<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_if<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_if<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_if<legacy_forward_iterator<const int*>, int*>();
+
+    test_copy_if<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test_copy_if<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_if<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_if<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_if<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_if<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test_copy_if<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test_copy_if<legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_if<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_if<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_if<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_if<legacy_random_access_iterator<const int*>, int*>();
 
     test_copy_if<const int*, output_iterator<int*> >();
-    test_copy_if<const int*, input_iterator<int*> >();
-    test_copy_if<const int*, forward_iterator<int*> >();
-    test_copy_if<const int*, bidirectional_iterator<int*> >();
-    test_copy_if<const int*, random_access_iterator<int*> >();
+    test_copy_if<const int*, legacy_input_iterator<int*> >();
+    test_copy_if<const int*, legacy_forward_iterator<int*> >();
+    test_copy_if<const int*, legacy_bidirectional_iterator<int*> >();
+    test_copy_if<const int*, legacy_random_access_iterator<int*> >();
     test_copy_if<const int*, int*>();
 
   return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp
@@ -42,39 +42,39 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test_copy_n<input_iterator<const int*>, output_iterator<int*> >();
-    test_copy_n<input_iterator<const int*>, input_iterator<int*> >();
-    test_copy_n<input_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_n<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_n<input_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_n<input_iterator<const int*>, int*>();
-
-    test_copy_n<forward_iterator<const int*>, output_iterator<int*> >();
-    test_copy_n<forward_iterator<const int*>, input_iterator<int*> >();
-    test_copy_n<forward_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_n<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_n<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_n<forward_iterator<const int*>, int*>();
-
-    test_copy_n<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test_copy_n<bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test_copy_n<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_n<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_n<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_n<bidirectional_iterator<const int*>, int*>();
-
-    test_copy_n<random_access_iterator<const int*>, output_iterator<int*> >();
-    test_copy_n<random_access_iterator<const int*>, input_iterator<int*> >();
-    test_copy_n<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test_copy_n<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test_copy_n<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test_copy_n<random_access_iterator<const int*>, int*>();
+    test_copy_n<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test_copy_n<legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_n<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_n<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_n<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_n<legacy_input_iterator<const int*>, int*>();
+
+    test_copy_n<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test_copy_n<legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_n<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_n<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_n<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_n<legacy_forward_iterator<const int*>, int*>();
+
+    test_copy_n<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test_copy_n<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_n<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_n<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_n<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_n<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test_copy_n<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test_copy_n<legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test_copy_n<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test_copy_n<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test_copy_n<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test_copy_n<legacy_random_access_iterator<const int*>, int*>();
 
     test_copy_n<const int*, output_iterator<int*> >();
-    test_copy_n<const int*, input_iterator<int*> >();
-    test_copy_n<const int*, forward_iterator<int*> >();
-    test_copy_n<const int*, bidirectional_iterator<int*> >();
-    test_copy_n<const int*, random_access_iterator<int*> >();
+    test_copy_n<const int*, legacy_input_iterator<int*> >();
+    test_copy_n<const int*, legacy_forward_iterator<int*> >();
+    test_copy_n<const int*, legacy_bidirectional_iterator<int*> >();
+    test_copy_n<const int*, legacy_random_access_iterator<int*> >();
     test_copy_n<const int*, int*>();
 
   return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
@@ -58,14 +58,14 @@
 
 int main(int, char**)
 {
-    test_char<forward_iterator<char*> >();
-    test_char<bidirectional_iterator<char*> >();
-    test_char<random_access_iterator<char*> >();
+    test_char<legacy_forward_iterator<char*> >();
+    test_char<legacy_bidirectional_iterator<char*> >();
+    test_char<legacy_random_access_iterator<char*> >();
     test_char<char*>();
 
-    test_int<forward_iterator<int*> >();
-    test_int<bidirectional_iterator<int*> >();
-    test_int<random_access_iterator<int*> >();
+    test_int<legacy_forward_iterator<int*> >();
+    test_int<legacy_bidirectional_iterator<int*> >();
+    test_int<legacy_random_access_iterator<int*> >();
     test_int<int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -150,14 +150,14 @@
 
 int main(int, char**)
 {
-    test_char<forward_iterator<char*> >();
-    test_char<bidirectional_iterator<char*> >();
-    test_char<random_access_iterator<char*> >();
+    test_char<legacy_forward_iterator<char*> >();
+    test_char<legacy_bidirectional_iterator<char*> >();
+    test_char<legacy_random_access_iterator<char*> >();
     test_char<char*>();
 
-    test_int<forward_iterator<int*> >();
-    test_int<bidirectional_iterator<int*> >();
-    test_int<random_access_iterator<int*> >();
+    test_int<legacy_forward_iterator<int*> >();
+    test_int<legacy_bidirectional_iterator<int*> >();
+    test_int<legacy_random_access_iterator<int*> >();
     test_int<int*>();
 
     test_int_array();
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
@@ -53,9 +53,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -76,9 +76,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -63,133 +63,133 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER >= 11
-    test1<input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<input_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<input_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<input_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<random_access_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<std::unique_ptr<int>*, output_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
 #if TEST_STD_VER > 17
-    test<input_iterator<const int*>, contiguous_iterator<int*>>();
-    test<forward_iterator<const int*>, contiguous_iterator<int*>>();
-    test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
-    test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
-    test<const int*, contiguous_iterator<int*>>();
-    test<contiguous_iterator<const int*>, output_iterator<int*>>();
-    test<contiguous_iterator<const int*>, forward_iterator<int*>>();
-    test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
-    test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
-    test<contiguous_iterator<const int*>, int*>();
-    test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
-
-    test1<input_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<forward_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-
-    static_assert(test<input_iterator<const int*>, input_iterator<int*> >());
-    static_assert(test<input_iterator<const int*>, forward_iterator<int*> >());
-    static_assert(test<input_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<input_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<input_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<input_iterator<const int*>, int*>());
-
-    static_assert(test<forward_iterator<const int*>, input_iterator<int*> >());
-    static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
-    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<forward_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<forward_iterator<const int*>, int*>());
-
-    static_assert(test<bidirectional_iterator<const int*>, input_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, int*>());
-
-    static_assert(test<random_access_iterator<const int*>, input_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, int*>());
-
-    static_assert(test<contiguous_iterator<const int*>, input_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, forward_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, int*>());
-
-    static_assert(test<const int*, input_iterator<int*> >());
-    static_assert(test<const int*, forward_iterator<int*> >());
-    static_assert(test<const int*, bidirectional_iterator<int*> >());
-    static_assert(test<const int*, random_access_iterator<int*> >());
-    static_assert(test<const int*, contiguous_iterator<int*> >());
+    test<legacy_input_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<legacy_forward_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<const int*, legacy_contiguous_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, output_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, legacy_forward_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, int*>();
+    test<legacy_contiguous_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+
+    test1<legacy_input_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<std::unique_ptr<int>*, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, output_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+
+    static_assert(test<legacy_input_iterator<const int*>, legacy_input_iterator<int*> >());
+    static_assert(test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_input_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_input_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_input_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, int*>());
+
+    static_assert(test<const int*, legacy_input_iterator<int*> >());
+    static_assert(test<const int*, legacy_forward_iterator<int*> >());
+    static_assert(test<const int*, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<const int*, legacy_random_access_iterator<int*> >());
+    static_assert(test<const int*, legacy_contiguous_iterator<int*> >());
     static_assert(test<const int*, int*>());
 #endif // TEST_STD_VER > 17
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -62,67 +62,67 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
 
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER >= 11
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
-    test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
-    test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
 #if TEST_STD_VER > 17
-    test<bidirectional_iterator<const int*>, contiguous_iterator<int*>>();
-    test<random_access_iterator<const int*>, contiguous_iterator<int*>>();
-    test<const int*, contiguous_iterator<int*>>();
-    test<contiguous_iterator<const int*>, bidirectional_iterator<int*>>();
-    test<contiguous_iterator<const int*>, random_access_iterator<int*>>();
-    test<contiguous_iterator<const int*>, int*>();
-    test<contiguous_iterator<const int*>, contiguous_iterator<int*>>();
-
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<random_access_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<std::unique_ptr<int>*, contiguous_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*>>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-    test1<contiguous_iterator<std::unique_ptr<int>*>, contiguous_iterator<std::unique_ptr<int>*>>();
-
-    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<const int*>, int*>());
-
-    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<random_access_iterator<const int*>, int*>());
-
-    static_assert(test<contiguous_iterator<const int*>, bidirectional_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, random_access_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, contiguous_iterator<int*> >());
-    static_assert(test<contiguous_iterator<const int*>, int*>());
-
-    static_assert(test<const int*, bidirectional_iterator<int*> >());
-    static_assert(test<const int*, random_access_iterator<int*> >());
-    static_assert(test<const int*, contiguous_iterator<int*> >());
+    test<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+    test<const int*, legacy_contiguous_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*>>();
+    test<legacy_contiguous_iterator<const int*>, int*>();
+    test<legacy_contiguous_iterator<const int*>, legacy_contiguous_iterator<int*>>();
+
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<std::unique_ptr<int>*, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*>>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+    test1<legacy_contiguous_iterator<std::unique_ptr<int>*>, legacy_contiguous_iterator<std::unique_ptr<int>*>>();
+
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<const int*>, int*>());
+
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_random_access_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, legacy_contiguous_iterator<int*> >());
+    static_assert(test<legacy_contiguous_iterator<const int*>, int*>());
+
+    static_assert(test<const int*, legacy_bidirectional_iterator<int*> >());
+    static_assert(test<const int*, legacy_random_access_iterator<int*> >());
+    static_assert(test<const int*, legacy_contiguous_iterator<int*> >());
     static_assert(test<const int*, int*>());
 #endif // TEST_STD_VER > 17
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -39,8 +39,8 @@
   {
     const int ia[] = {1, 2, 3, 4, 5, 6};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                                input_iterator<const int *>(std::end(ia)),
+    assert(!std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                                legacy_input_iterator<const int *>(std::end(ia)),
                                 std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::end(ia)));
@@ -48,8 +48,8 @@
   {
     const int ia[] = {1, 3, 5, 2, 4, 6};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                               input_iterator<const int *>(std::end(ia)),
+    assert(std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                               legacy_input_iterator<const int *>(std::end(ia)),
                                std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::end(ia)));
@@ -57,8 +57,8 @@
   {
     const int ia[] = {2, 4, 6, 1, 3, 5};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                                input_iterator<const int *>(std::end(ia)),
+    assert(!std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                                legacy_input_iterator<const int *>(std::end(ia)),
                                 std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::end(ia)));
@@ -66,8 +66,8 @@
   {
     const int ia[] = {1, 3, 5, 2, 4, 6, 7};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                                input_iterator<const int *>(std::end(ia)),
+    assert(!std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                                legacy_input_iterator<const int *>(std::end(ia)),
                                 std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::end(ia)));
@@ -75,8 +75,8 @@
   {
     const int ia[] = {1, 3, 5, 2, 4, 6, 7};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                               input_iterator<const int *>(std::begin(ia)),
+    assert(std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                               legacy_input_iterator<const int *>(std::begin(ia)),
                                std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::begin(ia)));
@@ -84,8 +84,8 @@
   {
     const int ia[] = {1, 3, 5, 7, 9, 11, 2};
     unary_counting_predicate<is_odd, int> pred((is_odd()));
-    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
-                               input_iterator<const int *>(std::end(ia)),
+    assert(std::is_partitioned(legacy_input_iterator<const int *>(std::begin(ia)),
+                               legacy_input_iterator<const int *>(std::end(ia)),
                                std::ref(pred)));
     assert(static_cast<std::ptrdiff_t>(pred.count()) <=
            std::distance(std::begin(ia), std::end(ia)));
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -98,13 +98,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -50,8 +50,8 @@
         int r1[10] = {0};
         int r2[10] = {0};
         typedef std::pair<output_iterator<int*>,  int*> P;
-        P p = std::partition_copy(input_iterator<const int*>(std::begin(ia)),
-                                  input_iterator<const int*>(std::end(ia)),
+        P p = std::partition_copy(legacy_input_iterator<const int*>(std::begin(ia)),
+                                  legacy_input_iterator<const int*>(std::end(ia)),
                                   output_iterator<int*>(r1), r2, is_odd());
         assert(p.first.base() == r1 + 4);
         assert(r1[0] == 1);
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp
@@ -39,51 +39,51 @@
 {
     {
         const int ia[] = {2, 4, 6, 8, 10};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia));
     }
     {
         const int ia[] = {1, 2, 4, 6, 8};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 1));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 1));
     }
     {
         const int ia[] = {1, 3, 2, 4, 6};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 2));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 2));
     }
     {
         const int ia[] = {1, 3, 5, 2, 4, 6};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 3));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 3));
     }
     {
         const int ia[] = {1, 3, 5, 7, 2, 4};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 4));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 4));
     }
     {
         const int ia[] = {1, 3, 5, 7, 9, 2};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 5));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 5));
     }
     {
         const int ia[] = {1, 3, 5, 7, 9, 11};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::end(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia + 6));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::end(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia + 6));
     }
     {
         const int ia[] = {1, 3, 5, 2, 4, 6, 7};
-        assert(std::partition_point(forward_iterator<const int*>(std::begin(ia)),
-                                    forward_iterator<const int*>(std::begin(ia)),
-                                    is_odd()) == forward_iterator<const int*>(ia));
+        assert(std::partition_point(legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    legacy_forward_iterator<const int*>(std::begin(ia)),
+                                    is_odd()) == legacy_forward_iterator<const int*>(ia));
     }
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -303,12 +303,12 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<std::pair<int,int>*> >();
-    test<random_access_iterator<std::pair<int,int>*> >();
+    test<legacy_bidirectional_iterator<std::pair<int,int>*> >();
+    test<legacy_random_access_iterator<std::pair<int,int>*> >();
     test<std::pair<int,int>*>();
 
 #if TEST_STD_VER >= 11
-    test1<bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
 #endif
 
   return 0;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
@@ -39,7 +39,7 @@
   // expected-error-re@algorithm:* {{static_assert failed{{( due to requirement '.*')?}} "SampleIterator must meet the requirements of RandomAccessIterator"}}
   // expected-error@algorithm:* 2 {{does not provide a subscript operator}}
   // expected-error@algorithm:* {{invalid operands}}
-  test<input_iterator<int *>, output_iterator<int *> >();
+  test<legacy_input_iterator<int *>, output_iterator<int *> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
@@ -137,25 +137,25 @@
 }
 
 int main(int, char**) {
-  test<input_iterator, int, random_access_iterator, int>();
-  test<forward_iterator, int, output_iterator, int>();
-  test<forward_iterator, int, random_access_iterator, int>();
+  test<legacy_input_iterator, int, legacy_random_access_iterator, int>();
+  test<legacy_forward_iterator, int, output_iterator, int>();
+  test<legacy_forward_iterator, int, legacy_random_access_iterator, int>();
 
-  test<input_iterator, int, random_access_iterator, double>();
-  test<forward_iterator, int, output_iterator, double>();
-  test<forward_iterator, int, random_access_iterator, double>();
+  test<legacy_input_iterator, int, legacy_random_access_iterator, double>();
+  test<legacy_forward_iterator, int, output_iterator, double>();
+  test<legacy_forward_iterator, int, legacy_random_access_iterator, double>();
 
-  test_empty_population<input_iterator, int, random_access_iterator, int>();
-  test_empty_population<forward_iterator, int, output_iterator, int>();
-  test_empty_population<forward_iterator, int, random_access_iterator, int>();
+  test_empty_population<legacy_input_iterator, int, legacy_random_access_iterator, int>();
+  test_empty_population<legacy_forward_iterator, int, output_iterator, int>();
+  test_empty_population<legacy_forward_iterator, int, legacy_random_access_iterator, int>();
 
-  test_empty_sample<input_iterator, int, random_access_iterator, int>();
-  test_empty_sample<forward_iterator, int, output_iterator, int>();
-  test_empty_sample<forward_iterator, int, random_access_iterator, int>();
+  test_empty_sample<legacy_input_iterator, int, legacy_random_access_iterator, int>();
+  test_empty_sample<legacy_forward_iterator, int, output_iterator, int>();
+  test_empty_sample<legacy_forward_iterator, int, legacy_random_access_iterator, int>();
 
-  test_small_population<input_iterator, int, random_access_iterator, int>();
-  test_small_population<forward_iterator, int, output_iterator, int>();
-  test_small_population<forward_iterator, int, random_access_iterator, int>();
+  test_small_population<legacy_input_iterator, int, legacy_random_access_iterator, int>();
+  test_small_population<legacy_forward_iterator, int, output_iterator, int>();
+  test_small_population<legacy_forward_iterator, int, legacy_random_access_iterator, int>();
 
   return 0;
 }
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
@@ -50,8 +50,8 @@
 }
 
 int main(int, char**) {
-  test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
-  test_stability<input_iterator<int *>, random_access_iterator<int *> >(false);
+  test_stability<legacy_forward_iterator<int *>, output_iterator<int *> >(true);
+  test_stability<legacy_input_iterator<int *>, legacy_random_access_iterator<int *> >(false);
 
   return 0;
 }
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -56,7 +56,7 @@
     LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
     assert(std::is_permutation(ia, ia+sa, ia2));
 
-    test_with_iterator<random_access_iterator<int*> >();
+    test_with_iterator<legacy_random_access_iterator<int*> >();
     test_with_iterator<int*>();
 
   return 0;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -55,7 +55,7 @@
 
 int main(int, char**)
 {
-    test_with_iterator<random_access_iterator<int*> >();
+    test_with_iterator<legacy_random_access_iterator<int*> >();
     test_with_iterator<int*>();
     return 0;
 }
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp
@@ -75,15 +75,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test1<forward_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp
@@ -52,34 +52,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
 
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
 
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
 
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
@@ -57,34 +57,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -90,15 +90,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test1<forward_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp
@@ -49,9 +49,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp
@@ -56,34 +56,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
@@ -60,34 +60,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
@@ -52,9 +52,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp
@@ -56,13 +56,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp
@@ -74,22 +74,22 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -427,24 +427,24 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
 
-    test1<forward_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
 #endif
 
 #if TEST_STD_VER > 17
-    static_assert(test<forward_iterator<int*> >());
-    static_assert(test<bidirectional_iterator<int*> >());
-    static_assert(test<random_access_iterator<int*> >());
+    static_assert(test<legacy_forward_iterator<int*> >());
+    static_assert(test<legacy_bidirectional_iterator<int*> >());
+    static_assert(test<legacy_random_access_iterator<int*> >());
     static_assert(test<int*>());
 #endif // TEST_STD_VER > 17
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp
@@ -129,22 +129,22 @@
 }
 
 TEST_CONSTEXPR_CXX20 bool all_tests() {
-  test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-  test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-  test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-  test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-  test<bidirectional_iterator<const int*>, int*>();
-
-  test<random_access_iterator<const int*>, output_iterator<int*> >();
-  test<random_access_iterator<const int*>, forward_iterator<int*> >();
-  test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-  test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-  test<random_access_iterator<const int*>, int*>();
+  test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+  test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+  test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+  test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+  test<legacy_bidirectional_iterator<const int*>, int*>();
+
+  test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+  test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+  test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+  test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+  test<legacy_random_access_iterator<const int*>, int*>();
 
   test<const int*, output_iterator<int*> >();
-  test<const int*, forward_iterator<int*> >();
-  test<const int*, bidirectional_iterator<int*> >();
-  test<const int*, random_access_iterator<int*> >();
+  test<const int*, legacy_forward_iterator<int*> >();
+  test<const int*, legacy_bidirectional_iterator<int*> >();
+  test<const int*, legacy_random_access_iterator<int*> >();
   test<const int*, int*>();
 
   return true;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_left.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_left.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_left.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_left.pass.cpp
@@ -106,22 +106,22 @@
 
 int main(int, char**)
 {
-    test<int, forward_iterator<int*>>();
-    test<int, bidirectional_iterator<int*>>();
-    test<int, random_access_iterator<int*>>();
+    test<int, legacy_forward_iterator<int*>>();
+    test<int, legacy_bidirectional_iterator<int*>>();
+    test<int, legacy_random_access_iterator<int*>>();
     test<int, int*>();
-    test<MoveOnly, forward_iterator<MoveOnly*>>();
-    test<MoveOnly, bidirectional_iterator<MoveOnly*>>();
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_forward_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_bidirectional_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 
-    static_assert(test<int, forward_iterator<int*>>());
-    static_assert(test<int, bidirectional_iterator<int*>>());
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_forward_iterator<int*>>());
+    static_assert(test<int, legacy_bidirectional_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, forward_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, bidirectional_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_forward_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_bidirectional_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 
     return 0;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_right.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_right.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_right.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_right.pass.cpp
@@ -105,22 +105,22 @@
 
 int main(int, char**)
 {
-    test<int, forward_iterator<int*>>();
-    test<int, bidirectional_iterator<int*>>();
-    test<int, random_access_iterator<int*>>();
+    test<int, legacy_forward_iterator<int*>>();
+    test<int, legacy_bidirectional_iterator<int*>>();
+    test<int, legacy_random_access_iterator<int*>>();
     test<int, int*>();
-    test<MoveOnly, forward_iterator<MoveOnly*>>();
-    test<MoveOnly, bidirectional_iterator<MoveOnly*>>();
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_forward_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_bidirectional_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 
-    static_assert(test<int, forward_iterator<int*>>());
-    static_assert(test<int, bidirectional_iterator<int*>>());
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_forward_iterator<int*>>());
+    static_assert(test<int, legacy_bidirectional_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, forward_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, bidirectional_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_forward_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_bidirectional_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 
     return 0;
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp
@@ -122,45 +122,45 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*>, forward_iterator<int*> >();
-    test<forward_iterator<int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<int*>, random_access_iterator<int*> >();
-    test<forward_iterator<int*>, int*>();
-
-    test<bidirectional_iterator<int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<int*>, int*>();
-
-    test<random_access_iterator<int*>, forward_iterator<int*> >();
-    test<random_access_iterator<int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<int*>, int*>();
-
-    test<int*, forward_iterator<int*> >();
-    test<int*, bidirectional_iterator<int*> >();
-    test<int*, random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*>, int*>();
+
+    test<legacy_bidirectional_iterator<int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*>, int*>();
+
+    test<legacy_random_access_iterator<int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<int*>, int*>();
+
+    test<int*, legacy_forward_iterator<int*> >();
+    test<int*, legacy_bidirectional_iterator<int*> >();
+    test<int*, legacy_random_access_iterator<int*> >();
     test<int*, int*>();
 
 #if TEST_STD_VER >= 11
-    test1<forward_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<random_access_iterator<std::unique_ptr<int>*>, forward_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, random_access_iterator<std::unique_ptr<int>*> >();
-    test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
-
-    test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
-    test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_forward_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_bidirectional_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, legacy_random_access_iterator<std::unique_ptr<int>*> >();
+    test1<legacy_random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
+
+    test1<std::unique_ptr<int>*, legacy_forward_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_bidirectional_iterator<std::unique_ptr<int>*> >();
+    test1<std::unique_ptr<int>*, legacy_random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
@@ -58,179 +58,179 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<const int*>, int*>();
-
-    test<input_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*>, int*>();
-
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
-
-    test<input_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*>, int*>();
-
-    test<input_iterator<const int*>, const int*, output_iterator<int*> >();
-    test<input_iterator<const int*>, const int*, input_iterator<int*> >();
-    test<input_iterator<const int*>, const int*, forward_iterator<int*> >();
-    test<input_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, const int*, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, const int*, int*>();
-
-    test<forward_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, const int*, output_iterator<int*> >();
-    test<forward_iterator<const int*>, const int*, input_iterator<int*> >();
-    test<forward_iterator<const int*>, const int*, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, const int*, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, const int*, int*>();
-
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, const int*, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, const int*, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, const int*, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, const int*, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, const int*, int*>();
-
-    test<random_access_iterator<const int*>, input_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<const int*>, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, const int*, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, const int*, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, const int*, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, const int*, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, const int*, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, const int*, int*>();
-
-    test<const int*, input_iterator<const int*>, output_iterator<int*> >();
-    test<const int*, input_iterator<const int*>, input_iterator<int*> >();
-    test<const int*, input_iterator<const int*>, forward_iterator<int*> >();
-    test<const int*, input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<const int*, input_iterator<const int*>, random_access_iterator<int*> >();
-    test<const int*, input_iterator<const int*>, int*>();
-
-    test<const int*, forward_iterator<const int*>, output_iterator<int*> >();
-    test<const int*, forward_iterator<const int*>, input_iterator<int*> >();
-    test<const int*, forward_iterator<const int*>, forward_iterator<int*> >();
-    test<const int*, forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<const int*, forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<const int*, forward_iterator<const int*>, int*>();
-
-    test<const int*, bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<const int*, bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<const int*, bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<const int*, bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<const int*, bidirectional_iterator<const int*>, int*>();
-
-    test<const int*, random_access_iterator<const int*>, output_iterator<int*> >();
-    test<const int*, random_access_iterator<const int*>, input_iterator<int*> >();
-    test<const int*, random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<const int*, random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<const int*, random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*>, int*>();
+
+    test<legacy_input_iterator<const int*>, const int*, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, const int*, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, const int*, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, const int*, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, const int*, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, const int*, int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, const int*, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, const int*, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, const int*, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, const int*, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, const int*, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, const int*, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, const int*, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*, int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, const int*, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*, int*>();
+
+    test<const int*, legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<const int*, legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<const int*, legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<const int*, legacy_input_iterator<const int*>, int*>();
+
+    test<const int*, legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<const int*>, int*>();
+
+    test<const int*, legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<const int*, legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, const int*, output_iterator<int*> >();
-    test<const int*, const int*, input_iterator<int*> >();
-    test<const int*, const int*, forward_iterator<int*> >();
-    test<const int*, const int*, bidirectional_iterator<int*> >();
-    test<const int*, const int*, random_access_iterator<int*> >();
+    test<const int*, const int*, legacy_input_iterator<int*> >();
+    test<const int*, const int*, legacy_forward_iterator<int*> >();
+    test<const int*, const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, const int*, legacy_random_access_iterator<int*> >();
     test<const int*, const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
@@ -59,39 +59,39 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, input_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, input_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, input_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, input_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, input_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_input_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp
@@ -183,15 +183,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test1<forward_iterator<Ptr*> >();
-    test1<bidirectional_iterator<Ptr*> >();
-    test1<random_access_iterator<Ptr*> >();
+    test1<legacy_forward_iterator<Ptr*> >();
+    test1<legacy_bidirectional_iterator<Ptr*> >();
+    test1<legacy_random_access_iterator<Ptr*> >();
     test1<Ptr*>();
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
@@ -107,34 +107,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
@@ -135,34 +135,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -225,15 +225,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test1<forward_iterator<Ptr*> >();
-    test1<bidirectional_iterator<Ptr*> >();
-    test1<random_access_iterator<Ptr*> >();
+    test1<legacy_forward_iterator<Ptr*> >();
+    test1<legacy_bidirectional_iterator<Ptr*> >();
+    test1<legacy_random_access_iterator<Ptr*> >();
     test1<Ptr*>();
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp
@@ -34,15 +34,15 @@
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-    assert(std::adjacent_find(forward_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ia + sa)) ==
-                              forward_iterator<const int*>(ia+2));
-    assert(std::adjacent_find(forward_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ia)) ==
-                              forward_iterator<const int*>(ia));
-    assert(std::adjacent_find(forward_iterator<const int*>(ia+3),
-                              forward_iterator<const int*>(ia + sa)) ==
-                              forward_iterator<const int*>(ia+sa));
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ia + sa)) ==
+                              legacy_forward_iterator<const int*>(ia+2));
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ia)) ==
+                              legacy_forward_iterator<const int*>(ia));
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia+3),
+                              legacy_forward_iterator<const int*>(ia + sa)) ==
+                              legacy_forward_iterator<const int*>(ia+sa));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
@@ -38,18 +38,18 @@
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-    assert(std::adjacent_find(forward_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ia + sa),
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ia + sa),
                               std::equal_to<int>()) ==
-                              forward_iterator<const int*>(ia+2));
-    assert(std::adjacent_find(forward_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ia+2));
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ia),
                               std::equal_to<int>()) ==
-                              forward_iterator<const int*>(ia));
-    assert(std::adjacent_find(forward_iterator<const int*>(ia+3),
-                              forward_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ia));
+    assert(std::adjacent_find(legacy_forward_iterator<const int*>(ia+3),
+                              legacy_forward_iterator<const int*>(ia + sa),
                               std::equal_to<int>()) ==
-                              forward_iterator<const int*>(ia+sa));
+                              legacy_forward_iterator<const int*>(ia+sa));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp
@@ -41,18 +41,18 @@
     {
         int ia[] = {2, 4, 6, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::all_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia + sa), test1()) == true);
-        assert(std::all_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia), test1()) == true);
+        assert(std::all_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia + sa), test1()) == true);
+        assert(std::all_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia), test1()) == true);
     }
     {
         const int ia[] = {2, 4, 5, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::all_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia + sa), test1()) == false);
-        assert(std::all_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia), test1()) == true);
+        assert(std::all_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia + sa), test1()) == false);
+        assert(std::all_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia), test1()) == true);
     }
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp
@@ -41,26 +41,26 @@
     {
         int ia[] = {2, 4, 6, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia + sa), test1()) == true);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia), test1()) == false);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia + sa), test1()) == true);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia), test1()) == false);
     }
     {
         const int ia[] = {2, 4, 5, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia + sa), test1()) == true);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia), test1()) == false);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia + sa), test1()) == true);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia), test1()) == false);
     }
     {
         const int ia[] = {1, 3, 5, 7};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia + sa), test1()) == false);
-        assert(std::any_of(input_iterator<const int*>(ia),
-                           input_iterator<const int*>(ia), test1()) == false);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia + sa), test1()) == false);
+        assert(std::any_of(legacy_input_iterator<const int*>(ia),
+                           legacy_input_iterator<const int*>(ia), test1()) == false);
     }
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp
@@ -33,12 +33,12 @@
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-    assert(std::count(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia + sa), 2) == 3);
-    assert(std::count(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia + sa), 7) == 0);
-    assert(std::count(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia), 2) == 0);
+    assert(std::count(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia + sa), 2) == 3);
+    assert(std::count(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia + sa), 7) == 0);
+    assert(std::count(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia), 2) == 0);
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -40,14 +40,14 @@
 {
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-    assert(std::count_if(input_iterator<const int*>(ia),
-                         input_iterator<const int*>(ia + sa),
+    assert(std::count_if(legacy_input_iterator<const int*>(ia),
+                         legacy_input_iterator<const int*>(ia + sa),
                          eq(2)) == 3);
-    assert(std::count_if(input_iterator<const int*>(ia),
-                         input_iterator<const int*>(ia + sa),
+    assert(std::count_if(legacy_input_iterator<const int*>(ia),
+                         legacy_input_iterator<const int*>(ia + sa),
                          eq(7)) == 0);
-    assert(std::count_if(input_iterator<const int*>(ia),
-                         input_iterator<const int*>(ia),
+    assert(std::count_if(legacy_input_iterator<const int*>(ia),
+                         legacy_input_iterator<const int*>(ia),
                          eq(2)) == 0);
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -29,8 +29,8 @@
     int ia[] = {1, 3, 6, 7};
     int ib[] = {1, 3};
     int ic[] = {1, 3, 5, 7};
-    typedef input_iterator<int*>         II;
-    typedef bidirectional_iterator<int*> BI;
+    typedef legacy_input_iterator<int*>         II;
+    typedef legacy_bidirectional_iterator<int*> BI;
 
     return !std::equal(std::begin(ia), std::end(ia), std::begin(ic))
         && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic))
@@ -49,39 +49,39 @@
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
     int ib[s] = {0, 1, 2, 5, 4, 5};
-    assert(std::equal(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
-                      input_iterator<const int*>(ia)));
+    assert(std::equal(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
+                      legacy_input_iterator<const int*>(ia)));
 #if TEST_STD_VER >= 14
-    assert(std::equal(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
-                      input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s)));
-    assert(std::equal(random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s),
-                      random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s)));
+    assert(std::equal(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
+                      legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s)));
+    assert(std::equal(legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s),
+                      legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s)));
 #endif
-    assert(!std::equal(input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s),
-                       input_iterator<const int*>(ib)));
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s),
+                       legacy_input_iterator<const int*>(ib)));
 #if TEST_STD_VER >= 14
-    assert(!std::equal(input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s),
-                       input_iterator<const int*>(ib),
-                       input_iterator<const int*>(ib+s)));
-    assert(!std::equal(random_access_iterator<const int*>(ia),
-                       random_access_iterator<const int*>(ia+s),
-                       random_access_iterator<const int*>(ib),
-                       random_access_iterator<const int*>(ib+s)));
-    assert(!std::equal(input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s),
-                       input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s-1)));
-    assert(!std::equal(random_access_iterator<const int*>(ia),
-                       random_access_iterator<const int*>(ia+s),
-                       random_access_iterator<const int*>(ia),
-                       random_access_iterator<const int*>(ia+s-1)));
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s),
+                       legacy_input_iterator<const int*>(ib),
+                       legacy_input_iterator<const int*>(ib+s)));
+    assert(!std::equal(legacy_random_access_iterator<const int*>(ia),
+                       legacy_random_access_iterator<const int*>(ia+s),
+                       legacy_random_access_iterator<const int*>(ib),
+                       legacy_random_access_iterator<const int*>(ib+s)));
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s),
+                       legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s-1)));
+    assert(!std::equal(legacy_random_access_iterator<const int*>(ia),
+                       legacy_random_access_iterator<const int*>(ia+s),
+                       legacy_random_access_iterator<const int*>(ia),
+                       legacy_random_access_iterator<const int*>(ia+s-1)));
 
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
@@ -36,8 +36,8 @@
     int ia[] = {1, 3, 6, 7};
     int ib[] = {1, 3};
     int ic[] = {1, 3, 5, 7};
-    typedef input_iterator<int*>         II;
-    typedef bidirectional_iterator<int*> BI;
+    typedef legacy_input_iterator<int*>         II;
+    typedef legacy_bidirectional_iterator<int*> BI;
 
     return !std::equal(std::begin(ia), std::end(ia), std::begin(ic)              , eq)
         && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq)
@@ -63,51 +63,51 @@
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
     int ib[s] = {0, 1, 2, 5, 4, 5};
-    assert(std::equal(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
-                      input_iterator<const int*>(ia),
+    assert(std::equal(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
+                      legacy_input_iterator<const int*>(ia),
                       std::equal_to<int>()));
 #if TEST_STD_VER >= 14
-    assert(std::equal(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
-                      input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
+    assert(std::equal(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
+                      legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
                       std::equal_to<int>()));
-    assert(std::equal(random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s),
-                      random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s),
+    assert(std::equal(legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s),
+                      legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s),
                       std::equal_to<int>()));
 
     comparison_count = 0;
-    assert(!std::equal(input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s),
-                      input_iterator<const int*>(ia),
-                      input_iterator<const int*>(ia+s-1),
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s),
+                      legacy_input_iterator<const int*>(ia),
+                      legacy_input_iterator<const int*>(ia+s-1),
                       counting_equals<int>));
     assert(comparison_count > 0);
     comparison_count = 0;
-    assert(!std::equal(random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s),
-                      random_access_iterator<const int*>(ia),
-                      random_access_iterator<const int*>(ia+s-1),
+    assert(!std::equal(legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s),
+                      legacy_random_access_iterator<const int*>(ia),
+                      legacy_random_access_iterator<const int*>(ia+s-1),
                       counting_equals<int>));
     assert(comparison_count == 0);
 #endif
-    assert(!std::equal(input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s),
-                       input_iterator<const int*>(ib),
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s),
+                       legacy_input_iterator<const int*>(ib),
                        std::equal_to<int>()));
 #if TEST_STD_VER >= 14
-    assert(!std::equal(input_iterator<const int*>(ia),
-                       input_iterator<const int*>(ia+s),
-                       input_iterator<const int*>(ib),
-                       input_iterator<const int*>(ib+s),
+    assert(!std::equal(legacy_input_iterator<const int*>(ia),
+                       legacy_input_iterator<const int*>(ia+s),
+                       legacy_input_iterator<const int*>(ib),
+                       legacy_input_iterator<const int*>(ib+s),
                        std::equal_to<int>()));
-    assert(!std::equal(random_access_iterator<const int*>(ia),
-                       random_access_iterator<const int*>(ia+s),
-                       random_access_iterator<const int*>(ib),
-                       random_access_iterator<const int*>(ib+s),
+    assert(!std::equal(legacy_random_access_iterator<const int*>(ia),
+                       legacy_random_access_iterator<const int*>(ia+s),
+                       legacy_random_access_iterator<const int*>(ib),
+                       legacy_random_access_iterator<const int*>(ib+s),
                        std::equal_to<int>()));
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp
@@ -24,9 +24,9 @@
     int ia[] = {0, 1, 2};
     int ib[] = {4, 5, 6};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0};
-    typedef forward_iterator<int*>       FI;
-    typedef bidirectional_iterator<int*> BI;
-    typedef random_access_iterator<int*> RI;
+    typedef legacy_forward_iterator<int*>       FI;
+    typedef legacy_bidirectional_iterator<int*> BI;
+    typedef legacy_random_access_iterator<int*> RI;
 
     return    (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia))) == FI(ic+15))
            && (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib))) == FI(std::end(ic)))
@@ -64,15 +64,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -34,9 +34,9 @@
     int ia[] = {0, 1, 2};
     int ib[] = {4, 5, 6};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0};
-    typedef forward_iterator<int*>       FI;
-    typedef bidirectional_iterator<int*> BI;
-    typedef random_access_iterator<int*> RI;
+    typedef legacy_forward_iterator<int*>       FI;
+    typedef legacy_bidirectional_iterator<int*> BI;
+    typedef legacy_random_access_iterator<int*> RI;
     std::equal_to<int> eq{};
     return    (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia)), eq) == FI(ic+15))
            && (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib)), eq) == FI(std::end(ic)))
@@ -94,15 +94,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp
@@ -24,9 +24,9 @@
     int ia[] = {1, 2, 3};
     int ib[] = {7, 8, 9};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3};
-    typedef forward_iterator<int*>       FI;
-    typedef bidirectional_iterator<int*> BI;
-    typedef random_access_iterator<int*> RI;
+    typedef legacy_forward_iterator<int*>       FI;
+    typedef legacy_bidirectional_iterator<int*> BI;
+    typedef legacy_random_access_iterator<int*> RI;
 
     return    (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia))) == FI(ic+1))
            && (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib))) == FI(std::end(ic)))
@@ -44,27 +44,27 @@
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {1, 3, 5, 7};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]);
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ib),
-                              forward_iterator<const int*>(ib + sb)) ==
-                              input_iterator<const int*>(ia+1));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ib),
+                              legacy_forward_iterator<const int*>(ib + sb)) ==
+                              legacy_input_iterator<const int*>(ia+1));
     int ic[] = {7};
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic + 1)) ==
-                              input_iterator<const int*>(ia+sa));
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic)) ==
-                              input_iterator<const int*>(ia+sa));
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic+1)) ==
-                              input_iterator<const int*>(ia));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic + 1)) ==
+                              legacy_input_iterator<const int*>(ia+sa));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic)) ==
+                              legacy_input_iterator<const int*>(ia+sa));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic+1)) ==
+                              legacy_input_iterator<const int*>(ia));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
@@ -26,9 +26,9 @@
     int ia[] = {1, 2, 3};
     int ib[] = {7, 8, 9};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3};
-    typedef forward_iterator<int*>       FI;
-    typedef bidirectional_iterator<int*> BI;
-    typedef random_access_iterator<int*> RI;
+    typedef legacy_forward_iterator<int*>       FI;
+    typedef legacy_bidirectional_iterator<int*> BI;
+    typedef legacy_random_access_iterator<int*> RI;
     std::equal_to<int> eq{};
     return    (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia)), eq) == FI(ic+1))
            && (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib)), eq) == FI(std::end(ic)))
@@ -46,31 +46,31 @@
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {1, 3, 5, 7};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]);
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ib),
-                              forward_iterator<const int*>(ib + sb),
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ib),
+                              legacy_forward_iterator<const int*>(ib + sb),
                               std::equal_to<int>()) ==
-                              input_iterator<const int*>(ia+1));
+                              legacy_input_iterator<const int*>(ia+1));
     int ic[] = {7};
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic + 1),
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic + 1),
                               std::equal_to<int>()) ==
-                              input_iterator<const int*>(ia+sa));
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia + sa),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic),
+                              legacy_input_iterator<const int*>(ia+sa));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia + sa),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic),
                               std::equal_to<int>()) ==
-                              input_iterator<const int*>(ia+sa));
-    assert(std::find_first_of(input_iterator<const int*>(ia),
-                              input_iterator<const int*>(ia),
-                              forward_iterator<const int*>(ic),
-                              forward_iterator<const int*>(ic+1),
+                              legacy_input_iterator<const int*>(ia+sa));
+    assert(std::find_first_of(legacy_input_iterator<const int*>(ia),
+                              legacy_input_iterator<const int*>(ia),
+                              legacy_forward_iterator<const int*>(ic),
+                              legacy_forward_iterator<const int*>(ic+1),
                               std::equal_to<int>()) ==
-                              input_iterator<const int*>(ia));
+                              legacy_input_iterator<const int*>(ia));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp
@@ -33,11 +33,11 @@
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
-    input_iterator<const int*> r = std::find(input_iterator<const int*>(ia),
-                                             input_iterator<const int*>(ia+s), 3);
+    legacy_input_iterator<const int*> r = std::find(legacy_input_iterator<const int*>(ia),
+                                             legacy_input_iterator<const int*>(ia+s), 3);
     assert(*r == 3);
-    r = std::find(input_iterator<const int*>(ia), input_iterator<const int*>(ia+s), 10);
-    assert(r == input_iterator<const int*>(ia+s));
+    r = std::find(legacy_input_iterator<const int*>(ia), legacy_input_iterator<const int*>(ia+s), 10);
+    assert(r == legacy_input_iterator<const int*>(ia+s));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -41,14 +41,14 @@
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
-    input_iterator<const int*> r = std::find_if(input_iterator<const int*>(ia),
-                                                input_iterator<const int*>(ia+s),
+    legacy_input_iterator<const int*> r = std::find_if(legacy_input_iterator<const int*>(ia),
+                                                legacy_input_iterator<const int*>(ia+s),
                                                 eq(3));
     assert(*r == 3);
-    r = std::find_if(input_iterator<const int*>(ia),
-                     input_iterator<const int*>(ia+s),
+    r = std::find_if(legacy_input_iterator<const int*>(ia),
+                     legacy_input_iterator<const int*>(ia+s),
                      eq(10));
-    assert(r == input_iterator<const int*>(ia+s));
+    assert(r == legacy_input_iterator<const int*>(ia+s));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -41,14 +41,14 @@
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
-    input_iterator<const int*> r = std::find_if_not(input_iterator<const int*>(ia),
-                                                    input_iterator<const int*>(ia+s),
+    legacy_input_iterator<const int*> r = std::find_if_not(legacy_input_iterator<const int*>(ia),
+                                                    legacy_input_iterator<const int*>(ia+s),
                                                     ne(3));
     assert(*r == 3);
-    r = std::find_if_not(input_iterator<const int*>(ia),
-                         input_iterator<const int*>(ia+s),
+    r = std::find_if_not(legacy_input_iterator<const int*>(ia),
+                         legacy_input_iterator<const int*>(ia+s),
                          ne(10));
-    assert(r == input_iterator<const int*>(ia+s));
+    assert(r == legacy_input_iterator<const int*>(ia+s));
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp
@@ -42,7 +42,7 @@
 
 int main(int, char**)
 {
-    typedef input_iterator<int*> Iter;
+    typedef legacy_input_iterator<int*> Iter;
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
@@ -41,8 +41,8 @@
 {
     int ia[] = {0, 1, 2, 3, 4, 5};
     const unsigned s = sizeof(ia)/sizeof(ia[0]);
-    for_each_test f = std::for_each(input_iterator<int*>(ia),
-                                    input_iterator<int*>(ia+s),
+    for_each_test f = std::for_each(legacy_input_iterator<int*>(ia),
+                                    legacy_input_iterator<int*>(ia+s),
                                     for_each_test(0));
     assert(f.count == s);
     for (unsigned i = 0; i < s; ++i)
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp
@@ -41,41 +41,41 @@
         const int ia[] = {0};
         const int ib[] = {0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + 0),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + 0),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + 0),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + 0)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + 0),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + 0)) == true);
 #endif
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0};
         const int ib[] = {1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
 
@@ -83,232 +83,232 @@
         const int ia[] = {0, 0};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
 #endif
     }
     {
         const int ia[] = {0, 1};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 0};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 0};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
 #endif
     }
     {
         const int ia[] = {1, 0};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
 #endif
     }
     {
         const int ia[] = {1, 0};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 1};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 1};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 1};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {1, 1};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
 #endif
     }
 
@@ -316,302 +316,302 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2};
         const int ib[] = {1, 0, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2};
         const int ib[] = {1, 2, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2};
         const int ib[] = {2, 1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2};
         const int ib[] = {2, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
     {
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib + 1),
-                                   forward_iterator<const int*>(ib + sa)) == false);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib + 1),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib + 1 ),
-                                   forward_iterator<const int*>(ib + sa)) == false);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == true);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib + 1 ),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1)) == false);
 #endif
     }
     {
         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib)) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa)) == false);
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa)) == false);
 #endif
     }
 
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp
@@ -61,24 +61,24 @@
         const int ia[] = {0};
         const int ib[] = {0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + 0),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + 0),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -86,15 +86,15 @@
         const int ia[] = {0};
         const int ib[] = {1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -103,20 +103,20 @@
         const int ia[] = {0, 0};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -124,15 +124,15 @@
         const int ia[] = {0, 0};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -140,15 +140,15 @@
         const int ia[] = {0, 0};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -156,15 +156,15 @@
         const int ia[] = {0, 0};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -172,15 +172,15 @@
         const int ia[] = {0, 1};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -188,20 +188,20 @@
         const int ia[] = {0, 1};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -209,20 +209,20 @@
         const int ia[] = {0, 1};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -230,15 +230,15 @@
         const int ia[] = {0, 1};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -246,15 +246,15 @@
         const int ia[] = {1, 0};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -262,20 +262,20 @@
         const int ia[] = {1, 0};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -283,20 +283,20 @@
         const int ia[] = {1, 0};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -304,15 +304,15 @@
         const int ia[] = {1, 0};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -320,15 +320,15 @@
         const int ia[] = {1, 1};
         const int ib[] = {0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -336,15 +336,15 @@
         const int ia[] = {1, 1};
         const int ib[] = {0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -352,15 +352,15 @@
         const int ia[] = {1, 1};
         const int ib[] = {1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -368,20 +368,20 @@
         const int ia[] = {1, 1};
         const int ib[] = {1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -390,15 +390,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -406,15 +406,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -422,15 +422,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 0, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -438,15 +438,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -454,15 +454,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -470,15 +470,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 1, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -486,15 +486,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -502,15 +502,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -518,15 +518,15 @@
         const int ia[] = {0, 0, 0};
         const int ib[] = {1, 2, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -534,20 +534,20 @@
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -555,15 +555,15 @@
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -571,20 +571,20 @@
         const int ia[] = {0, 1, 2};
         const int ib[] = {1, 0, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -592,20 +592,20 @@
         const int ia[] = {0, 1, 2};
         const int ib[] = {1, 2, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -613,20 +613,20 @@
         const int ia[] = {0, 1, 2};
         const int ib[] = {2, 1, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -634,20 +634,20 @@
         const int ia[] = {0, 1, 2};
         const int ib[] = {2, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -655,15 +655,15 @@
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 1};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -671,25 +671,25 @@
         const int ia[] = {0, 0, 1};
         const int ib[] = {1, 0, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib + 1),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib + 1),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -697,38 +697,38 @@
         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == true);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == true);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib + 1),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib + 1),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    std::equal_to<const int>()) == false);
         comparison_count = 0;
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa - 1),
                                    counting_equals<const int>) == false);
         assert ( comparison_count > 0 );
         comparison_count = 0;
-        assert(std::is_permutation(random_access_iterator<const int*>(ia),
-                                   random_access_iterator<const int*>(ia + sa),
-                                   random_access_iterator<const int*>(ib),
-                                   random_access_iterator<const int*>(ib + sa - 1),
+        assert(std::is_permutation(legacy_random_access_iterator<const int*>(ia),
+                                   legacy_random_access_iterator<const int*>(ia + sa),
+                                   legacy_random_access_iterator<const int*>(ib),
+                                   legacy_random_access_iterator<const int*>(ib + sa - 1),
                                    counting_equals<const int>) == false);
         assert ( comparison_count == 0 );
 #endif
@@ -737,15 +737,15 @@
         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
                                    std::equal_to<const int>()) == false);
 #if TEST_STD_VER >= 14
-        assert(std::is_permutation(forward_iterator<const int*>(ia),
-                                   forward_iterator<const int*>(ia + sa),
-                                   forward_iterator<const int*>(ib),
-                                   forward_iterator<const int*>(ib + sa),
+        assert(std::is_permutation(legacy_forward_iterator<const int*>(ia),
+                                   legacy_forward_iterator<const int*>(ia + sa),
+                                   legacy_forward_iterator<const int*>(ib),
+                                   legacy_forward_iterator<const int*>(ib + sa),
                                    std::equal_to<const int>()) == false);
 #endif
     }
@@ -753,15 +753,15 @@
       const S a[] = {S(0), S(1)};
       const S b[] = {S(1), S(0)};
       const unsigned sa = sizeof(a)/sizeof(a[0]);
-      assert(std::is_permutation(forward_iterator<const S*>(a),
-                                 forward_iterator<const S*>(a + sa),
-                                 forward_iterator<const S*>(b),
+      assert(std::is_permutation(legacy_forward_iterator<const S*>(a),
+                                 legacy_forward_iterator<const S*>(a + sa),
+                                 legacy_forward_iterator<const S*>(b),
                                  eq()));
 #if TEST_STD_VER >= 14
-      assert(std::is_permutation(forward_iterator<const S*>(a),
-                                 forward_iterator<const S*>(a + sa),
-                                 forward_iterator<const S*>(b),
-                                 forward_iterator<const S*>(b + sa),
+      assert(std::is_permutation(legacy_forward_iterator<const S*>(a),
+                                 legacy_forward_iterator<const S*>(a + sa),
+                                 legacy_forward_iterator<const S*>(b),
+                                 legacy_forward_iterator<const S*>(b + sa),
                                  eq()));
 #endif
     }
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp
@@ -41,26 +41,26 @@
     {
         int ia[] = {2, 4, 6, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia + sa), test1()) == false);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia), test1()) == true);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia + sa), test1()) == false);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia), test1()) == true);
     }
     {
         const int ia[] = {2, 4, 5, 8};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia + sa), test1()) == false);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia), test1()) == true);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia + sa), test1()) == false);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia), test1()) == true);
     }
     {
         const int ia[] = {1, 3, 5, 7};
         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia + sa), test1()) == true);
-        assert(std::none_of(input_iterator<const int*>(ia),
-                            input_iterator<const int*>(ia), test1()) == true);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia + sa), test1()) == true);
+        assert(std::none_of(legacy_input_iterator<const int*>(ia),
+                            legacy_input_iterator<const int*>(ia), test1()) == true);
     }
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp
@@ -118,18 +118,18 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-
-    adl_test<forward_iterator<User::S*> >();
-    adl_test<random_access_iterator<User::S*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+
+    adl_test<legacy_forward_iterator<User::S*> >();
+    adl_test<legacy_random_access_iterator<User::S*> >();
 
 #if TEST_STD_VER > 14
 {
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -81,9 +81,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
@@ -160,9 +160,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp
@@ -112,15 +112,15 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER > 17
     static_assert(test_constexpr());
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -28,8 +28,8 @@
     int ia[] = {1, 3, 6, 7};
     int ib[] = {1, 3};
     int ic[] = {1, 3, 5, 7};
-    typedef input_iterator<int*>         II;
-    typedef bidirectional_iterator<int*> BI;
+    typedef legacy_input_iterator<int*>         II;
+    typedef legacy_bidirectional_iterator<int*> BI;
 
     auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic));
     if (p1.first != ia+2 || p1.second != ic+2)
@@ -65,8 +65,8 @@
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
 
-    typedef input_iterator<const int*> II;
-    typedef random_access_iterator<const int*>  RAI;
+    typedef legacy_input_iterator<const int*> II;
+    typedef legacy_random_access_iterator<const int*>  RAI;
 
     assert(std::mismatch(II(ia), II(ia + sa), II(ib))
             == (std::pair<II, II>(II(ia+3), II(ib+3))));
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -33,8 +33,8 @@
     int ia[] = {1, 3, 6, 7};
     int ib[] = {1, 3};
     int ic[] = {1, 3, 5, 7};
-    typedef input_iterator<int*>         II;
-    typedef bidirectional_iterator<int*> BI;
+    typedef legacy_input_iterator<int*>         II;
+    typedef legacy_bidirectional_iterator<int*> BI;
 
     auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), eq);
     if (p1.first != ia+2 || p1.second != ic+2)
@@ -75,8 +75,8 @@
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
     const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
 
-    typedef input_iterator<const int*> II;
-    typedef random_access_iterator<const int*>  RAI;
+    typedef legacy_input_iterator<const int*> II;
+    typedef legacy_random_access_iterator<const int*>  RAI;
     typedef std::equal_to<int> EQ;
 
     assert(std::mismatch(II(ia), II(ia + sa), II(ib), EQ())
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp
@@ -30,7 +30,7 @@
 
 void test()
 {
-    typedef random_access_iterator<int *> RI;
+    typedef legacy_random_access_iterator<int *> RI;
     int i1[] = {0, 0};
     assert(std::is_heap(i1, i1));
     assert(std::is_heap(i1, i1+1) == (std::is_heap_until(i1, i1+1) == i1+1));
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp
@@ -31,7 +31,7 @@
 
 void test()
 {
-    typedef random_access_iterator<int *> RI;
+    typedef legacy_random_access_iterator<int *> RI;
     int i1[] = {0, 0};
     assert(std::is_heap(i1, i1, std::greater<int>()));
     assert(std::is_heap(i1, i1+1, std::greater<int>()) == (std::is_heap_until(i1, i1+1, std::greater<int>()) == i1+1));
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp
@@ -30,7 +30,7 @@
 
 void test()
 {
-    typedef random_access_iterator<int *> RI;
+    typedef legacy_random_access_iterator<int *> RI;
     int i1[] = {0, 0};
     assert(std::is_heap_until(i1, i1) == i1);
     assert(std::is_heap_until(i1, i1+1) == i1+1);
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
@@ -31,7 +31,7 @@
 
 void test()
 {
-    typedef random_access_iterator<int *> RI;
+    typedef legacy_random_access_iterator<int *> RI;
     int i1[] = {0, 0};
     assert(std::is_heap_until(i1, i1, std::greater<int>()) == i1);
     assert(std::is_heap_until(i1, i1+1, std::greater<int>()) == i1+1);
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp
@@ -47,18 +47,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -48,18 +48,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp
@@ -49,18 +49,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -49,18 +49,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp
@@ -46,18 +46,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp
@@ -46,18 +46,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp
@@ -51,18 +51,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -51,18 +51,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp
@@ -68,9 +68,9 @@
         for (int x = -1; x <= 7; ++x)
             test(d, e, x, (x % 2 == 0) && ((e-d)*2 > x));
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
@@ -69,9 +69,9 @@
         for (int x = -1; x <= 7; ++x)
             test(d, e, x, (x % 2 == 0) && e != d && (-2*(e-d) + 8 <= x));
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
@@ -76,9 +76,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
@@ -75,9 +75,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
@@ -71,9 +71,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
@@ -71,9 +71,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
@@ -68,9 +68,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
@@ -71,9 +71,9 @@
         for (int x = -1; x <= 4; ++x)
             test(d, e, x);
 
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp
@@ -48,34 +48,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
 
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
 
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
 
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
 
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
@@ -53,34 +53,34 @@
 
 int main(int, char**)
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
 
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
 
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
 
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
 
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -99,13 +99,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test<bidirectional_iterator<S*> >();
-    test<random_access_iterator<S*> >();
+    test<legacy_bidirectional_iterator<S*> >();
+    test<legacy_random_access_iterator<S*> >();
     test<S*>();
 #endif // TEST_STD_VER >= 11
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -137,13 +137,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 11
-    test<bidirectional_iterator<S*> >();
-    test<random_access_iterator<S*> >();
+    test<legacy_bidirectional_iterator<S*> >();
+    test<legacy_random_access_iterator<S*> >();
     test<S*>();
 
     {
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp
@@ -55,29 +55,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
@@ -56,29 +56,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp
@@ -74,9 +74,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     constexpr_test ();
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -93,9 +93,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp
@@ -74,9 +74,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     constexpr_test();
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -93,9 +93,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test_eq();
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
@@ -92,9 +92,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
    constexpr_test();
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -98,9 +98,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     constexpr_test();
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp
@@ -22,7 +22,7 @@
 int main(int, char**) {
   int arr[] = {1, 2, 3};
   const int *b = std::begin(arr), *e = std::end(arr);
-  typedef input_iterator<const int*> Iter;
+  typedef legacy_input_iterator<const int*> Iter;
   {
     // expected-error@algorithm:* {{"std::min_element requires a ForwardIterator"}}
     std::min_element(Iter(b), Iter(e));
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp
@@ -67,18 +67,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -68,18 +68,18 @@
 
 int main(int, char**)
 {
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp
@@ -61,13 +61,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
@@ -63,13 +63,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp
@@ -61,13 +61,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
@@ -63,13 +63,13 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<bidirectional_iterator<int*>>());
-    static_assert(test<random_access_iterator<int*>>());
+    static_assert(test<legacy_bidirectional_iterator<int*>>());
+    static_assert(test<legacy_random_access_iterator<int*>>());
     static_assert(test<int*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp
@@ -53,34 +53,34 @@
 TEST_CONSTEXPR_CXX20
 bool do_tests()
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
-
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
-
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
-
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
-
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
+
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
     return true;
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp
@@ -54,34 +54,34 @@
 TEST_CONSTEXPR_CXX20
 bool do_tests()
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
-
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
-
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
-
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
-
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
+
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
     return true;
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp
@@ -55,29 +55,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
@@ -56,29 +56,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp
@@ -53,29 +53,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
@@ -54,29 +54,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp
@@ -55,29 +55,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
@@ -56,29 +56,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp
@@ -55,29 +55,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
@@ -56,29 +56,29 @@
 TEST_CONSTEXPR_CXX20 void test3()
 {
     test4<T, Iter1, Iter2, output_iterator<T*> >();
-    test4<T, Iter1, Iter2, forward_iterator<T*> >();
-    test4<T, Iter1, Iter2, bidirectional_iterator<T*> >();
-    test4<T, Iter1, Iter2, random_access_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_forward_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_bidirectional_iterator<T*> >();
+    test4<T, Iter1, Iter2, legacy_random_access_iterator<T*> >();
     test4<T, Iter1, Iter2, T*>();
 }
 
 template<class T, class Iter1>
 TEST_CONSTEXPR_CXX20 void test2()
 {
-    test3<T, Iter1, input_iterator<const T*> >();
-    test3<T, Iter1, forward_iterator<const T*> >();
-    test3<T, Iter1, bidirectional_iterator<const T*> >();
-    test3<T, Iter1, random_access_iterator<const T*> >();
+    test3<T, Iter1, legacy_input_iterator<const T*> >();
+    test3<T, Iter1, legacy_forward_iterator<const T*> >();
+    test3<T, Iter1, legacy_bidirectional_iterator<const T*> >();
+    test3<T, Iter1, legacy_random_access_iterator<const T*> >();
     test3<T, Iter1, const T*>();
 }
 
 template<class T>
 TEST_CONSTEXPR_CXX20 void test1()
 {
-    test2<T, input_iterator<const T*> >();
-    test2<T, forward_iterator<const T*> >();
-    test2<T, bidirectional_iterator<const T*> >();
-    test2<T, random_access_iterator<const T*> >();
+    test2<T, legacy_input_iterator<const T*> >();
+    test2<T, legacy_forward_iterator<const T*> >();
+    test2<T, legacy_bidirectional_iterator<const T*> >();
+    test2<T, legacy_random_access_iterator<const T*> >();
     test2<T, const T*>();
 }
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp
@@ -185,9 +185,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
@@ -186,9 +186,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp
@@ -185,9 +185,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
@@ -186,9 +186,9 @@
 
 int main(int, char**)
 {
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp
@@ -68,26 +68,26 @@
     assert(i == 42);
     assert(j == 75);
 
-    test<int, random_access_iterator<int*>, random_access_iterator<int*> >();
-    test<int, random_access_iterator<int*>, int*>();
-    test<int, int*, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*>, legacy_random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*>, int*>();
+    test<int, int*, legacy_random_access_iterator<int*> >();
     test<int, int*, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<int*>, random_access_iterator<MoveOnly*>>();
-    test<MoveOnly, random_access_iterator<int*>, MoveOnly*>();
-    test<MoveOnly, int*, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<int*>, legacy_random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<int*>, MoveOnly*>();
+    test<MoveOnly, int*, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, int*, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>, random_access_iterator<int*>>());
-    static_assert(test<int, int*, random_access_iterator<int*>>());
-    static_assert(test<int, random_access_iterator<int*>, int*>());
+    static_assert(test<int, legacy_random_access_iterator<int*>, legacy_random_access_iterator<int*>>());
+    static_assert(test<int, int*, legacy_random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>, int*>());
     static_assert(test<int, int*, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<int*>, random_access_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, random_access_iterator<int*>, MoveOnly*>());
-    static_assert(test<MoveOnly, int*, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<int*>, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<int*>, MoveOnly*>());
+    static_assert(test<MoveOnly, int*, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, int*, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
@@ -71,26 +71,26 @@
     assert(i == 42);
     assert(j == 75);
 
-    test<int, random_access_iterator<int*>, random_access_iterator<int*> >();
-    test<int, random_access_iterator<int*>, int*>();
-    test<int, int*, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*>, legacy_random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*>, int*>();
+    test<int, int*, legacy_random_access_iterator<int*> >();
     test<int, int*, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<int*>, random_access_iterator<MoveOnly*>>();
-    test<MoveOnly, random_access_iterator<int*>, MoveOnly*>();
-    test<MoveOnly, int*, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<int*>, legacy_random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<int*>, MoveOnly*>();
+    test<MoveOnly, int*, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, int*, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>, random_access_iterator<int*>>());
-    static_assert(test<int, int*, random_access_iterator<int*>>());
-    static_assert(test<int, random_access_iterator<int*>, int*>());
+    static_assert(test<int, legacy_random_access_iterator<int*>, legacy_random_access_iterator<int*>>());
+    static_assert(test<int, int*, legacy_random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>, int*>());
     static_assert(test<int, int*, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<int*>, random_access_iterator<MoveOnly*>>());
-    static_assert(test<MoveOnly, random_access_iterator<int*>, MoveOnly*>());
-    static_assert(test<MoveOnly, int*, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<int*>, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<int*>, MoveOnly*>());
+    static_assert(test<MoveOnly, int*, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, int*, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp
@@ -55,18 +55,18 @@
     std::partial_sort(&i, &i, &i);  // no-op
     assert(i == 42);
 
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -57,18 +57,18 @@
     std::partial_sort(&i, &i, &i, std::greater<int>());  // no-op
     assert(i == 42);
 
-    test<int, random_access_iterator<int*> >();
+    test<int, legacy_random_access_iterator<int*> >();
     test<int, int*>();
 
 #if TEST_STD_VER >= 11
-    test<MoveOnly, random_access_iterator<MoveOnly*>>();
+    test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>();
     test<MoveOnly, MoveOnly*>();
 #endif
 
 #if TEST_STD_VER >= 20
-    static_assert(test<int, random_access_iterator<int*>>());
+    static_assert(test<int, legacy_random_access_iterator<int*>>());
     static_assert(test<int, int*>());
-    static_assert(test<MoveOnly, random_access_iterator<MoveOnly*>>());
+    static_assert(test<MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
     static_assert(test<MoveOnly, MoveOnly*>());
 #endif
 
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp
@@ -60,56 +60,56 @@
 int main(int, char**)
 {
     test<7, int, int*>();
-    test<7, int, random_access_iterator<int*> >();
+    test<7, int, legacy_random_access_iterator<int*> >();
     test<257, int, int*>();
-    test<257, int, random_access_iterator<int*> >();
+    test<257, int, legacy_random_access_iterator<int*> >();
 
 #if TEST_STD_VER >= 11
     test<7, MoveOnly, MoveOnly*>();
-    test<7, MoveOnly, random_access_iterator<MoveOnly*> >();
+    test<7, MoveOnly, legacy_random_access_iterator<MoveOnly*> >();
     test<257, MoveOnly, MoveOnly*>();
-    test<257, MoveOnly, random_access_iterator<MoveOnly*> >();
+    test<257, MoveOnly, legacy_random_access_iterator<MoveOnly*> >();
 #endif
 
     test_pointers<17, char, char**>();
-    test_pointers<17, char, random_access_iterator<char**> >();
+    test_pointers<17, char, legacy_random_access_iterator<char**> >();
     test_pointers<17, const char, const char**>();
-    test_pointers<17, const char, random_access_iterator<const char**> >();
+    test_pointers<17, const char, legacy_random_access_iterator<const char**> >();
     test_pointers<17, int, int**>();
-    test_pointers<17, int, random_access_iterator<int**> >();
+    test_pointers<17, int, legacy_random_access_iterator<int**> >();
 
 #if TEST_STD_VER >= 20
-    test<7, int, contiguous_iterator<int*>>();
-    test<257, int, contiguous_iterator<int*>>();
-    test<7, MoveOnly, contiguous_iterator<MoveOnly*>>();
-    test<257, MoveOnly, contiguous_iterator<MoveOnly*>>();
-    test_pointers<17, char, contiguous_iterator<char**>>();
-    test_pointers<17, const char, contiguous_iterator<const char**>>();
-    test_pointers<17, int, contiguous_iterator<int**>>();
+    test<7, int, legacy_contiguous_iterator<int*>>();
+    test<257, int, legacy_contiguous_iterator<int*>>();
+    test<7, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>();
+    test<257, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>();
+    test_pointers<17, char, legacy_contiguous_iterator<char**>>();
+    test_pointers<17, const char, legacy_contiguous_iterator<const char**>>();
+    test_pointers<17, int, legacy_contiguous_iterator<int**>>();
 
     static_assert(test<7, int, int*>());
-    static_assert(test<7, int, random_access_iterator<int*>>());
-    static_assert(test<7, int, contiguous_iterator<int*>>());
+    static_assert(test<7, int, legacy_random_access_iterator<int*>>());
+    static_assert(test<7, int, legacy_contiguous_iterator<int*>>());
     static_assert(test<257, int, int*>());
-    static_assert(test<257, int, random_access_iterator<int*>>());
-    static_assert(test<257, int, contiguous_iterator<int*>>());
+    static_assert(test<257, int, legacy_random_access_iterator<int*>>());
+    static_assert(test<257, int, legacy_contiguous_iterator<int*>>());
 
     static_assert(test<7, MoveOnly, MoveOnly*>());
-    static_assert(test<7, MoveOnly, random_access_iterator<MoveOnly*>>());
-    static_assert(test<7, MoveOnly, contiguous_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>());
     static_assert(test<257, MoveOnly, MoveOnly*>());
-    static_assert(test<257, MoveOnly, random_access_iterator<MoveOnly*>>());
-    static_assert(test<257, MoveOnly, contiguous_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>());
 
     static_assert(test_pointers<17, char, char**>());
-    static_assert(test_pointers<17, char, random_access_iterator<char**>>());
-    static_assert(test_pointers<17, char, contiguous_iterator<char**>>());
+    static_assert(test_pointers<17, char, legacy_random_access_iterator<char**>>());
+    static_assert(test_pointers<17, char, legacy_contiguous_iterator<char**>>());
     static_assert(test_pointers<17, const char, const char**>());
-    static_assert(test_pointers<17, const char, random_access_iterator<const char**>>());
-    static_assert(test_pointers<17, const char, contiguous_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, legacy_random_access_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, legacy_contiguous_iterator<const char**>>());
     static_assert(test_pointers<17, int, int**>());
-    static_assert(test_pointers<17, int, random_access_iterator<int**>>());
-    static_assert(test_pointers<17, int, contiguous_iterator<int**>>());
+    static_assert(test_pointers<17, int, legacy_random_access_iterator<int**>>());
+    static_assert(test_pointers<17, int, legacy_contiguous_iterator<int**>>());
 #endif
 
     return 0;
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp
--- a/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp
@@ -61,56 +61,56 @@
 int main(int, char**)
 {
     test<7, int, int*>();
-    test<7, int, random_access_iterator<int*> >();
+    test<7, int, legacy_random_access_iterator<int*> >();
     test<257, int, int*>();
-    test<257, int, random_access_iterator<int*> >();
+    test<257, int, legacy_random_access_iterator<int*> >();
 
 #if TEST_STD_VER >= 11
     test<7, MoveOnly, MoveOnly*>();
-    test<7, MoveOnly, random_access_iterator<MoveOnly*> >();
+    test<7, MoveOnly, legacy_random_access_iterator<MoveOnly*> >();
     test<257, MoveOnly, MoveOnly*>();
-    test<257, MoveOnly, random_access_iterator<MoveOnly*> >();
+    test<257, MoveOnly, legacy_random_access_iterator<MoveOnly*> >();
 #endif
 
     test_pointers<17, char, char**>();
-    test_pointers<17, char, random_access_iterator<char**> >();
+    test_pointers<17, char, legacy_random_access_iterator<char**> >();
     test_pointers<17, const char, const char**>();
-    test_pointers<17, const char, random_access_iterator<const char**> >();
+    test_pointers<17, const char, legacy_random_access_iterator<const char**> >();
     test_pointers<17, int, int**>();
-    test_pointers<17, int, random_access_iterator<int**> >();
+    test_pointers<17, int, legacy_random_access_iterator<int**> >();
 
 #if TEST_STD_VER >= 20
-    test<7, int, contiguous_iterator<int*>>();
-    test<257, int, contiguous_iterator<int*>>();
-    test<7, MoveOnly, contiguous_iterator<MoveOnly*>>();
-    test<257, MoveOnly, contiguous_iterator<MoveOnly*>>();
-    test_pointers<17, char, contiguous_iterator<char**>>();
-    test_pointers<17, const char, contiguous_iterator<const char**>>();
-    test_pointers<17, int, contiguous_iterator<int**>>();
+    test<7, int, legacy_contiguous_iterator<int*>>();
+    test<257, int, legacy_contiguous_iterator<int*>>();
+    test<7, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>();
+    test<257, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>();
+    test_pointers<17, char, legacy_contiguous_iterator<char**>>();
+    test_pointers<17, const char, legacy_contiguous_iterator<const char**>>();
+    test_pointers<17, int, legacy_contiguous_iterator<int**>>();
 
     static_assert(test<7, int, int*>());
-    static_assert(test<7, int, random_access_iterator<int*>>());
-    static_assert(test<7, int, contiguous_iterator<int*>>());
+    static_assert(test<7, int, legacy_random_access_iterator<int*>>());
+    static_assert(test<7, int, legacy_contiguous_iterator<int*>>());
     static_assert(test<257, int, int*>());
-    static_assert(test<257, int, random_access_iterator<int*>>());
-    static_assert(test<257, int, contiguous_iterator<int*>>());
+    static_assert(test<257, int, legacy_random_access_iterator<int*>>());
+    static_assert(test<257, int, legacy_contiguous_iterator<int*>>());
 
     static_assert(test<7, MoveOnly, MoveOnly*>());
-    static_assert(test<7, MoveOnly, random_access_iterator<MoveOnly*>>());
-    static_assert(test<7, MoveOnly, contiguous_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<7, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>());
     static_assert(test<257, MoveOnly, MoveOnly*>());
-    static_assert(test<257, MoveOnly, random_access_iterator<MoveOnly*>>());
-    static_assert(test<257, MoveOnly, contiguous_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, legacy_random_access_iterator<MoveOnly*>>());
+    static_assert(test<257, MoveOnly, legacy_contiguous_iterator<MoveOnly*>>());
 
     static_assert(test_pointers<17, char, char**>());
-    static_assert(test_pointers<17, char, random_access_iterator<char**>>());
-    static_assert(test_pointers<17, char, contiguous_iterator<char**>>());
+    static_assert(test_pointers<17, char, legacy_random_access_iterator<char**>>());
+    static_assert(test_pointers<17, char, legacy_contiguous_iterator<char**>>());
     static_assert(test_pointers<17, const char, const char**>());
-    static_assert(test_pointers<17, const char, random_access_iterator<const char**>>());
-    static_assert(test_pointers<17, const char, contiguous_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, legacy_random_access_iterator<const char**>>());
+    static_assert(test_pointers<17, const char, legacy_contiguous_iterator<const char**>>());
     static_assert(test_pointers<17, int, int**>());
-    static_assert(test_pointers<17, int, random_access_iterator<int**>>());
-    static_assert(test_pointers<17, int, contiguous_iterator<int**>>());
+    static_assert(test_pointers<17, int, legacy_random_access_iterator<int**>>());
+    static_assert(test_pointers<17, int, legacy_contiguous_iterator<int**>>());
 #endif
 
     return 0;
diff --git a/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp
@@ -38,7 +38,7 @@
             P(3, 2),
         };
         M m;
-        m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<P*>(ar), legacy_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 3);
         assert(m.begin()->first == 1);
         assert(m.begin()->second == 1);
@@ -64,7 +64,7 @@
             P(3, 2),
         };
         M m;
-        m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<P*>(ar), legacy_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 3);
         assert(m.begin()->first == 1);
         assert(m.begin()->second == 1);
diff --git a/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp
@@ -38,7 +38,7 @@
             P(3, 2),
         };
         M m;
-        m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<P*>(ar), legacy_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 9);
         assert(m.begin()->first == 1);
         assert(m.begin()->second == 1);
@@ -76,7 +76,7 @@
             P(3, 2),
         };
         M m;
-        m.insert(input_iterator<P*>(ar), input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<P*>(ar), legacy_input_iterator<P*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 9);
         assert(m.begin()->first == 1);
         assert(m.begin()->second == 1);
diff --git a/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp
@@ -38,8 +38,8 @@
             3
         };
         M m;
-        m.insert(input_iterator<const V*>(ar),
-                 input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<const V*>(ar),
+                 legacy_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
@@ -68,8 +68,8 @@
             3
         };
         M m;
-        m.insert(input_iterator<const V*>(ar),
-                 input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<const V*>(ar),
+                 legacy_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 9);
         assert(*next(m.begin(), 0) == 1);
         assert(*next(m.begin(), 1) == 1);
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp
@@ -36,8 +36,8 @@
         3,
         3
     };
-    std::multiset<V> m(input_iterator<const int*>(ar),
-                  input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+    std::multiset<V> m(legacy_input_iterator<const int*>(ar),
+                  legacy_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 9);
     assert(distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
@@ -65,8 +65,8 @@
         3,
         3
     };
-    std::multiset<V, std::less<V>, min_allocator<V>> m(input_iterator<const int*>(ar),
-                  input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+    std::multiset<V, std::less<V>, min_allocator<V>> m(legacy_input_iterator<const int*>(ar),
+                  legacy_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 9);
     assert(distance(m.begin(), m.end()) == 9);
     assert(*next(m.begin(), 0) == 1);
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp
@@ -40,8 +40,8 @@
     };
     typedef test_compare<std::less<V> > C;
     typedef test_allocator<V> A;
-    std::multiset<V, C, A> m(input_iterator<const V*>(ar),
-                        input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
+    std::multiset<V, C, A> m(legacy_input_iterator<const V*>(ar),
+                        legacy_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
                         C(5), A(7));
     assert(m.value_comp() == C(5));
     assert(m.get_allocator() == A(7));
diff --git a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp
@@ -36,8 +36,8 @@
         3
     };
     typedef test_compare<std::less<V> > C;
-    std::multiset<V, C> m(input_iterator<const V*>(ar),
-                     input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
+    std::multiset<V, C> m(legacy_input_iterator<const V*>(ar),
+                     legacy_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
     assert(m.size() == 9);
     assert(distance(m.begin(), m.end()) == 9);
diff --git a/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -38,8 +38,8 @@
             3
         };
         M m;
-        m.insert(input_iterator<const V*>(ar),
-                 input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<const V*>(ar),
+                 legacy_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
@@ -62,8 +62,8 @@
             3
         };
         M m;
-        m.insert(input_iterator<const V*>(ar),
-                 input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
+        m.insert(legacy_input_iterator<const V*>(ar),
+                 legacy_input_iterator<const V*>(ar + sizeof(ar)/sizeof(ar[0])));
         assert(m.size() == 3);
         assert(*m.begin() == 1);
         assert(*next(m.begin()) == 2);
diff --git a/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp
@@ -36,8 +36,8 @@
         3,
         3
     };
-    std::set<V> m(input_iterator<const int*>(ar),
-                  input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+    std::set<V> m(legacy_input_iterator<const int*>(ar),
+                  legacy_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 3);
     assert(distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
@@ -59,8 +59,8 @@
         3,
         3
     };
-    std::set<V, std::less<int>, min_allocator<int>> m(input_iterator<const int*>(ar),
-                  input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
+    std::set<V, std::less<int>, min_allocator<int>> m(legacy_input_iterator<const int*>(ar),
+                  legacy_input_iterator<const int*>(ar+sizeof(ar)/sizeof(ar[0])));
     assert(m.size() == 3);
     assert(distance(m.begin(), m.end()) == 3);
     assert(*m.begin() == 1);
diff --git a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp
@@ -44,8 +44,8 @@
     };
     typedef test_compare<std::less<V> > C;
     typedef test_allocator<V> A;
-    std::set<V, C, A> m(input_iterator<const V*>(ar),
-                        input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
+    std::set<V, C, A> m(legacy_input_iterator<const V*>(ar),
+                        legacy_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])),
                         C(5), A(7));
     assert(m.value_comp() == C(5));
     assert(m.get_allocator() == A(7));
diff --git a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
--- a/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
+++ b/libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp
@@ -36,8 +36,8 @@
         3
     };
     typedef test_compare<std::less<V> > C;
-    std::set<V, C> m(input_iterator<const V*>(ar),
-                     input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
+    std::set<V, C> m(legacy_input_iterator<const V*>(ar),
+                     legacy_input_iterator<const V*>(ar+sizeof(ar)/sizeof(ar[0])), C(5));
     assert(m.value_comp() == C(5));
     assert(m.size() == 3);
     assert(distance(m.begin(), m.end()) == 3);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp
@@ -67,7 +67,7 @@
 testI(C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
-    typedef input_iterator<CI> ICI;
+    typedef legacy_input_iterator<CI> ICI;
     c1.assign(ICI(c2.begin()), ICI(c2.end()));
     assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
     assert(c1 == c2);
@@ -112,7 +112,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleMoveableAndAssignable<int>;
-    using It = random_access_iterator<int*>;
+    using It = legacy_random_access_iterator<int*>;
     {
       std::deque<T> v;
       v.assign(It(arr1), It(std::end(arr1)));
@@ -128,7 +128,7 @@
   }
   {
     using T = EmplaceConstructibleMoveableAndAssignable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       std::deque<T> v;
       v.assign(It(arr1), It(std::end(arr1)));
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp
@@ -55,10 +55,10 @@
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);
-    test(input_iterator<const int*>(ab), input_iterator<const int*>(an));
-    test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an));
-    test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an));
-    test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an));
+    test(legacy_input_iterator<const int*>(ab), legacy_input_iterator<const int*>(an));
+    test(legacy_forward_iterator<const int*>(ab), legacy_forward_iterator<const int*>(an));
+    test(legacy_bidirectional_iterator<const int*>(ab), legacy_bidirectional_iterator<const int*>(an));
+    test(legacy_random_access_iterator<const int*>(ab), legacy_random_access_iterator<const int*>(an));
     test<limited_allocator<int, 4096> >(ab, an);
 #if TEST_STD_VER >= 11
     test<min_allocator<int> >(ab, an);
@@ -72,7 +72,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleAndMoveable<int>;
-    using It = random_access_iterator<int*>;
+    using It = legacy_random_access_iterator<int*>;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)));
       assert(v[0].value == 42);
@@ -86,7 +86,7 @@
   }
   {
     using T = EmplaceConstructibleAndMoveable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)));
       assert(v[0].copied == 0);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp
@@ -42,15 +42,15 @@
 {
     int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
     int* an = ab + sizeof(ab)/sizeof(ab[0]);
-    test(input_iterator<const int*>(ab), input_iterator<const int*>(an), test_allocator<int>(3));
-    test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), test_allocator<int>(4));
-    test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), test_allocator<int>(5));
-    test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), test_allocator<int>(6));
+    test(legacy_input_iterator<const int*>(ab), legacy_input_iterator<const int*>(an), test_allocator<int>(3));
+    test(legacy_forward_iterator<const int*>(ab), legacy_forward_iterator<const int*>(an), test_allocator<int>(4));
+    test(legacy_bidirectional_iterator<const int*>(ab), legacy_bidirectional_iterator<const int*>(an), test_allocator<int>(5));
+    test(legacy_random_access_iterator<const int*>(ab), legacy_random_access_iterator<const int*>(an), test_allocator<int>(6));
 #if TEST_STD_VER >= 11
-    test(input_iterator<const int*>(ab), input_iterator<const int*>(an), min_allocator<int>());
-    test(forward_iterator<const int*>(ab), forward_iterator<const int*>(an), min_allocator<int>());
-    test(bidirectional_iterator<const int*>(ab), bidirectional_iterator<const int*>(an), min_allocator<int>());
-    test(random_access_iterator<const int*>(ab), random_access_iterator<const int*>(an), min_allocator<int>());
+    test(legacy_input_iterator<const int*>(ab), legacy_input_iterator<const int*>(an), min_allocator<int>());
+    test(legacy_forward_iterator<const int*>(ab), legacy_forward_iterator<const int*>(an), min_allocator<int>());
+    test(legacy_bidirectional_iterator<const int*>(ab), legacy_bidirectional_iterator<const int*>(an), min_allocator<int>());
+    test(legacy_random_access_iterator<const int*>(ab), legacy_random_access_iterator<const int*>(an), min_allocator<int>());
 #endif
 }
 
@@ -61,7 +61,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleAndMoveable<int>;
-    using It = random_access_iterator<int*>;
+    using It = legacy_random_access_iterator<int*>;
     std::allocator<T> a;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)), a);
@@ -76,7 +76,7 @@
   }
   {
     using T = EmplaceConstructibleAndMoveable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     std::allocator<T> a;
     {
       std::deque<T> v(It(arr1), It(std::end(arr1)), a);
diff --git a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp
@@ -51,7 +51,7 @@
 {
     {
     typedef typename C::const_iterator CI;
-    typedef input_iterator<CI> BCI;
+    typedef legacy_input_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
@@ -68,7 +68,7 @@
     }
     {
     typedef typename C::const_iterator CI;
-    typedef forward_iterator<CI> BCI;
+    typedef legacy_forward_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
@@ -85,7 +85,7 @@
     }
     {
     typedef typename C::const_iterator CI;
-    typedef bidirectional_iterator<CI> BCI;
+    typedef legacy_bidirectional_iterator<CI> BCI;
     C c1 = c0;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
@@ -167,7 +167,7 @@
 testI(int P, C& c1, const C& c2)
 {
     typedef typename C::const_iterator CI;
-    typedef input_iterator<CI> ICI;
+    typedef legacy_input_iterator<CI> ICI;
     std::size_t c1_osize = c1.size();
     CI i = c1.insert(c1.begin() + P, ICI(c2.begin()), ICI(c2.end()));
     assert(i == c1.begin() + P);
@@ -250,7 +250,7 @@
         assert(*i == MoveOnly(j));
     {
         MoveOnly mo(1);
-        typedef input_iterator<MoveOnly*> I;
+        typedef legacy_input_iterator<MoveOnly*> I;
         c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1)));
     }
     j = 0;
diff --git a/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp
@@ -48,9 +48,9 @@
 {
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
-    typedef random_access_iterator<I> RAI;
-    typedef random_access_iterator<CI> RACI;
-    typedef input_iterator<CI> ICI;
+    typedef legacy_random_access_iterator<I> RAI;
+    typedef legacy_random_access_iterator<CI> RACI;
+    typedef legacy_input_iterator<CI> ICI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::copy(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
diff --git a/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp
@@ -48,8 +48,8 @@
 {
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
-    typedef random_access_iterator<I> RAI;
-    typedef random_access_iterator<CI> RACI;
+    typedef legacy_random_access_iterator<I> RAI;
+    typedef legacy_random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::copy_backward(c1.cbegin(), c1.cend(), c2.end()) == c2.begin());
diff --git a/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp
@@ -48,8 +48,8 @@
 {
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
-    typedef random_access_iterator<I> RAI;
-    typedef random_access_iterator<CI> RACI;
+    typedef legacy_random_access_iterator<I> RAI;
+    typedef legacy_random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::move(c1.cbegin(), c1.cend(), c2.begin()) == c2.end());
diff --git a/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp b/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp
@@ -48,8 +48,8 @@
 {
     typedef typename C::iterator I;
     typedef typename C::const_iterator CI;
-    typedef random_access_iterator<I> RAI;
-    typedef random_access_iterator<CI> RACI;
+    typedef legacy_random_access_iterator<I> RAI;
+    typedef legacy_random_access_iterator<CI> RACI;
     C c1 = make<C>(N, start);
     C c2 = make<C>(N);
     assert(std::move_backward(c1.cbegin(), c1.cend(), c2.end()) == c2.begin());
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp
@@ -27,7 +27,7 @@
         const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         const T t1[] = {10, 11, 12, 13};
         C c(std::begin(t1), std::end(t1));
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         c.assign(I(std::begin(t0)), I(std::end(t0)));
         int n = 0;
         for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
@@ -40,7 +40,7 @@
         const T t0[] = {10, 11, 12, 13};
         const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t1), std::end(t1));
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         c.assign(I(std::begin(t0)), I(std::end(t0)));
         int n = 0;
         for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
@@ -54,7 +54,7 @@
         const T t0[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         const T t1[] = {10, 11, 12, 13};
         C c(std::begin(t1), std::end(t1));
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         c.assign(I(std::begin(t0)), I(std::end(t0)));
         int n = 0;
         for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, ++n)
@@ -67,7 +67,7 @@
         const T t0[] = {10, 11, 12, 13};
         const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(std::begin(t1), std::end(t1));
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         c.assign(I(std::begin(t0)), I(std::end(t0)));
         int n = 0;
         for (C::const_iterator i = c.cbegin(); i != c.cend(); ++i, (void) ++n)
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp
@@ -24,7 +24,7 @@
     {
         typedef int T;
         typedef std::forward_list<T> C;
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(I(std::begin(t)), I(std::end(t)));
         int n = 0;
@@ -36,7 +36,7 @@
     {
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(I(std::begin(t)), I(std::end(t)));
         int n = 0;
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp
@@ -27,7 +27,7 @@
         typedef int T;
         typedef test_allocator<T> A;
         typedef std::forward_list<T, A> C;
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(I(std::begin(t)), I(std::end(t)), A(13));
         int n = 0;
@@ -41,7 +41,7 @@
         typedef int T;
         typedef min_allocator<T> A;
         typedef std::forward_list<T, A> C;
-        typedef input_iterator<const T*> I;
+        typedef legacy_input_iterator<const T*> I;
         const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
         C c(I(std::begin(t)), I(std::end(t)), A());
         int n = 0;
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
--- a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
+++ b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp
@@ -25,7 +25,7 @@
         typedef int T;
         typedef std::forward_list<T> C;
         typedef C::iterator I;
-        typedef input_iterator<const T*> J;
+        typedef legacy_input_iterator<const T*> J;
         C c;
         const T t[] = {0, 1, 2, 3, 4};
         I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
@@ -53,7 +53,7 @@
         typedef int T;
         typedef std::forward_list<T, min_allocator<T>> C;
         typedef C::iterator I;
-        typedef input_iterator<const T*> J;
+        typedef legacy_input_iterator<const T*> J;
         C c;
         const T t[] = {0, 1, 2, 3, 4};
         I i = c.insert_after(c.cbefore_begin(), J(t), J(t));
diff --git a/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
--- a/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
+++ b/libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
@@ -26,8 +26,8 @@
 {
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int> l(input_iterator<const int*>(a),
-                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+        std::list<int> l(legacy_input_iterator<const int*>(a),
+                         legacy_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
@@ -36,8 +36,8 @@
     }
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int> l(input_iterator<const int*>(a),
-                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
+        std::list<int> l(legacy_input_iterator<const int*>(a),
+                         legacy_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
                          std::allocator<int>());
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
@@ -48,8 +48,8 @@
     {
         int a[] = {0, 1, 2, 3};
         // Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
-        std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(input_iterator<const int*>(a),
-                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+        std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(legacy_input_iterator<const int*>(a),
+                         legacy_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
@@ -59,8 +59,8 @@
 #if TEST_STD_VER >= 11
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
-                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
+        std::list<int, min_allocator<int>> l(legacy_input_iterator<const int*>(a),
+                         legacy_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
@@ -69,8 +69,8 @@
     }
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
-                         input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
+        std::list<int, min_allocator<int>> l(legacy_input_iterator<const int*>(a),
+                         legacy_input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
                          min_allocator<int>());
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
@@ -89,7 +89,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
-    using It = random_access_iterator<int*>;
+    using It = legacy_random_access_iterator<int*>;
     {
       std::list<T> v(It(arr1), It(std::end(arr1)));
       auto I = v.begin();
@@ -107,7 +107,7 @@
   }
   {
     using T = EmplaceConstructible<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       std::list<T> v(It(arr1), It(std::end(arr1)));
       auto I = v.begin();
@@ -136,7 +136,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
-    using It = random_access_iterator<int*>;
+    using It = legacy_random_access_iterator<int*>;
     std::allocator<T> a;
     {
       std::list<T> v(It(arr1), It(std::end(arr1)), a);
@@ -155,7 +155,7 @@
   }
   {
     using T = EmplaceConstructible<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     std::allocator<T> a;
     {
       std::list<T> v(It(arr1), It(std::end(arr1)), a);
@@ -183,7 +183,7 @@
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::list<>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)));
@@ -195,7 +195,7 @@
   }
   {
     using C = TCT::list<>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)));
@@ -214,7 +214,7 @@
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::list<>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
@@ -228,7 +228,7 @@
   }
   {
     using C = TCT::list<>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
diff --git a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp
@@ -34,16 +34,16 @@
 {
     bool a[] = {0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0};
     bool* an = a + sizeof(a)/sizeof(a[0]);
-    test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
-    test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
-    test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
-    test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
+    test<std::vector<bool> >(legacy_input_iterator<const bool*>(a), legacy_input_iterator<const bool*>(an));
+    test<std::vector<bool> >(legacy_forward_iterator<const bool*>(a), legacy_forward_iterator<const bool*>(an));
+    test<std::vector<bool> >(legacy_bidirectional_iterator<const bool*>(a), legacy_bidirectional_iterator<const bool*>(an));
+    test<std::vector<bool> >(legacy_random_access_iterator<const bool*>(a), legacy_random_access_iterator<const bool*>(an));
     test<std::vector<bool> >(a, an);
 #if TEST_STD_VER >= 11
-    test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an));
-    test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an));
-    test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an));
-    test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an));
+    test<std::vector<bool, min_allocator<bool>> >(legacy_input_iterator<const bool*>(a), legacy_input_iterator<const bool*>(an));
+    test<std::vector<bool, min_allocator<bool>> >(legacy_forward_iterator<const bool*>(a), legacy_forward_iterator<const bool*>(an));
+    test<std::vector<bool, min_allocator<bool>> >(legacy_bidirectional_iterator<const bool*>(a), legacy_bidirectional_iterator<const bool*>(an));
+    test<std::vector<bool, min_allocator<bool>> >(legacy_random_access_iterator<const bool*>(a), legacy_random_access_iterator<const bool*>(an));
     test<std::vector<bool, min_allocator<bool>> >(a, an);
 #endif
 
diff --git a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp
@@ -37,19 +37,19 @@
     bool* an = a + sizeof(a)/sizeof(a[0]);
     {
     std::allocator<bool> alloc;
-    test<std::vector<bool> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
-    test<std::vector<bool> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
-    test<std::vector<bool> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
-    test<std::vector<bool> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
+    test<std::vector<bool> >(legacy_input_iterator<const bool*>(a), legacy_input_iterator<const bool*>(an), alloc);
+    test<std::vector<bool> >(legacy_forward_iterator<const bool*>(a), legacy_forward_iterator<const bool*>(an), alloc);
+    test<std::vector<bool> >(legacy_bidirectional_iterator<const bool*>(a), legacy_bidirectional_iterator<const bool*>(an), alloc);
+    test<std::vector<bool> >(legacy_random_access_iterator<const bool*>(a), legacy_random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool> >(a, an, alloc);
     }
 #if TEST_STD_VER >= 11
     {
     min_allocator<bool> alloc;
-    test<std::vector<bool, min_allocator<bool>> >(input_iterator<const bool*>(a), input_iterator<const bool*>(an), alloc);
-    test<std::vector<bool, min_allocator<bool>> >(forward_iterator<const bool*>(a), forward_iterator<const bool*>(an), alloc);
-    test<std::vector<bool, min_allocator<bool>> >(bidirectional_iterator<const bool*>(a), bidirectional_iterator<const bool*>(an), alloc);
-    test<std::vector<bool, min_allocator<bool>> >(random_access_iterator<const bool*>(a), random_access_iterator<const bool*>(an), alloc);
+    test<std::vector<bool, min_allocator<bool>> >(legacy_input_iterator<const bool*>(a), legacy_input_iterator<const bool*>(an), alloc);
+    test<std::vector<bool, min_allocator<bool>> >(legacy_forward_iterator<const bool*>(a), legacy_forward_iterator<const bool*>(an), alloc);
+    test<std::vector<bool, min_allocator<bool>> >(legacy_bidirectional_iterator<const bool*>(a), legacy_bidirectional_iterator<const bool*>(an), alloc);
+    test<std::vector<bool, min_allocator<bool>> >(legacy_random_access_iterator<const bool*>(a), legacy_random_access_iterator<const bool*>(an), alloc);
     test<std::vector<bool, min_allocator<bool>> >(a, an, alloc);
     }
 #endif
diff --git a/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
@@ -26,8 +26,8 @@
         std::vector<bool> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
-                                        input_iterator<const bool*>(a+N));
+        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, legacy_input_iterator<const bool*>(a),
+                                        legacy_input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -42,8 +42,8 @@
         std::vector<bool> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
-                                        forward_iterator<const bool*>(a+N));
+        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const bool*>(a),
+                                        legacy_forward_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
         int j;
@@ -60,8 +60,8 @@
         size_t sz = v.size();
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
-                                        forward_iterator<const bool*>(a+N));
+        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const bool*>(a),
+                                        legacy_forward_iterator<const bool*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -79,8 +79,8 @@
         size_t sz = v.size();
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
-                                        forward_iterator<const bool*>(a+N));
+        std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const bool*>(a),
+                                        legacy_forward_iterator<const bool*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -96,8 +96,8 @@
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
-                                        input_iterator<const bool*>(a+N));
+        std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, legacy_input_iterator<const bool*>(a),
+                                        legacy_input_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -112,8 +112,8 @@
         std::vector<bool, min_allocator<bool>> v(100);
         bool a[] = {1, 0, 0, 1, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
-                                        forward_iterator<const bool*>(a+N));
+        std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const bool*>(a),
+                                        legacy_forward_iterator<const bool*>(a+N));
         assert(v.size() == 100 + N);
         assert(i == v.begin() + 10);
         std::size_t j;
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp
@@ -29,7 +29,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructibleMoveableAndAssignable<int>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     {
       std::vector<T> v;
       v.assign(It(arr1), It(std::end(arr1)));
@@ -45,7 +45,7 @@
   }
   {
     using T = EmplaceConstructibleMoveableAndAssignable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       std::vector<T> v;
       v.assign(It(arr1), It(std::end(arr1)));
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -38,39 +38,39 @@
 static void basic_test_cases() {
   int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
   int* an = a + sizeof(a) / sizeof(a[0]);
-  test<std::vector<int> >(input_iterator<const int*>(a),
-                          input_iterator<const int*>(an));
-  test<std::vector<int> >(forward_iterator<const int*>(a),
-                          forward_iterator<const int*>(an));
-  test<std::vector<int> >(bidirectional_iterator<const int*>(a),
-                          bidirectional_iterator<const int*>(an));
-  test<std::vector<int> >(random_access_iterator<const int*>(a),
-                          random_access_iterator<const int*>(an));
+  test<std::vector<int> >(legacy_input_iterator<const int*>(a),
+                          legacy_input_iterator<const int*>(an));
+  test<std::vector<int> >(legacy_forward_iterator<const int*>(a),
+                          legacy_forward_iterator<const int*>(an));
+  test<std::vector<int> >(legacy_bidirectional_iterator<const int*>(a),
+                          legacy_bidirectional_iterator<const int*>(an));
+  test<std::vector<int> >(legacy_random_access_iterator<const int*>(a),
+                          legacy_random_access_iterator<const int*>(an));
   test<std::vector<int> >(a, an);
 
   test<std::vector<int, limited_allocator<int, 63> > >(
-      input_iterator<const int*>(a), input_iterator<const int*>(an));
+      legacy_input_iterator<const int*>(a), legacy_input_iterator<const int*>(an));
   // Add 1 for implementations that dynamically allocate a container proxy.
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(
-      forward_iterator<const int*>(a), forward_iterator<const int*>(an));
+      legacy_forward_iterator<const int*>(a), legacy_forward_iterator<const int*>(an));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(
-      bidirectional_iterator<const int*>(a),
-      bidirectional_iterator<const int*>(an));
+      legacy_bidirectional_iterator<const int*>(a),
+      legacy_bidirectional_iterator<const int*>(an));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(
-      random_access_iterator<const int*>(a),
-      random_access_iterator<const int*>(an));
+      legacy_random_access_iterator<const int*>(a),
+      legacy_random_access_iterator<const int*>(an));
   test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
 #if TEST_STD_VER >= 11
-  test<std::vector<int, min_allocator<int> > >(input_iterator<const int*>(a),
-                                               input_iterator<const int*>(an));
+  test<std::vector<int, min_allocator<int> > >(legacy_input_iterator<const int*>(a),
+                                               legacy_input_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
-      forward_iterator<const int*>(a), forward_iterator<const int*>(an));
+      legacy_forward_iterator<const int*>(a), legacy_forward_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
-      bidirectional_iterator<const int*>(a),
-      bidirectional_iterator<const int*>(an));
+      legacy_bidirectional_iterator<const int*>(a),
+      legacy_bidirectional_iterator<const int*>(an));
   test<std::vector<int, min_allocator<int> > >(
-      random_access_iterator<const int*>(a),
-      random_access_iterator<const int*>(an));
+      legacy_random_access_iterator<const int*>(a),
+      legacy_random_access_iterator<const int*>(an));
   test<std::vector<int> >(a, an);
 #endif
 }
@@ -81,7 +81,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     {
       std::vector<T> v(It(arr1), It(std::end(arr1)));
       assert(v[0].value == 42);
@@ -95,7 +95,7 @@
   }
   {
     using T = EmplaceConstructibleAndMoveInsertable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       std::vector<T> v(It(arr1), It(std::end(arr1)));
       assert(v[0].copied == 0);
@@ -120,7 +120,7 @@
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::vector<>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)));
@@ -132,7 +132,7 @@
   }
   {
     using C = TCT::vector<>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     {
       ExpectConstructGuard<int&> G(1);
       C v(It(arr1), It(std::end(arr1)));
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp
@@ -54,14 +54,14 @@
     int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
     int* an = a + sizeof(a) / sizeof(a[0]);
     std::allocator<int> alloc;
-    test<std::vector<int> >(input_iterator<const int*>(a),
-                            input_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(forward_iterator<const int*>(a),
-                            forward_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(bidirectional_iterator<const int*>(a),
-                            bidirectional_iterator<const int*>(an), alloc);
-    test<std::vector<int> >(random_access_iterator<const int*>(a),
-                            random_access_iterator<const int*>(an), alloc);
+    test<std::vector<int> >(legacy_input_iterator<const int*>(a),
+                            legacy_input_iterator<const int*>(an), alloc);
+    test<std::vector<int> >(legacy_forward_iterator<const int*>(a),
+                            legacy_forward_iterator<const int*>(an), alloc);
+    test<std::vector<int> >(legacy_bidirectional_iterator<const int*>(a),
+                            legacy_bidirectional_iterator<const int*>(an), alloc);
+    test<std::vector<int> >(legacy_random_access_iterator<const int*>(a),
+                            legacy_random_access_iterator<const int*>(an), alloc);
     test<std::vector<int> >(a, an, alloc);
   }
 #if TEST_STD_VER >= 11
@@ -70,16 +70,16 @@
     int* an = a + sizeof(a) / sizeof(a[0]);
     min_allocator<int> alloc;
     test<std::vector<int, min_allocator<int> > >(
-        input_iterator<const int*>(a), input_iterator<const int*>(an), alloc);
+        legacy_input_iterator<const int*>(a), legacy_input_iterator<const int*>(an), alloc);
     test<std::vector<int, min_allocator<int> > >(
-        forward_iterator<const int*>(a), forward_iterator<const int*>(an),
+        legacy_forward_iterator<const int*>(a), legacy_forward_iterator<const int*>(an),
         alloc);
     test<std::vector<int, min_allocator<int> > >(
-        bidirectional_iterator<const int*>(a),
-        bidirectional_iterator<const int*>(an), alloc);
+        legacy_bidirectional_iterator<const int*>(a),
+        legacy_bidirectional_iterator<const int*>(an), alloc);
     test<std::vector<int, min_allocator<int> > >(
-        random_access_iterator<const int*>(a),
-        random_access_iterator<const int*>(an), alloc);
+        legacy_random_access_iterator<const int*>(a),
+        legacy_random_access_iterator<const int*>(an), alloc);
     test<std::vector<int, min_allocator<int> > >(a, an, alloc);
     test<std::vector<int, implicit_conv_allocator<int> > >(a, an, nullptr);
   }
@@ -92,7 +92,7 @@
   int arr2[] = {1, 101, 42};
   {
     using T = EmplaceConstructible<int>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     using Alloc = std::allocator<T>;
     Alloc a;
     {
@@ -108,7 +108,7 @@
   }
   {
     using T = EmplaceConstructibleAndMoveInsertable<int>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     using Alloc = std::allocator<T>;
     Alloc a;
     {
@@ -133,7 +133,7 @@
   int arr2[] = {1, 101, 42};
   {
     using C = TCT::vector<>;
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
@@ -147,7 +147,7 @@
   }
   {
     using C = TCT::vector<>;
-    using It = input_iterator<int*>;
+    using It = legacy_input_iterator<int*>;
     using Alloc = typename C::allocator_type;
     Alloc a;
     {
diff --git a/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
@@ -33,8 +33,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
-                                 input_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_input_iterator<const int*>(a),
+                                 legacy_input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -51,8 +51,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
-                                 forward_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const int*>(a),
+                                 legacy_forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -71,8 +71,8 @@
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
-                                 forward_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const int*>(a),
+                                 legacy_forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -90,8 +90,8 @@
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
-                                 forward_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const int*>(a),
+                                 legacy_forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
@@ -107,8 +107,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
-                                 input_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_input_iterator<const int*>(a),
+                                 legacy_input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -125,8 +125,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
-                                 forward_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const int*>(a),
+                                 legacy_forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -144,8 +144,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
-                                 input_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_input_iterator<const int*>(a),
+                                 legacy_input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -162,8 +162,8 @@
         V v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        V::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
-                                 forward_iterator<const int*>(a+N));
+        V::iterator i = v.insert(v.cbegin() + 10, legacy_forward_iterator<const int*>(a),
+                                 legacy_forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
@@ -179,7 +179,7 @@
 
     {
         std::vector<adl::S> s;
-        s.insert(s.end(), input_iterator<adl::S*>(), input_iterator<adl::S*>());
+        s.insert(s.end(), legacy_input_iterator<adl::S*>(), legacy_input_iterator<adl::S*>());
     }
 
   return 0;
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -48,7 +48,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
@@ -82,7 +82,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
@@ -116,7 +116,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14);
+        C c(legacy_input_iterator<P*>(arr), legacy_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14);
         assert(c.bucket_count() >= 14);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
@@ -150,7 +150,7 @@
         };
         HF hf(42);
         A a(43);
-        C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a);
+        C c(legacy_input_iterator<P*>(arr), legacy_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, hf, a);
         assert(c.bucket_count() >= 14);
         assert(c.size() == 4);
         assert(c.at(1) == "one");
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -48,7 +48,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             10
            );
         LIBCPP_ASSERT(c.bucket_count() == 11);
@@ -84,7 +84,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             10
            );
         LIBCPP_ASSERT(c.bucket_count() == 11);
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -49,7 +49,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
@@ -86,7 +86,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -49,7 +49,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
@@ -87,7 +87,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -50,7 +50,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -89,7 +89,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -128,7 +128,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
diff --git a/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp
@@ -38,7 +38,7 @@
             P(2, "four"),
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
@@ -60,7 +60,7 @@
             P(2, "four"),
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 4);
         assert(c.at(1) == "one");
         assert(c.at(2) == "two");
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -50,7 +50,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
@@ -101,7 +101,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
@@ -153,7 +153,7 @@
             P(2, "four"),
         };
          A a(42);
-       C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
+       C c(legacy_input_iterator<P*>(arr), legacy_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 14, a);
         assert(c.bucket_count() >= 14);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
@@ -206,7 +206,7 @@
         };
         A a(42);
         HF hf (43);
-        C c(input_iterator<P*>(arr), input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
+        C c(legacy_input_iterator<P*>(arr), legacy_input_iterator<P*>(arr + sizeof(arr)/sizeof(arr[0])), 12, hf, a );
         assert(c.bucket_count() >= 12);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -50,7 +50,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             10
            );
         LIBCPP_ASSERT(c.bucket_count() == 11);
@@ -103,7 +103,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             10
            );
         LIBCPP_ASSERT(c.bucket_count() == 11);
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -51,7 +51,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
@@ -105,7 +105,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -51,7 +51,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
@@ -106,7 +106,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -52,7 +52,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -108,7 +108,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -164,7 +164,7 @@
             P(1, "four"),
             P(2, "four"),
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
diff --git a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp
@@ -41,7 +41,7 @@
             P(2, "four"),
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 6);
         typedef std::pair<C::iterator, C::iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -83,7 +83,7 @@
             P(2, "four"),
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 6);
         typedef std::pair<C::iterator, C::iterator> Eq;
         Eq eq = c.equal_range(1);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp
@@ -37,7 +37,7 @@
             P(2)
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -59,7 +59,7 @@
             P(2)
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp
@@ -46,7 +46,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
@@ -79,7 +79,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
@@ -112,7 +112,7 @@
             T(2)
         };
         A a(42);
-        C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
+        C c(legacy_input_iterator<T*>(arr), legacy_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
         assert(c.bucket_count() >= 12);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
@@ -146,7 +146,7 @@
         };
         HF hf(43);
         A a(42);
-        C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
+        C c(legacy_input_iterator<T*>(arr), legacy_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
         assert(c.bucket_count() >= 16);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
@@ -46,7 +46,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -81,7 +81,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
@@ -47,7 +47,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
@@ -83,7 +83,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
@@ -47,7 +47,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
@@ -84,7 +84,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
diff --git a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -48,7 +48,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -86,7 +86,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
diff --git a/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp
@@ -37,7 +37,7 @@
             P(2)
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -59,7 +59,7 @@
             P(2)
         };
         C c;
-        c.insert(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        c.insert(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp
@@ -46,7 +46,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
@@ -79,7 +79,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])));
         assert(c.bucket_count() >= 5);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
@@ -112,7 +112,7 @@
             T(2)
         };
         A a(42);
-        C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
+        C c(legacy_input_iterator<T*>(arr), legacy_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 12, a);
         assert(c.bucket_count() >= 12);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
@@ -146,7 +146,7 @@
         };
         HF hf(43);
         A a(42);
-        C c(input_iterator<T*>(arr), input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
+        C c(legacy_input_iterator<T*>(arr), legacy_input_iterator<T*>(arr + sizeof(arr)/sizeof(arr[0])), 16, hf, a);
         assert(c.bucket_count() >= 16);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
@@ -46,7 +46,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
@@ -81,7 +81,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
         LIBCPP_ASSERT(c.bucket_count() == 7);
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
@@ -47,7 +47,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
@@ -83,7 +83,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8)
            );
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
@@ -47,7 +47,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
@@ -84,7 +84,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9)
diff --git a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
--- a/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ b/libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -48,7 +48,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
@@ -86,7 +86,7 @@
             P(1),
             P(2)
         };
-        C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
+        C c(legacy_input_iterator<P*>(a), legacy_input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7,
             test_hash<std::hash<int> >(8),
             test_compare<std::equal_to<int> >(9),
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp
@@ -123,8 +123,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -119,8 +119,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -137,8 +137,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp
@@ -128,8 +128,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp
@@ -123,8 +123,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -118,8 +118,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -131,8 +131,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp
@@ -125,8 +125,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp
@@ -84,15 +84,15 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp
@@ -91,15 +91,15 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp
@@ -69,15 +69,15 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
--- a/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
+++ b/libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp
@@ -76,15 +76,15 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp b/libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
--- a/libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
+++ b/libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -75,12 +75,12 @@
 
     test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
     test('x',  ints,  ints+10, "10x11x12x13x14x15x16x17x18x19");
-    test('X', input_iterator<const char*>(chars),         input_iterator<const char*>(chars+10),         "0X1X2X3X4X5X6X7X8X9");
-    test('x', input_iterator<const int*>(ints),           input_iterator<const int*>(ints+10),           "10x11x12x13x14x15x16x17x18x19");
-    test('X', forward_iterator<const char*>(chars),       forward_iterator<const char*>(chars+10),       "0X1X2X3X4X5X6X7X8X9");
-    test('x', forward_iterator<const int*>(ints),         forward_iterator<const int*>(ints+10),         "10x11x12x13x14x15x16x17x18x19");
-    test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
-    test('x', random_access_iterator<const int*>(ints),   random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
+    test('X', legacy_input_iterator<const char*>(chars),         legacy_input_iterator<const char*>(chars+10),         "0X1X2X3X4X5X6X7X8X9");
+    test('x', legacy_input_iterator<const int*>(ints),           legacy_input_iterator<const int*>(ints+10),           "10x11x12x13x14x15x16x17x18x19");
+    test('X', legacy_forward_iterator<const char*>(chars),       legacy_forward_iterator<const char*>(chars+10),       "0X1X2X3X4X5X6X7X8X9");
+    test('x', legacy_forward_iterator<const int*>(ints),         legacy_forward_iterator<const int*>(ints+10),         "10x11x12x13x14x15x16x17x18x19");
+    test('X', legacy_random_access_iterator<const char*>(chars), legacy_random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
+    test('x', legacy_random_access_iterator<const int*>(ints),   legacy_random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
 
     test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
@@ -101,12 +101,12 @@
     const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
     test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
     test(L'x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
-    test(L'X', input_iterator<const wchar_t*>(chars),         input_iterator<const wchar_t*>(chars+10),         L"0X1X2X3X4X5X6X7X8X9");
-    test(L'x', input_iterator<const int*>(ints),              input_iterator<const int*>(ints+10),              L"10x11x12x13x14x15x16x17x18x19");
-    test(L'X', forward_iterator<const wchar_t*>(chars),       forward_iterator<const wchar_t*>(chars+10),       L"0X1X2X3X4X5X6X7X8X9");
-    test(L'x', forward_iterator<const int*>(ints),            forward_iterator<const int*>(ints+10),            L"10x11x12x13x14x15x16x17x18x19");
-    test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
-    test(L'x', random_access_iterator<const int*>(ints),      random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', legacy_input_iterator<const wchar_t*>(chars),         legacy_input_iterator<const wchar_t*>(chars+10),         L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', legacy_input_iterator<const int*>(ints),              legacy_input_iterator<const int*>(ints+10),              L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', legacy_forward_iterator<const wchar_t*>(chars),       legacy_forward_iterator<const wchar_t*>(chars+10),       L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', legacy_forward_iterator<const int*>(ints),            legacy_forward_iterator<const int*>(ints+10),            L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', legacy_random_access_iterator<const wchar_t*>(chars), legacy_random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', legacy_random_access_iterator<const int*>(ints),      legacy_random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
 
     test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
     test(L"z", ints,  ints+10,  L"10z11z12z13z14z15z16z17z18z19");
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
@@ -130,7 +130,7 @@
   using Ptr = CharT const*;
   using Str = std::basic_string<CharT>;
   using StrView = std::basic_string_view<CharT>;
-  using InputIter = input_iterator<Ptr>;
+  using InputIter = legacy_input_iterator<Ptr>;
 
   const Ptr L = TC.lhs;
   Str RShort = (Ptr)TC.rhs;
@@ -232,7 +232,7 @@
   using Ptr = CharT const*;
   using Str = std::basic_string<CharT>;
   using StrView = std::basic_string_view<CharT>;
-  using InputIter = input_iterator<Ptr>;
+  using InputIter = legacy_input_iterator<Ptr>;
   const Ptr L = TC.lhs;
   const Ptr R = TC.rhs;
   const Ptr E = TC.expected_result();
@@ -338,7 +338,7 @@
     static_assert(has_append<It>(), "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = legacy_input_iterator<const char*>;
     static_assert(has_append<It>(), "");
   }
   {
@@ -349,7 +349,7 @@
       using reference = const char&;
       using difference_type = std::ptrdiff_t;
     };
-    using It = input_iterator<const char*, Traits>;
+    using It = legacy_input_iterator<const char*, Traits>;
     static_assert(has_append<It>(), "");
   }
   {
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp
@@ -137,7 +137,7 @@
   //////////////////////////////////////////////////////////////////////////////
   // Iterators
   {
-    using It = input_iterator<const CharT*>;
+    using It = legacy_input_iterator<const CharT*>;
     path p; PathReserve(p, Size + 1);
     It it(TestPath);
     {
@@ -150,7 +150,7 @@
     assert(p.string<CharT>() == TestPath);
   }
   {
-    using It = input_iterator<const CharT*>;
+    using It = legacy_input_iterator<const CharT*>;
     path p; PathReserve(p, Size + 1);
     It it(TestPath);
     {
@@ -161,7 +161,7 @@
     assert(p.string<CharT>() == TestPath);
   }
   {
-    using It = input_iterator<const CharT*>;
+    using It = legacy_input_iterator<const CharT*>;
     path p; PathReserve(p, Size + 1);
     It it(TestPath);
     It e(TestPathEnd);
@@ -189,7 +189,7 @@
     static_assert(has_assign<It>(), "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = legacy_input_iterator<const char*>;
     static_assert(std::is_assignable<path, It>::value, "");
     static_assert(has_assign<It>(), "");
   }
@@ -201,7 +201,7 @@
       using reference = const char&;
       using difference_type = std::ptrdiff_t;
     };
-    using It = input_iterator<const char*, Traits>;
+    using It = legacy_input_iterator<const char*, Traits>;
     static_assert(std::is_assignable<path, It>::value, "");
     static_assert(has_assign<It>(), "");
   }
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp
@@ -92,7 +92,7 @@
   using Ptr = CharT const*;
   using Str = std::basic_string<CharT>;
   using StrView = std::basic_string_view<CharT>;
-  using InputIter = input_iterator<Ptr>;
+  using InputIter = legacy_input_iterator<Ptr>;
 
   const Ptr L = TC.lhs;
   const Ptr R = TC.rhs;
@@ -173,7 +173,7 @@
   using Ptr = CharT const*;
   using Str = std::basic_string<CharT>;
   using StrView = std::basic_string_view<CharT>;
-  using InputIter = input_iterator<Ptr>;
+  using InputIter = legacy_input_iterator<Ptr>;
   const Ptr L = TC.lhs;
   const Ptr R = TC.rhs;
   const Ptr E = TC.expect;
@@ -303,7 +303,7 @@
     static_assert(has_concat<It>(), "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = legacy_input_iterator<const char*>;
     static_assert(has_concat<It>(), "");
   }
   {
@@ -314,7 +314,7 @@
       using reference = const char&;
       using difference_type = std::ptrdiff_t;
     };
-    using It = input_iterator<const char*, Traits>;
+    using It = legacy_input_iterator<const char*, Traits>;
     static_assert(has_concat<It>(), "");
   }
   {
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp
@@ -68,13 +68,13 @@
   }
   // Iterators
   {
-    using It = input_iterator<const CharT*>;
+    using It = legacy_input_iterator<const CharT*>;
     path p(It{TestPath}, args...);
     assert(p.native() == Expect);
     assert(p.string<CharT>() == TestPath);
   }
   {
-    using It = input_iterator<const CharT*>;
+    using It = legacy_input_iterator<const CharT*>;
     path p(It{TestPath}, It{TestPathEnd}, args...);
     assert(p.native() == Expect);
     assert(p.string<CharT>() == TestPath);
@@ -99,7 +99,7 @@
     static_assert(std::is_constructible<path, It>::value, "");
   }
   {
-    using It = input_iterator<const char*>;
+    using It = legacy_input_iterator<const char*>;
     static_assert(std::is_constructible<path, It>::value, "");
   }
   {
@@ -110,7 +110,7 @@
       using reference = const char&;
       using difference_type = std::ptrdiff_t;
     };
-    using It = input_iterator<const char*, Traits>;
+    using It = legacy_input_iterator<const char*, Traits>;
     static_assert(std::is_constructible<path, It>::value, "");
   }
   {
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp
@@ -43,20 +43,20 @@
 {
     const char* s = "1234567890";
     typedef std::iterator_traits<const char*>::difference_type Distance;
-    check_advance<Distance>(input_iterator<const char*>(s), 10, input_iterator<const char*>(s+10));
-    check_advance<Distance>(forward_iterator<const char*>(s), 10, forward_iterator<const char*>(s+10));
-    check_advance<Distance>(bidirectional_iterator<const char*>(s+5), 5, bidirectional_iterator<const char*>(s+10));
-    check_advance<Distance>(bidirectional_iterator<const char*>(s+5), -5, bidirectional_iterator<const char*>(s));
-    check_advance<Distance>(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
-    check_advance<Distance>(random_access_iterator<const char*>(s+5), -5, random_access_iterator<const char*>(s));
+    check_advance<Distance>(legacy_input_iterator<const char*>(s), 10, legacy_input_iterator<const char*>(s+10));
+    check_advance<Distance>(legacy_forward_iterator<const char*>(s), 10, legacy_forward_iterator<const char*>(s+10));
+    check_advance<Distance>(legacy_bidirectional_iterator<const char*>(s+5), 5, legacy_bidirectional_iterator<const char*>(s+10));
+    check_advance<Distance>(legacy_bidirectional_iterator<const char*>(s+5), -5, legacy_bidirectional_iterator<const char*>(s));
+    check_advance<Distance>(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s+10));
+    check_advance<Distance>(legacy_random_access_iterator<const char*>(s+5), -5, legacy_random_access_iterator<const char*>(s));
     check_advance<Distance>(s+5, 5, s+10);
     check_advance<Distance>(s+5, -5, s);
 
     // Also check with other distance types
-    check_advance<std::size_t>(input_iterator<const char*>(s), 10u, input_iterator<const char*>(s+10));
-    check_advance<std::size_t>(forward_iterator<const char*>(s), 10u, forward_iterator<const char*>(s+10));
-    check_advance<std::size_t>(bidirectional_iterator<const char*>(s), 10u, bidirectional_iterator<const char*>(s+10));
-    check_advance<std::size_t>(random_access_iterator<const char*>(s), 10u, random_access_iterator<const char*>(s+10));
+    check_advance<std::size_t>(legacy_input_iterator<const char*>(s), 10u, legacy_input_iterator<const char*>(s+10));
+    check_advance<std::size_t>(legacy_forward_iterator<const char*>(s), 10u, legacy_forward_iterator<const char*>(s+10));
+    check_advance<std::size_t>(legacy_bidirectional_iterator<const char*>(s), 10u, legacy_bidirectional_iterator<const char*>(s+10));
+    check_advance<std::size_t>(legacy_random_access_iterator<const char*>(s), 10u, legacy_random_access_iterator<const char*>(s+10));
 
     return true;
 }
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp
@@ -35,10 +35,10 @@
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     const char* s = "1234567890";
-    check_distance(input_iterator<const char*>(s), input_iterator<const char*>(s+10), 10);
-    check_distance(forward_iterator<const char*>(s), forward_iterator<const char*>(s+10), 10);
-    check_distance(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+10), 10);
-    check_distance(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+10), 10);
+    check_distance(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), 10);
+    check_distance(legacy_forward_iterator<const char*>(s), legacy_forward_iterator<const char*>(s+10), 10);
+    check_distance(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s+10), 10);
+    check_distance(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+10), 10);
     check_distance(s, s+10, 10);
     return true;
 }
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -42,18 +42,18 @@
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     const char* s = "1234567890";
-    check_next_n(input_iterator<const char*>(s),             10, input_iterator<const char*>(s+10));
-    check_next_n(forward_iterator<const char*>(s),           10, forward_iterator<const char*>(s+10));
-    check_next_n(bidirectional_iterator<const char*>(s),     10, bidirectional_iterator<const char*>(s+10));
-    check_next_n(bidirectional_iterator<const char*>(s+10), -10, bidirectional_iterator<const char*>(s));
-    check_next_n(random_access_iterator<const char*>(s),     10, random_access_iterator<const char*>(s+10));
-    check_next_n(random_access_iterator<const char*>(s+10), -10, random_access_iterator<const char*>(s));
+    check_next_n(legacy_input_iterator<const char*>(s),             10, legacy_input_iterator<const char*>(s+10));
+    check_next_n(legacy_forward_iterator<const char*>(s),           10, legacy_forward_iterator<const char*>(s+10));
+    check_next_n(legacy_bidirectional_iterator<const char*>(s),     10, legacy_bidirectional_iterator<const char*>(s+10));
+    check_next_n(legacy_bidirectional_iterator<const char*>(s+10), -10, legacy_bidirectional_iterator<const char*>(s));
+    check_next_n(legacy_random_access_iterator<const char*>(s),     10, legacy_random_access_iterator<const char*>(s+10));
+    check_next_n(legacy_random_access_iterator<const char*>(s+10), -10, legacy_random_access_iterator<const char*>(s));
     check_next_n(s, 10, s+10);
 
-    check_next_1(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
-    check_next_1(forward_iterator<const char*>(s), forward_iterator<const char*>(s+1));
-    check_next_1(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1));
-    check_next_1(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1));
+    check_next_1(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1));
+    check_next_1(legacy_forward_iterator<const char*>(s), legacy_forward_iterator<const char*>(s+1));
+    check_next_1(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s+1));
+    check_next_1(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1));
     check_next_1(s, s+1);
 
     return true;
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -40,15 +40,15 @@
 TEST_CONSTEXPR_CXX17 bool tests()
 {
     const char* s = "1234567890";
-    check_prev_n(forward_iterator      <const char*>(s),    -10, forward_iterator      <const char*>(s+10));
-    check_prev_n(bidirectional_iterator<const char*>(s+10),  10, bidirectional_iterator<const char*>(s));
-    check_prev_n(bidirectional_iterator<const char*>(s),    -10, bidirectional_iterator<const char*>(s+10));
-    check_prev_n(random_access_iterator<const char*>(s+10),  10, random_access_iterator<const char*>(s));
-    check_prev_n(random_access_iterator<const char*>(s),    -10, random_access_iterator<const char*>(s+10));
+    check_prev_n(legacy_forward_iterator      <const char*>(s),    -10, legacy_forward_iterator      <const char*>(s+10));
+    check_prev_n(legacy_bidirectional_iterator<const char*>(s+10),  10, legacy_bidirectional_iterator<const char*>(s));
+    check_prev_n(legacy_bidirectional_iterator<const char*>(s),    -10, legacy_bidirectional_iterator<const char*>(s+10));
+    check_prev_n(legacy_random_access_iterator<const char*>(s+10),  10, legacy_random_access_iterator<const char*>(s));
+    check_prev_n(legacy_random_access_iterator<const char*>(s),    -10, legacy_random_access_iterator<const char*>(s+10));
     check_prev_n(s+10, 10, s);
 
-    check_prev_1(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
-    check_prev_1(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
+    check_prev_1(legacy_bidirectional_iterator<const char*>(s+1), legacy_bidirectional_iterator<const char*>(s));
+    check_prev_1(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s));
     check_prev_1(s+1, s);
 
     return true;
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp
@@ -612,7 +612,7 @@
 
 // Other test iterators.
 
-using InputTestItereatorTraits = std::iterator_traits<input_iterator<int*> >;
+using InputTestItereatorTraits = std::iterator_traits<legacy_input_iterator<int*> >;
 static_assert(std::same_as<InputTestItereatorTraits::iterator_category,
                            std::input_iterator_tag>);
 static_assert(std::same_as<InputTestItereatorTraits::value_type, int>);
@@ -630,7 +630,7 @@
 static_assert(std::same_as<OutputTestItereatorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<OutputTestItereatorTraits>);
 
-using ForwardTestIteratorTraits = std::iterator_traits<forward_iterator<int*> >;
+using ForwardTestIteratorTraits = std::iterator_traits<legacy_forward_iterator<int*> >;
 static_assert(std::same_as<ForwardTestIteratorTraits::iterator_category,
                            std::forward_iterator_tag>);
 static_assert(std::same_as<ForwardTestIteratorTraits::value_type, int>);
@@ -640,7 +640,7 @@
 static_assert(!has_iterator_concept_v<ForwardTestIteratorTraits>);
 
 using BidirectionalTestIteratorTraits =
-    std::iterator_traits<bidirectional_iterator<int*> >;
+    std::iterator_traits<legacy_bidirectional_iterator<int*> >;
 static_assert(std::same_as<BidirectionalTestIteratorTraits::iterator_category,
                            std::bidirectional_iterator_tag>);
 static_assert(std::same_as<BidirectionalTestIteratorTraits::value_type, int>);
@@ -651,7 +651,7 @@
 static_assert(!has_iterator_concept_v<BidirectionalTestIteratorTraits>);
 
 using RandomAccessTestIteratorTraits =
-    std::iterator_traits<random_access_iterator<int*> >;
+    std::iterator_traits<legacy_random_access_iterator<int*> >;
 static_assert(std::same_as<RandomAccessTestIteratorTraits::iterator_category,
                            std::random_access_iterator_tag>);
 static_assert(std::same_as<RandomAccessTestIteratorTraits::value_type, int>);
@@ -662,7 +662,7 @@
 static_assert(!has_iterator_concept_v<RandomAccessTestIteratorTraits>);
 
 using ContiguousTestIteratorTraits =
-    std::iterator_traits<contiguous_iterator<int*> >;
+    std::iterator_traits<legacy_contiguous_iterator<int*> >;
 static_assert(std::same_as<ContiguousTestIteratorTraits::iterator_category,
                            std::contiguous_iterator_tag>);
 static_assert(std::same_as<ContiguousTestIteratorTraits::value_type, int>);
diff --git a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp
--- a/libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp
@@ -19,7 +19,7 @@
 
 #include "test_iterators.h"
 
-static_assert(std::same_as<std::iter_reference_t<input_iterator<int*> >, int&>);
-static_assert(std::same_as<std::iter_reference_t<forward_iterator<int*> >, int&>);
-static_assert(std::same_as<std::iter_reference_t<bidirectional_iterator<int*> >, int&>);
-static_assert(std::same_as<std::iter_reference_t<random_access_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<legacy_input_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<legacy_forward_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<legacy_bidirectional_iterator<int*> >, int&>);
+static_assert(std::same_as<std::iter_reference_t<legacy_random_access_iterator<int*> >, int&>);
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp
--- a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp
@@ -23,25 +23,25 @@
 static_assert(std::input_or_output_iterator<int volatile*>);
 static_assert(std::input_or_output_iterator<int const volatile*>);
 
-static_assert(std::input_or_output_iterator<input_iterator<int*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int const*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int volatile*> >);
-static_assert(std::input_or_output_iterator<input_iterator<int const volatile*> >);
-
-static_assert(std::input_or_output_iterator<forward_iterator<int*> >);
-static_assert(std::input_or_output_iterator<forward_iterator<int const*> >);
-static_assert(std::input_or_output_iterator<forward_iterator<int volatile*> >);
-static_assert(std::input_or_output_iterator<forward_iterator<int const volatile*> >);
-
-static_assert(std::input_or_output_iterator<bidirectional_iterator<int*> >);
-static_assert(std::input_or_output_iterator<bidirectional_iterator<int const*> >);
-static_assert(std::input_or_output_iterator<bidirectional_iterator<int volatile*> >);
-static_assert(std::input_or_output_iterator<bidirectional_iterator<int const volatile*> >);
-
-static_assert(std::input_or_output_iterator<random_access_iterator<int*> >);
-static_assert(std::input_or_output_iterator<random_access_iterator<int const*> >);
-static_assert(std::input_or_output_iterator<random_access_iterator<int volatile*> >);
-static_assert(std::input_or_output_iterator<random_access_iterator<int const volatile*> >);
+static_assert(std::input_or_output_iterator<legacy_input_iterator<int*> >);
+static_assert(std::input_or_output_iterator<legacy_input_iterator<int const*> >);
+static_assert(std::input_or_output_iterator<legacy_input_iterator<int volatile*> >);
+static_assert(std::input_or_output_iterator<legacy_input_iterator<int const volatile*> >);
+
+static_assert(std::input_or_output_iterator<legacy_forward_iterator<int*> >);
+static_assert(std::input_or_output_iterator<legacy_forward_iterator<int const*> >);
+static_assert(std::input_or_output_iterator<legacy_forward_iterator<int volatile*> >);
+static_assert(std::input_or_output_iterator<legacy_forward_iterator<int const volatile*> >);
+
+static_assert(std::input_or_output_iterator<legacy_bidirectional_iterator<int*> >);
+static_assert(std::input_or_output_iterator<legacy_bidirectional_iterator<int const*> >);
+static_assert(std::input_or_output_iterator<legacy_bidirectional_iterator<int volatile*> >);
+static_assert(std::input_or_output_iterator<legacy_bidirectional_iterator<int const volatile*> >);
+
+static_assert(std::input_or_output_iterator<legacy_random_access_iterator<int*> >);
+static_assert(std::input_or_output_iterator<legacy_random_access_iterator<int const*> >);
+static_assert(std::input_or_output_iterator<legacy_random_access_iterator<int volatile*> >);
+static_assert(std::input_or_output_iterator<legacy_random_access_iterator<int const volatile*> >);
 
 static_assert(!std::input_or_output_iterator<void*>);
 static_assert(!std::input_or_output_iterator<void const*>);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
@@ -34,10 +34,10 @@
 {
     {
     char s[] = "1234567890";
-    test(input_iterator<char*>(s+5));
-    test(forward_iterator<char*>(s+5));
-    test(bidirectional_iterator<char*>(s+5));
-    test(random_access_iterator<char*>(s+5));
+    test(legacy_input_iterator<char*>(s+5));
+    test(legacy_forward_iterator<char*>(s+5));
+    test(legacy_bidirectional_iterator<char*>(s+5));
+    test(legacy_random_access_iterator<char*>(s+5));
     test(s+5);
     }
     {
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp
@@ -36,7 +36,7 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s+5), random_access_iterator<char*>(s), 5);
+    test(legacy_random_access_iterator<char*>(s+5), legacy_random_access_iterator<char*>(s), 5);
     test(s+5, s, 5);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s+5), 5, random_access_iterator<char*>(s+10));
+    test(legacy_random_access_iterator<char*>(s+5), 5, legacy_random_access_iterator<char*>(s+10));
     test(s+5, 5, s+10);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp
@@ -33,7 +33,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp
@@ -33,7 +33,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s));
     test(s+5, 5, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s));
     test(s+5, 5, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp
@@ -35,14 +35,14 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(input_iterator<char*>(s), input_iterator<char*>(s), true);
-    test(input_iterator<char*>(s), input_iterator<char*>(s+1), false);
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s), true);
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), false);
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), true);
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), false);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s), true);
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s+1), false);
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s), true);
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s+1), false);
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s), true);
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s+1), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);
 
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp
@@ -38,9 +38,9 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), false);
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s), true);
     test(s, s, false);
     test(s, s+1, false);
     test(s+1, s, true);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp
@@ -38,9 +38,9 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), false);
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), false);
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s), true);
     test(s, s, true);
     test(s, s+1, false);
     test(s+1, s, true);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp
@@ -35,9 +35,9 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), true);
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s), false);
     test(s, s, false);
     test(s, s+1, true);
     test(s+1, s, false);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp
@@ -38,9 +38,9 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), true);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), true);
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s), false);
     test(s, s, true);
     test(s, s+1, true);
     test(s+1, s, false);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp
@@ -35,14 +35,14 @@
 int main(int, char**)
 {
     char s[] = "1234567890";
-    test(input_iterator<char*>(s), input_iterator<char*>(s), false);
-    test(input_iterator<char*>(s), input_iterator<char*>(s+1), true);
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s), false);
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s+1), true);
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s), false);
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1), true);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s), false);
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1), true);
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s), false);
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s+1), true);
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s), false);
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s+1), true);
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s), false);
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s+1), true);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s), false);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1), true);
     test(s, s, false);
     test(s, s+1, true);
 
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp
@@ -38,10 +38,10 @@
 {
     Derived d;
 
-    test<input_iterator<Base*> >(input_iterator<Derived*>(&d));
-    test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
-    test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
-    test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
+    test<legacy_input_iterator<Base*> >(legacy_input_iterator<Derived*>(&d));
+    test<legacy_forward_iterator<Base*> >(legacy_forward_iterator<Derived*>(&d));
+    test<legacy_bidirectional_iterator<Base*> >(legacy_bidirectional_iterator<Derived*>(&d));
+    test<legacy_random_access_iterator<const Base*> >(legacy_random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -29,10 +29,10 @@
 
 int main(int, char**)
 {
-    test<input_iterator<char*> >();
-    test<forward_iterator<char*> >();
-    test<bidirectional_iterator<char*> >();
-    test<random_access_iterator<char*> >();
+    test<legacy_input_iterator<char*> >();
+    test<legacy_forward_iterator<char*> >();
+    test<legacy_bidirectional_iterator<char*> >();
+    test<legacy_random_access_iterator<char*> >();
     test<char*>();
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp
@@ -31,10 +31,10 @@
 int main(int, char**)
 {
     char s[] = "123";
-    test(input_iterator<char*>(s));
-    test(forward_iterator<char*>(s));
-    test(bidirectional_iterator<char*>(s));
-    test(random_access_iterator<char*>(s));
+    test(legacy_input_iterator<char*>(s));
+    test(legacy_forward_iterator<char*>(s));
+    test(legacy_bidirectional_iterator<char*>(s));
+    test(legacy_random_access_iterator<char*>(s));
     test(s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     char s[] = "123";
-    test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
+    test(legacy_bidirectional_iterator<char*>(s+1), legacy_bidirectional_iterator<char*>(s));
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s));
     test(s+1, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     char s[] = "123";
-    test(bidirectional_iterator<char*>(s+1), bidirectional_iterator<char*>(s));
-    test(random_access_iterator<char*>(s+1), random_access_iterator<char*>(s));
+    test(legacy_bidirectional_iterator<char*>(s+1), legacy_bidirectional_iterator<char*>(s));
+    test(legacy_random_access_iterator<char*>(s+1), legacy_random_access_iterator<char*>(s));
     test(s+1, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp
@@ -44,13 +44,13 @@
 {
     char s[] = "123";
 #if TEST_STD_VER > 17
-    test_single_pass(input_iterator<char*>(s), input_iterator<char*>(s + 1));
+    test_single_pass(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s + 1));
 #else
-    test(input_iterator<char*>(s), input_iterator<char*>(s+1));
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s+1));
 #endif
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s+1));
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s+1));
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1));
     test(s, s+1);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp
@@ -33,10 +33,10 @@
 int main(int, char**)
 {
     char s[] = "123";
-    test(input_iterator<char*>(s), input_iterator<char*>(s+1));
-    test(forward_iterator<char*>(s), forward_iterator<char*>(s+1));
-    test(bidirectional_iterator<char*>(s), bidirectional_iterator<char*>(s+1));
-    test(random_access_iterator<char*>(s), random_access_iterator<char*>(s+1));
+    test(legacy_input_iterator<char*>(s), legacy_input_iterator<char*>(s+1));
+    test(legacy_forward_iterator<char*>(s), legacy_forward_iterator<char*>(s+1));
+    test(legacy_bidirectional_iterator<char*>(s), legacy_bidirectional_iterator<char*>(s+1));
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<char*>(s+1));
     test(s, s+1);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp
@@ -42,7 +42,7 @@
 {
     {
         char s[] = "1234567890";
-        test(random_access_iterator<char*>(s+5), 4, '0');
+        test(legacy_random_access_iterator<char*>(s+5), 4, '0');
         test(s+5, 4, '0');
     }
 #if TEST_STD_VER >= 11
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp
@@ -41,10 +41,10 @@
 {
     Derived d;
 
-    test<input_iterator<Base*> >(input_iterator<Derived*>(&d));
-    test<forward_iterator<Base*> >(forward_iterator<Derived*>(&d));
-    test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
-    test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
+    test<legacy_input_iterator<Base*> >(legacy_input_iterator<Derived*>(&d));
+    test<legacy_forward_iterator<Base*> >(legacy_forward_iterator<Derived*>(&d));
+    test<legacy_bidirectional_iterator<Base*> >(legacy_bidirectional_iterator<Derived*>(&d));
+    test<legacy_random_access_iterator<const Base*> >(legacy_random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
 #if TEST_STD_VER > 14
     {
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp
@@ -67,10 +67,10 @@
 
 int main(int, char**)
 {
-    test<input_iterator<char*> >();
-    test<forward_iterator<char*> >();
-    test<bidirectional_iterator<char*> >();
-    test<random_access_iterator<char*> >();
+    test<legacy_input_iterator<char*> >();
+    test<legacy_forward_iterator<char*> >();
+    test<legacy_bidirectional_iterator<char*> >();
+    test<legacy_random_access_iterator<char*> >();
     test<char*>();
 #if TEST_STD_VER >= 11
     {
@@ -103,11 +103,11 @@
 #endif
 
 #if TEST_STD_VER > 17
-    test<contiguous_iterator<char*>>();
-    static_assert(std::is_same_v<typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<bidirectional_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<random_access_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
-    static_assert(std::is_same_v<typename std::move_iterator<contiguous_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
+    test<legacy_contiguous_iterator<char*>>();
+    static_assert(std::is_same_v<typename std::move_iterator<legacy_forward_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename std::move_iterator<legacy_bidirectional_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename std::move_iterator<legacy_random_access_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
+    static_assert(std::is_same_v<typename std::move_iterator<legacy_contiguous_iterator<char*>>::iterator_concept, std::input_iterator_tag>);
     static_assert(std::is_same_v<typename std::move_iterator<char*>::iterator_concept, std::input_iterator_tag>);
 #endif
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -29,8 +29,8 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<const char*> >();
-    test<random_access_iterator<char*> >();
+    test<legacy_bidirectional_iterator<const char*> >();
+    test<legacy_random_access_iterator<char*> >();
     test<char*>();
     test<const char*>();
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -31,8 +31,8 @@
 int main(int, char**)
 {
     const char s[] = "123";
-    test(bidirectional_iterator<const char*>(s));
-    test(random_access_iterator<const char*>(s));
+    test(legacy_bidirectional_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s));
     test(s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -38,8 +38,8 @@
 {
     Derived d;
 
-    test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
-    test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
+    test<legacy_bidirectional_iterator<Base*> >(legacy_bidirectional_iterator<Derived*>(&d));
+    test<legacy_random_access_iterator<const Base*> >(legacy_random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -34,8 +34,8 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    random_access_iterator<const char*>b(s);
-    random_access_iterator<const char*>e(s+10);
+    legacy_random_access_iterator<const char*>b(s);
+    legacy_random_access_iterator<const char*>e(s+10);
     while ( b != e )
         test ( b++ );
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
@@ -35,10 +35,10 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), false);
-    test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1), true);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), true);
+    test(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s), false);
+    test(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s+1), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), true);
     test(s, s, false);
     test(s, s+1, true);
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     const char* s = "123";
-    test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
+    test(legacy_bidirectional_iterator<const char*>(s+1), legacy_bidirectional_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s));
     test(s+1, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     const char* s = "123";
-    test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s));
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s));
+    test(legacy_bidirectional_iterator<const char*>(s+1), legacy_bidirectional_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s));
     test(s+1, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -33,7 +33,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s));
     test(s+5, 5, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s));
     test(s+5, 5, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     const char* s = "123";
-    test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s+2));
+    test(legacy_bidirectional_iterator<const char*>(s+1), legacy_bidirectional_iterator<const char*>(s+2));
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s+2));
     test(s+1, s+2);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp
@@ -33,8 +33,8 @@
 int main(int, char**)
 {
     const char* s = "123";
-    test(bidirectional_iterator<const char*>(s+1), bidirectional_iterator<const char*>(s+2));
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s+2));
+    test(legacy_bidirectional_iterator<const char*>(s+1), legacy_bidirectional_iterator<const char*>(s+2));
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s+2));
     test(s+1, s+2);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -33,7 +33,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s+10));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s+10));
     test(s+5, 5, s+10);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -41,8 +41,8 @@
 {
     Derived d;
 
-    test<bidirectional_iterator<Base*> >(bidirectional_iterator<Derived*>(&d));
-    test<random_access_iterator<const Base*> >(random_access_iterator<Derived*>(&d));
+    test<legacy_bidirectional_iterator<Base*> >(legacy_bidirectional_iterator<Derived*>(&d));
+    test<legacy_random_access_iterator<const Base*> >(legacy_random_access_iterator<Derived*>(&d));
     test<Base*>(&d);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -35,10 +35,10 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s), true);
-    test(bidirectional_iterator<const char*>(s), bidirectional_iterator<const char*>(s+1), false);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), false);
+    test(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s), true);
+    test(legacy_bidirectional_iterator<const char*>(s), legacy_bidirectional_iterator<const char*>(s+1), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), false);
     test(s, s, true);
     test(s, s+1, false);
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -36,9 +36,9 @@
 int main(int, char**)
 {
     char s[3] = {0};
-    test(random_access_iterator<const char*>(s), random_access_iterator<char*>(s), 0);
-    test(random_access_iterator<char*>(s), random_access_iterator<const char*>(s+1), 1);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<char*>(s), -1);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<char*>(s), 0);
+    test(legacy_random_access_iterator<char*>(s), legacy_random_access_iterator<const char*>(s+1), 1);
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<char*>(s), -1);
     test(s, s, 0);
     test(s, s+1, 1);
     test(s+1, s, -1);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -35,9 +35,9 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), true);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), true);
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s), false);
     test(s, s, false);
     test(s, s+1, true);
     test(s+1, s, false);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -35,9 +35,9 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), true);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), true);
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s), false);
     test(s, s, true);
     test(s, s+1, true);
     test(s+1, s, false);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp
@@ -33,7 +33,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 4, '1');
+    test(legacy_random_access_iterator<const char*>(s+5), 4, '1');
     test(s+5, 4, '1');
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -35,9 +35,9 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), false);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), false);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), false);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), false);
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s), true);
     test(s, s, false);
     test(s, s+1, false);
     test(s+1, s, true);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -35,9 +35,9 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s), true);
-    test(random_access_iterator<const char*>(s), random_access_iterator<const char*>(s+1), false);
-    test(random_access_iterator<const char*>(s+1), random_access_iterator<const char*>(s), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s), true);
+    test(legacy_random_access_iterator<const char*>(s), legacy_random_access_iterator<const char*>(s+1), false);
+    test(legacy_random_access_iterator<const char*>(s+1), legacy_random_access_iterator<const char*>(s), true);
     test(s, s, true);
     test(s, s+1, false);
     test(s+1, s, true);
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp
@@ -34,7 +34,7 @@
 int main(int, char**)
 {
     const char* s = "1234567890";
-    test(random_access_iterator<const char*>(s+5), 5, random_access_iterator<const char*>(s));
+    test(legacy_random_access_iterator<const char*>(s+5), 5, legacy_random_access_iterator<const char*>(s));
     test(s+5, 5, s);
 
 #if TEST_STD_VER > 14
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
--- a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
+++ b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp
@@ -62,15 +62,15 @@
 
 int main(int, char**)
 {
-    test<bidirectional_iterator<char*> >();
-    test<random_access_iterator<char*> >();
+    test<legacy_bidirectional_iterator<char*> >();
+    test<legacy_random_access_iterator<char*> >();
     test<char*>();
 
 #if TEST_STD_VER > 17
-    test<contiguous_iterator<char*>>();
-    static_assert(std::is_same_v<typename std::reverse_iterator<bidirectional_iterator<char*>>::iterator_concept, std::bidirectional_iterator_tag>);
-    static_assert(std::is_same_v<typename std::reverse_iterator<random_access_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>);
-    static_assert(std::is_same_v<typename std::reverse_iterator<contiguous_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>);
+    test<legacy_contiguous_iterator<char*>>();
+    static_assert(std::is_same_v<typename std::reverse_iterator<legacy_bidirectional_iterator<char*>>::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::is_same_v<typename std::reverse_iterator<legacy_random_access_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::is_same_v<typename std::reverse_iterator<legacy_contiguous_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>);
     static_assert(std::is_same_v<typename std::reverse_iterator<char*>::iterator_concept, std::random_access_iterator_tag>);
 #endif
 
diff --git a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, legacy_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
@@ -35,7 +35,7 @@
         : Fn(refs) {}
 };
 
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, legacy_input_iterator<const wchar_t*> > Fw;
 
 class my_facetw
     : public Fw
@@ -62,7 +62,7 @@
         // char, national
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -73,7 +73,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -84,7 +84,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -95,7 +95,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -106,7 +106,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -117,7 +117,7 @@
         }
         {   // zero, showbase
             std::string v = "$0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -129,7 +129,7 @@
         {   // zero, showbase
             std::string v = "$0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -141,7 +141,7 @@
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -153,7 +153,7 @@
         {   // negative one, showbase
             std::string v = "-$0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -165,7 +165,7 @@
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -177,7 +177,7 @@
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -190,7 +190,7 @@
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -203,7 +203,7 @@
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -214,7 +214,7 @@
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -228,7 +228,7 @@
         // char, international
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -239,7 +239,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -250,7 +250,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -261,7 +261,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -272,7 +272,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -283,7 +283,7 @@
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -295,7 +295,7 @@
         {   // zero, showbase
             std::string v = "USD 0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -307,7 +307,7 @@
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -319,7 +319,7 @@
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -331,7 +331,7 @@
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -343,7 +343,7 @@
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -356,7 +356,7 @@
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -369,7 +369,7 @@
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -380,7 +380,7 @@
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -394,7 +394,7 @@
         // wchar_t, national
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -405,7 +405,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -416,7 +416,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -427,7 +427,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -438,7 +438,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -449,7 +449,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -461,7 +461,7 @@
         {   // zero, showbase
             std::wstring v = L"$0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -473,7 +473,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -485,7 +485,7 @@
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -497,7 +497,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -509,7 +509,7 @@
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -522,7 +522,7 @@
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -535,7 +535,7 @@
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -546,7 +546,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -560,7 +560,7 @@
         // wchar_t, international
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -571,7 +571,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -582,7 +582,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -593,7 +593,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -604,7 +604,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -615,7 +615,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -627,7 +627,7 @@
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -639,7 +639,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -651,7 +651,7 @@
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -663,7 +663,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -675,7 +675,7 @@
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -688,7 +688,7 @@
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -701,7 +701,7 @@
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -712,7 +712,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
diff --git a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
@@ -31,7 +31,7 @@
 #include "platform_support.h" // locale name macros
 #include "test_macros.h"
 
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, legacy_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
@@ -41,7 +41,7 @@
         : Fn(refs) {}
 };
 
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, legacy_input_iterator<const wchar_t*> > Fw;
 
 class my_facetw
     : public Fw
@@ -95,7 +95,7 @@
         // char, national
         {   // zero
             std::string v = "0,00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -106,7 +106,7 @@
         }
         {   // negative one
             std::string v = "-0,01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -117,7 +117,7 @@
         }
         {   // positive
             std::string v = "1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -128,7 +128,7 @@
         }
         {   // negative
             std::string v = "-1 234 567,89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -139,7 +139,7 @@
         }
         {   // negative
             std::string v = "-1234567,89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -151,7 +151,7 @@
         {   // zero, showbase
             std::string v = "0,00 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -163,7 +163,7 @@
         {   // zero, showbase
             std::string v = "0,00 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -174,7 +174,7 @@
         }
         {   // negative one, showbase
             std::string v = "-0,01 \u20ac";  // EURO SIGN
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -186,7 +186,7 @@
         {   // negative one, showbase
             std::string v = "-0,01 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -197,7 +197,7 @@
         }
         {   // positive, showbase
             std::string v = "1 234 567,89 \u20ac";  // EURO SIGN
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -209,7 +209,7 @@
         {   // positive, showbase
             std::string v = "1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -222,7 +222,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -235,7 +235,7 @@
         {   // negative, showbase
             std::string v = "1 234 567,89 EUR -";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -246,7 +246,7 @@
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 EUR -";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -262,7 +262,7 @@
         // char, international
         {   // zero
             std::string v = "0,00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -273,7 +273,7 @@
         }
         {   // negative one
             std::string v = "-0,01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -284,7 +284,7 @@
         }
         {   // positive
             std::string v = "1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -295,7 +295,7 @@
         }
         {   // negative
             std::string v = "-1 234 567,89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -306,7 +306,7 @@
         }
         {   // negative
             std::string v = "-1234567,89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -318,7 +318,7 @@
         {   // zero, showbase
             std::string v = "0,00 EUR";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -330,7 +330,7 @@
         {   // zero, showbase
             std::string v = "0,00 EUR";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -341,7 +341,7 @@
         }
         {   // negative one, showbase
             std::string v = "-0,01 EUR";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -353,7 +353,7 @@
         {   // negative one, showbase
             std::string v = "-0,01 EUR";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -364,7 +364,7 @@
         }
         {   // positive, showbase
             std::string v = "1 234 567,89 EUR";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -376,7 +376,7 @@
         {   // positive, showbase
             std::string v = "1 234 567,89 EUR";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -389,7 +389,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 EUR";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -402,7 +402,7 @@
         {   // negative, showbase
             std::string v = "1 234 567,89 Eu-";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -413,7 +413,7 @@
         }
         {   // negative, showbase
             std::string v = "1 234 567,89 Eu-";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -428,7 +428,7 @@
         // wchar_t, national
         {   // zero
             std::wstring v = L"0,00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -439,7 +439,7 @@
         }
         {   // negative one
             std::wstring v = L"-0,01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -450,7 +450,7 @@
         }
         {   // positive
             std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -461,7 +461,7 @@
         }
         {   // negative
             std::wstring v = convert_thousands_sep(L"-1 234 567,89");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -472,7 +472,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567,89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -484,7 +484,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -496,7 +496,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -507,7 +507,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-0,01 \u20ac";  // EURO SIGN
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -519,7 +519,7 @@
         {   // negative one, showbase
             std::wstring v = L"-0,01 \u20ac";  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -530,7 +530,7 @@
         }
         {   // positive, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac");  // EURO SIGN
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -542,7 +542,7 @@
         {   // positive, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 \u20ac");  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -555,7 +555,7 @@
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"-1 234 567,89 \u20ac");  // EURO SIGN
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -568,7 +568,7 @@
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -579,7 +579,7 @@
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR -");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -594,7 +594,7 @@
         // wchar_t, international
         {   // zero
             std::wstring v = L"0,00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -605,7 +605,7 @@
         }
         {   // negative one
             std::wstring v = L"-0,01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -616,7 +616,7 @@
         }
         {   // positive
             std::wstring v = convert_thousands_sep(L"1 234 567,89 ");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -627,7 +627,7 @@
         }
         {   // negative
             std::wstring v = convert_thousands_sep(L"-1 234 567,89");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -638,7 +638,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567,89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -650,7 +650,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 EUR";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -662,7 +662,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 EUR";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -673,7 +673,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-0,01 EUR";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -685,7 +685,7 @@
         {   // negative one, showbase
             std::wstring v = L"-0,01 EUR";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -696,7 +696,7 @@
         }
         {   // positive, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -708,7 +708,7 @@
         {   // positive, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 EUR");
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -721,7 +721,7 @@
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"-1 234 567,89 EUR");
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -734,7 +734,7 @@
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -745,7 +745,7 @@
         }
         {   // negative, showbase
             std::wstring v = convert_thousands_sep(L"1 234 567,89 Eu-");
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
diff --git a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp
@@ -48,7 +48,7 @@
 #   define APPLE_FIXME
 #endif
 
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, legacy_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
@@ -58,7 +58,7 @@
         : Fn(refs) {}
 };
 
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, legacy_input_iterator<const wchar_t*> > Fw;
 
 class my_facetw
     : public Fw
@@ -85,7 +85,7 @@
         // char, national
         {   // zero
             std::string v = "0,00 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -96,7 +96,7 @@
         }
         {   // negative one
             std::string v = "-0,01 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -107,7 +107,7 @@
         }
         {   // positive
             std::string v = "1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -118,7 +118,7 @@
         }
         {   // negative
             std::string v = "-1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -129,7 +129,7 @@
         }
         {   // negative
             std::string v = "-1234567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -140,7 +140,7 @@
         }
         {   // zero, showbase
             std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -152,7 +152,7 @@
         {   // zero, showbase
             std::string v = "0,00 \xD1\x80\xD1\x83\xD0\xB1"".";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -164,7 +164,7 @@
         }
         {   // negative one, showbase
             std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -176,7 +176,7 @@
         {   // negative one, showbase
             std::string v = "-0,01 \xD1\x80\xD1\x83\xD0\xB1"".";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -188,7 +188,7 @@
         }
         {   // positive, showbase
             std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -200,7 +200,7 @@
         {   // positive, showbase
             std::string v = "1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -213,7 +213,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -226,7 +226,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -237,7 +237,7 @@
         }
         {   // negative, showbase
             std::string v = "-1 234 567,89 RUB ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -252,7 +252,7 @@
         // char, international
         {   // zero
             std::string v = "0,00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -263,7 +263,7 @@
         }
         {   // negative one
             std::string v = "-0,01 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -274,7 +274,7 @@
         }
         {   // positive
             std::string v = "1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -285,7 +285,7 @@
         }
         {   // negative
             std::string v = "-1 234 567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -296,7 +296,7 @@
         }
         {   // negative
             std::string v = "-1234567,89 ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -307,7 +307,7 @@
         }
         {   // zero, showbase
             std::string v = "0,00 RUB ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -320,7 +320,7 @@
         {   // zero, showbase
             std::string v = "0,00 RUB ";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -333,7 +333,7 @@
 #endif
         {   // negative one, showbase
             std::string v = "-0,01 RUB ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -346,7 +346,7 @@
         {   // negative one, showbase
             std::string v = "-0,01 RUB ";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -359,7 +359,7 @@
 #endif
         {   // positive, showbase
             std::string v = "1 234 567,89 RUB ";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -372,7 +372,7 @@
         {   // positive, showbase
             std::string v = "1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -387,7 +387,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -401,7 +401,7 @@
         {   // negative, showbase
             std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -412,7 +412,7 @@
         }
         {   // negative, showbase
             std::string v = "-1 234 567,89 \xD1\x80\xD1\x83\xD0\xB1"".";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -427,7 +427,7 @@
         // wchar_t, national
         {   // zero
             std::wstring v = L"0,00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -438,7 +438,7 @@
         }
         {   // negative one
             std::wstring v = L"-0,01 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -449,7 +449,7 @@
         }
         {   // positive
             std::wstring v = L"1 234 567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -460,7 +460,7 @@
         }
         {   // negative
             std::wstring v = L"-1 234 567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -471,7 +471,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -482,7 +482,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"0,00 \x440\x443\x431"".";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -494,7 +494,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 \x440\x443\x431"".";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -506,7 +506,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-0,01 \x440\x443\x431"".";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -518,7 +518,7 @@
         {   // negative one, showbase
             std::wstring v = L"-0,01 \x440\x443\x431"".";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -530,7 +530,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -542,7 +542,7 @@
         {   // positive, showbase
             std::wstring v = L"1 234 567,89 \x440\x443\x431"".";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -555,7 +555,7 @@
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -568,7 +568,7 @@
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -579,7 +579,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 RUB ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -594,7 +594,7 @@
         // wchar_t, international
         {   // zero
             std::wstring v = L"0,00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -605,7 +605,7 @@
         }
         {   // negative one
             std::wstring v = L"-0,01 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -616,7 +616,7 @@
         }
         {   // positive
             std::wstring v = L"1 234 567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -627,7 +627,7 @@
         }
         {   // negative
             std::wstring v = L"-1 234 567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -638,7 +638,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567,89 ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -649,7 +649,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"0,00 RUB ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -662,7 +662,7 @@
         {   // zero, showbase
             std::wstring v = L"0,00 RUB ";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -675,7 +675,7 @@
 #endif
         {   // negative one, showbase
             std::wstring v = L"-0,01 RUB ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -688,7 +688,7 @@
         {   // negative one, showbase
             std::wstring v = L"-0,01 RUB ";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -701,7 +701,7 @@
 #endif
         {   // positive, showbase
             std::wstring v = L"1 234 567,89 RUB ";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -714,7 +714,7 @@
         {   // positive, showbase
             std::wstring v = L"1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -729,7 +729,7 @@
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 RUB ";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -743,7 +743,7 @@
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -754,7 +754,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-1 234 567,89 \x440\x443\x431"".";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
diff --git a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp
@@ -32,7 +32,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, legacy_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
@@ -42,7 +42,7 @@
         : Fn(refs) {}
 };
 
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, legacy_input_iterator<const wchar_t*> > Fw;
 
 class my_facetw
     : public Fw
@@ -69,7 +69,7 @@
         // char, national
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -80,7 +80,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -91,7 +91,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -102,7 +102,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -113,7 +113,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -124,7 +124,7 @@
         }
         {   // zero, showbase
             std::string v = "\xEF\xBF\xA5""0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -136,7 +136,7 @@
         {   // zero, showbase
             std::string v = "\xEF\xBF\xA5""0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -148,7 +148,7 @@
         }
         {   // negative one, showbase
             std::string v = "\xEF\xBF\xA5""-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -160,7 +160,7 @@
         {   // negative one, showbase
             std::string v = "\xEF\xBF\xA5""-0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -172,7 +172,7 @@
         }
         {   // positive, showbase
             std::string v = "\xEF\xBF\xA5""1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -184,7 +184,7 @@
         {   // positive, showbase
             std::string v = "\xEF\xBF\xA5""1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -197,7 +197,7 @@
         {   // negative, showbase
             std::string v = "\xEF\xBF\xA5""-1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -210,7 +210,7 @@
         {   // negative, showbase
             std::string v = "CNY -1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -221,7 +221,7 @@
         }
         {   // negative, showbase
             std::string v = "CNY -1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -235,7 +235,7 @@
         // char, international
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -246,7 +246,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -257,7 +257,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -268,7 +268,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -279,7 +279,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -290,7 +290,7 @@
         }
         {   // zero, showbase
             std::string v = "CNY 0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -302,7 +302,7 @@
         {   // zero, showbase
             std::string v = "CNY 0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -314,7 +314,7 @@
         }
         {   // negative one, showbase
             std::string v = "CNY -0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -326,7 +326,7 @@
         {   // negative one, showbase
             std::string v = "CNY -0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -338,7 +338,7 @@
         }
         {   // positive, showbase
             std::string v = "CNY 1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -350,7 +350,7 @@
         {   // positive, showbase
             std::string v = "CNY 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -363,7 +363,7 @@
         {   // negative, showbase
             std::string v = "CNY -1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -376,7 +376,7 @@
         {   // negative, showbase
             std::string v = "\xEF\xBF\xA5""-1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -387,7 +387,7 @@
         }
         {   // negative, showbase
             std::string v = "\xEF\xBF\xA5""-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -401,7 +401,7 @@
         // wchar_t, national
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -412,7 +412,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -423,7 +423,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -434,7 +434,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -445,7 +445,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -456,7 +456,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"\xFFE5""0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -468,7 +468,7 @@
         {   // zero, showbase
             std::wstring v = L"\xFFE5""0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -480,7 +480,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"\xFFE5""-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -492,7 +492,7 @@
         {   // negative one, showbase
             std::wstring v = L"\xFFE5""-0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -504,7 +504,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"\xFFE5""1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -516,7 +516,7 @@
         {   // positive, showbase
             std::wstring v = L"\xFFE5""1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -529,7 +529,7 @@
         {   // negative, showbase
             std::wstring v = L"\xFFE5""-1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -542,7 +542,7 @@
         {   // negative, showbase
             std::wstring v = L"CNY -1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -553,7 +553,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"CNY -1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -567,7 +567,7 @@
         // wchar_t, international
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -578,7 +578,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -589,7 +589,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -600,7 +600,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -611,7 +611,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -622,7 +622,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"CNY 0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -634,7 +634,7 @@
         {   // zero, showbase
             std::wstring v = L"CNY 0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -646,7 +646,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"CNY -0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -658,7 +658,7 @@
         {   // negative one, showbase
             std::wstring v = L"CNY -0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -670,7 +670,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"CNY 1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -682,7 +682,7 @@
         {   // positive, showbase
             std::wstring v = L"CNY 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -695,7 +695,7 @@
         {   // negative, showbase
             std::wstring v = L"CNY -1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -708,7 +708,7 @@
         {   // negative, showbase
             std::wstring v = L"\xFFE5""-1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -719,7 +719,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"\xFFE5""-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
diff --git a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef std::money_get<char, input_iterator<const char*> > Fn;
+typedef std::money_get<char, legacy_input_iterator<const char*> > Fn;
 
 class my_facet
     : public Fn
@@ -35,7 +35,7 @@
         : Fn(refs) {}
 };
 
-typedef std::money_get<wchar_t, input_iterator<const wchar_t*> > Fw;
+typedef std::money_get<wchar_t, legacy_input_iterator<const wchar_t*> > Fw;
 
 class my_facetw
     : public Fw
@@ -62,7 +62,7 @@
         // char, national
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -73,7 +73,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -84,7 +84,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -95,7 +95,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -106,7 +106,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -117,7 +117,7 @@
         }
         {   // zero, showbase
             std::string v = "$0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -129,7 +129,7 @@
         {   // zero, showbase
             std::string v = "$0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -141,7 +141,7 @@
         }
         {   // negative one, showbase
             std::string v = "-$0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -153,7 +153,7 @@
         {   // negative one, showbase
             std::string v = "-$0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -165,7 +165,7 @@
         }
         {   // positive, showbase
             std::string v = "$1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -177,7 +177,7 @@
         {   // positive, showbase
             std::string v = "$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -190,7 +190,7 @@
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -203,7 +203,7 @@
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -215,7 +215,7 @@
         }
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -230,7 +230,7 @@
         // char, international
         {   // zero
             std::string v = "0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -241,7 +241,7 @@
         }
         {   // negative one
             std::string v = "-0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -252,7 +252,7 @@
         }
         {   // positive
             std::string v = "1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -263,7 +263,7 @@
         }
         {   // negative
             std::string v = "-1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -274,7 +274,7 @@
         }
         {   // negative
             std::string v = "-1234567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -285,7 +285,7 @@
         }
         {   // zero, showbase
             std::string v = "USD 0.00";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -297,7 +297,7 @@
         {   // zero, showbase
             std::string v = "USD 0.00";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -309,7 +309,7 @@
         }
         {   // negative one, showbase
             std::string v = "-USD 0.01";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -321,7 +321,7 @@
         {   // negative one, showbase
             std::string v = "-USD 0.01";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -333,7 +333,7 @@
         }
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -345,7 +345,7 @@
         {   // positive, showbase
             std::string v = "USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -358,7 +358,7 @@
         {   // negative, showbase
             std::string v = "-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -371,7 +371,7 @@
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -383,7 +383,7 @@
         }
         {   // negative, showbase
             std::string v = "-$1,234,567.89";
-            typedef input_iterator<const char*> I;
+            typedef legacy_input_iterator<const char*> I;
             std::string ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -398,7 +398,7 @@
         // wchar_t, national
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -409,7 +409,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -420,7 +420,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -431,7 +431,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -442,7 +442,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -453,7 +453,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"$0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -465,7 +465,7 @@
         {   // zero, showbase
             std::wstring v = L"$0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -477,7 +477,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -489,7 +489,7 @@
         {   // negative one, showbase
             std::wstring v = L"-$0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -501,7 +501,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -513,7 +513,7 @@
         {   // positive, showbase
             std::wstring v = L"$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -526,7 +526,7 @@
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -539,7 +539,7 @@
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -551,7 +551,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -566,7 +566,7 @@
         // wchar_t, international
         {   // zero
             std::wstring v = L"0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -577,7 +577,7 @@
         }
         {   // negative one
             std::wstring v = L"-0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -588,7 +588,7 @@
         }
         {   // positive
             std::wstring v = L"1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -599,7 +599,7 @@
         }
         {   // negative
             std::wstring v = L"-1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -610,7 +610,7 @@
         }
         {   // negative
             std::wstring v = L"-1234567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -621,7 +621,7 @@
         }
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -633,7 +633,7 @@
         {   // zero, showbase
             std::wstring v = L"USD 0.00";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -645,7 +645,7 @@
         }
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -657,7 +657,7 @@
         {   // negative one, showbase
             std::wstring v = L"-USD 0.01";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -669,7 +669,7 @@
         }
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -681,7 +681,7 @@
         {   // positive, showbase
             std::wstring v = L"USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -694,7 +694,7 @@
         {   // negative, showbase
             std::wstring v = L"-USD 1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -707,7 +707,7 @@
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
             showbase(ios);
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
@@ -719,7 +719,7 @@
         }
         {   // negative, showbase
             std::wstring v = L"-$1,234,567.89";
-            typedef input_iterator<const wchar_t*> I;
+            typedef legacy_input_iterator<const wchar_t*> I;
             std::wstring ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
             I iter = f.get(I(v.data()), I(v.data() + v.size()),
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -60,9 +60,9 @@
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -72,9 +72,9 @@
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -84,9 +84,9 @@
         const char str[] = "12";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -96,9 +96,9 @@
         const char str[] = "*12";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+0);
         assert(err == ios.failbit);
@@ -109,9 +109,9 @@
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+0);
         assert(err == ios.failbit);
@@ -121,9 +121,9 @@
         const char str[] = "true";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -133,9 +133,9 @@
         const char str[] = "false";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, b);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -146,9 +146,9 @@
         const char str[] = "a";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+1),
                   ios, err, b);
         assert(iter.base() == str+1);
         assert(err == ios.eofbit);
@@ -158,9 +158,9 @@
         const char str[] = "abc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+3),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+3),
                   ios, err, b);
         assert(iter.base() == str+2);
         assert(err == ios.failbit);
@@ -170,9 +170,9 @@
         const char str[] = "acc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+3),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+3),
                   ios, err, b);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
@@ -183,9 +183,9 @@
         const char str[] = "a";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+1),
                   ios, err, b);
         assert(iter.base() == str+1);
         assert(err == ios.eofbit);
@@ -195,9 +195,9 @@
         const char str[] = "ab";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+2),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+2),
                   ios, err, b);
         assert(iter.base() == str+2);
         assert(err == ios.eofbit);
@@ -207,9 +207,9 @@
         const char str[] = "abc";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+3),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+3),
                   ios, err, b);
         assert(iter.base() == str+2);
         assert(err == ios.goodbit);
@@ -219,9 +219,9 @@
         const char str[] = "ac";
         std::ios_base::iostate err = ios.goodbit;
         bool b;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+2),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+2),
                   ios, err, b);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "hexfloat.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -54,9 +54,9 @@
         assert((ios.flags() & ios.basefield) == ios.dec);
         assert(ios.getloc().name() == "C");
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -65,9 +65,9 @@
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -76,9 +76,9 @@
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -88,9 +88,9 @@
         const char str[] = "125e-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -100,9 +100,9 @@
         const char str[] = "0x125p-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -112,9 +112,9 @@
         const char str[] = "inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -124,9 +124,9 @@
         const char str[] = "INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -136,9 +136,9 @@
         const char str[] = "-inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -148,9 +148,9 @@
         const char str[] = "-INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -160,9 +160,9 @@
         const char str[] = "nan";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -172,9 +172,9 @@
         const char str[] = "NAN";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -184,9 +184,9 @@
         v = -1;
         const char str[] = "123_456_78_9;125";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+3);
         assert(err == ios.goodbit);
@@ -197,9 +197,9 @@
         v = -1;
         const char str[] = "2-";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
@@ -209,9 +209,9 @@
         v = -1;
         const char str[] = "1.79779e+309"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -221,9 +221,9 @@
         v = -1;
         const char str[] = "-1.79779e+308"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -234,9 +234,9 @@
         v = -1;
         const char str[] = "123_456_78_9;125";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -256,9 +256,9 @@
                            "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
                            "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -268,9 +268,9 @@
         v = -1;
         const char str[] = "3;14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+10";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "hexfloat.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -43,9 +43,9 @@
         assert((ios.flags() & ios.basefield) == ios.dec);
         assert(ios.getloc().name() == "C");
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -54,9 +54,9 @@
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -65,9 +65,9 @@
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -77,9 +77,9 @@
         const char str[] = "125e-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -89,9 +89,9 @@
         const char str[] = "0x125p-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -101,9 +101,9 @@
         const char str[] = "inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -113,9 +113,9 @@
         const char str[] = "INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -125,9 +125,9 @@
         const char str[] = "-inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -137,9 +137,9 @@
         const char str[] = "-INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -149,9 +149,9 @@
         const char str[] = "nan";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -161,9 +161,9 @@
         const char str[] = "NAN";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -173,9 +173,9 @@
         v = -1;
         const char str[] = "3.40283e+39"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -185,9 +185,9 @@
         v = -1;
         const char str[] = "-3.40283e+38"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -198,9 +198,9 @@
         v = -1;
         const char str[] = "2-";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp
@@ -30,7 +30,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -62,9 +62,9 @@
         assert((ios.flags() & ios.basefield) == ios.dec);
         assert(ios.getloc().name() == "C");
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+3);
         assert(err == ios.goodbit);
@@ -75,9 +75,9 @@
         assert((ios.flags() & ios.basefield) == ios.dec);
         assert(ios.getloc().name() == "C");
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+4);
         assert(err == ios.goodbit);
@@ -87,9 +87,9 @@
         const char str[] = "123";
         oct(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+3);
         assert(err == ios.goodbit);
@@ -99,9 +99,9 @@
         const char str[] = "123";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+3);
         assert(err == ios.goodbit);
@@ -111,9 +111,9 @@
         const char str[] = "0x123";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -123,9 +123,9 @@
         const char str[] = "123";
         ios.setf(zf, ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -135,9 +135,9 @@
         const char str[] = "0x123";
         ios.setf(zf, ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -147,9 +147,9 @@
         const char str[] = "0123";
         ios.setf(zf, ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -160,9 +160,9 @@
         const char str[] = "2-";
         ios.setf(zf, ios.basefield);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
@@ -174,9 +174,9 @@
         v = -1;
         const char str[] = "123"; // no separators at all
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -186,9 +186,9 @@
         v = -1;
         const char str[] = "+1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -198,9 +198,9 @@
         v = -1;
         const char str[] = "+1_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -210,9 +210,9 @@
         v = -1;
         const char str[] = "+_1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -222,9 +222,9 @@
         v = -1;
         const char str[] = "_+1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -234,9 +234,9 @@
         v = -1;
         const char str[] = "+1__";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -246,9 +246,9 @@
         v = -1;
         const char str[] = "+_1_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -258,9 +258,9 @@
         v = -1;
         const char str[] = "_+1_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -270,9 +270,9 @@
         v = -1;
         const char str[] = "+__1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -282,9 +282,9 @@
         v = -1;
         const char str[] = "_+_1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -294,9 +294,9 @@
         v = -1;
         const char str[] = "__+1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -306,9 +306,9 @@
         v = -1;
         const char str[] = "+1_2";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -318,9 +318,9 @@
         v = -1;
         const char str[] = "+12_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -330,9 +330,9 @@
         v = -1;
         const char str[] = "+_12";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -342,9 +342,9 @@
         v = -1;
         const char str[] = "+1__2";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -354,9 +354,9 @@
         v = -1;
         const char str[] = "+12_3";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -366,9 +366,9 @@
         v = -1;
         const char str[] = "+1_23";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -378,9 +378,9 @@
         v = -1;
         const char str[] = "+1_23_4";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -390,9 +390,9 @@
         v = -1;
         const char str[] = "+123_4";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -402,9 +402,9 @@
         v = -1;
         const char str[] = "+12_34";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -414,9 +414,9 @@
         v = -1;
         const char str[] = "+12_34_5";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -426,9 +426,9 @@
         v = -1;
         const char str[] = "+123_45_6";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -438,9 +438,9 @@
         v = -1;
         const char str[] = "+1_23_45_6";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -450,9 +450,9 @@
         v = -1;
         const char str[] = "+1_234_56_7";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -462,9 +462,9 @@
         v = -1;
         const char str[] = "+1_234_567_89_0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -474,9 +474,9 @@
         v = -1;
         const char str[] = "-1_234_567_89_0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -486,9 +486,9 @@
         v = -1;
         const char str[] = "1_234_567_89_0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -498,9 +498,9 @@
         v = -1;
         const char str[] = "1234_567_89_0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -520,9 +520,9 @@
                            "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_"
                            "1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_1_2_3_4_5_6_7_8_9_0_";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -22,7 +22,7 @@
 #include "test_iterators.h"
 #include "hexfloat.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -43,9 +43,9 @@
         assert((ios.flags() & ios.basefield) == ios.dec);
         assert(ios.getloc().name() == "C");
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -54,9 +54,9 @@
     {
         const char str[] = "-123";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -65,9 +65,9 @@
     {
         const char str[] = "123.5";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -77,9 +77,9 @@
         const char str[] = "125e-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -89,9 +89,9 @@
         const char str[] = "0x125p-1";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -101,9 +101,9 @@
         const char str[] = "inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -113,9 +113,9 @@
         const char str[] = "INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -125,9 +125,9 @@
         const char str[] = "-inf";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -137,9 +137,9 @@
         const char str[] = "-INF";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -149,9 +149,9 @@
         const char str[] = "nan";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -161,9 +161,9 @@
         const char str[] = "NAN";
         hex(ios);
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -173,9 +173,9 @@
         const char str[] = "1.189731495357231765021264e+49321";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -185,9 +185,9 @@
         const char str[] = "1.189731495357231765021264e+49329";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -197,9 +197,9 @@
         const char str[] = "11.189731495357231765021264e+4932";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -209,9 +209,9 @@
         const char str[] = "91.189731495357231765021264e+4932";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -221,9 +221,9 @@
         const char str[] = "304888344611713860501504000000";
         std::ios_base::iostate err = ios.goodbit;
         v = 0;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err != ios.failbit);
@@ -233,9 +233,9 @@
         v = -1;
         const char str[] = "1.19973e+4933"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -245,9 +245,9 @@
         v = -1;
         const char str[] = "-1.18974e+4932"; // unrepresentable
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -257,9 +257,9 @@
         v = -1;
         const char str[] = "2-";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -49,9 +49,9 @@
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -60,9 +60,9 @@
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -71,9 +71,9 @@
     {
         const char str[] = "-1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -83,9 +83,9 @@
     {
         const char str[] = "0x7FFFFFFFFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -94,9 +94,9 @@
     {
         const char str[] = "-0x8000000000000000";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -38,9 +38,9 @@
         const char str[] = "0x0";
         std::ios_base::iostate err = ios.goodbit;
         void* p;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, p);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -50,9 +50,9 @@
         const char str[] = "0x73";
         std::ios_base::iostate err = ios.goodbit;
         void* p;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, p);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -49,9 +49,9 @@
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -60,9 +60,9 @@
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -72,9 +72,9 @@
     {
         const char str[] = "0xFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -49,9 +49,9 @@
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -60,9 +60,9 @@
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -72,9 +72,9 @@
     {
         const char str[] = "0xFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -49,9 +49,9 @@
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -60,9 +60,9 @@
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -72,9 +72,9 @@
     {
         const char str[] = "0xFFFFFFFFFFFFFFFF";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -49,9 +49,9 @@
     {
         const char str[] = "0";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -60,9 +60,9 @@
     {
         const char str[] = "1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -72,9 +72,9 @@
     {
         const char str[] = "0xFFFF";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp
@@ -26,7 +26,7 @@
 #pragma warning(disable: 4146) // unary minus operator applied to unsigned type, result still unsigned
 #endif
 
-typedef std::num_get<char, input_iterator<const char*> > F;
+typedef std::num_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
@@ -52,9 +52,9 @@
     {
         const char str[] = "-1";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
@@ -64,9 +64,9 @@
     {
         const char str[] = "-";
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+sizeof(str)),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+sizeof(str)),
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.failbit);
@@ -87,9 +87,9 @@
         const char* str = std_str.data();
         size_t size = std_str.size();
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+size+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+size+1),
                   ios, err, v);
         assert(iter.base() == str+size);
         assert(err == ios.goodbit);
@@ -105,9 +105,9 @@
         const char* str = std_str.data();
         size_t size = std_str.size();
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+size+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+size+1),
                   ios, err, v);
         assert(iter.base() == str+size);
         assert(err == ios.goodbit);
@@ -121,9 +121,9 @@
         const char* str = std_str.data();
         size_t size = std_str.size();
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+size+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+size+1),
                   ios, err, v);
         assert(iter.base() == str+size);
         assert(err == ios.goodbit);
@@ -137,9 +137,9 @@
         const char* str = std_str.data();
         size_t size = std_str.size();
         std::ios_base::iostate err = ios.goodbit;
-        input_iterator<const char*> iter =
-            f.get(input_iterator<const char*>(str),
-                  input_iterator<const char*>(str+size+1),
+        legacy_input_iterator<const char*> iter =
+            f.get(legacy_input_iterator<const char*>(str),
+                  legacy_input_iterator<const char*>(str+size+1),
                   ios, err, v);
         assert(iter.base() == str+size);
         assert(err == ios.failbit);
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef std::time_get_byname<char, input_iterator<const char*> > F;
+typedef std::time_get_byname<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef std::time_get_byname<wchar_t, input_iterator<const wchar_t*> > F;
+typedef std::time_get_byname<wchar_t, legacy_input_iterator<const wchar_t*> > F;
 
 class my_facet
     : public F
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp
@@ -25,7 +25,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp
@@ -27,7 +27,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp
@@ -31,7 +31,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp
@@ -29,7 +29,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get_byname<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "platform_support.h" // locale name macros
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get_byname<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp
@@ -17,7 +17,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef std::time_get<char, input_iterator<const char*> > F;
+typedef std::time_get<char, legacy_input_iterator<const char*> > F;
 
 class my_facet
     : public F
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const wchar_t*> I;
+typedef legacy_input_iterator<const wchar_t*> I;
 
 typedef std::time_get<wchar_t, I> F;
 
diff --git a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
--- a/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
+++ b/libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp
@@ -19,7 +19,7 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
-typedef input_iterator<const char*> I;
+typedef legacy_input_iterator<const char*> I;
 
 typedef std::time_get<char, I> F;
 
diff --git a/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp b/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
@@ -49,10 +49,10 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
@@ -103,10 +103,10 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp b/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -81,34 +81,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER >= 11
diff --git a/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -142,34 +142,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER >= 11
diff --git a/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp b/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -97,10 +97,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -68,10 +68,10 @@
 test()
 {
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -103,10 +103,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -107,10 +107,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -124,10 +124,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp b/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
@@ -54,34 +54,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
 
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
 
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
 
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
 
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp b/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
@@ -119,34 +119,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, input_iterator<const int*> >();
-    test<input_iterator<const int*>, forward_iterator<const int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<input_iterator<const int*>, random_access_iterator<const int*> >();
-    test<input_iterator<const int*>, const int*>();
-
-    test<forward_iterator<const int*>, input_iterator<const int*> >();
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<forward_iterator<const int*>, const int*>();
-
-    test<bidirectional_iterator<const int*>, input_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, const int*>();
-
-    test<random_access_iterator<const int*>, input_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, const int*>();
-
-    test<const int*, input_iterator<const int*> >();
-    test<const int*, forward_iterator<const int*> >();
-    test<const int*, bidirectional_iterator<const int*> >();
-    test<const int*, random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*>, const int*>();
+
+    test<legacy_forward_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, const int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, const int*>();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, const int*>();
+
+    test<const int*, legacy_input_iterator<const int*> >();
+    test<const int*, legacy_forward_iterator<const int*> >();
+    test<const int*, legacy_bidirectional_iterator<const int*> >();
+    test<const int*, legacy_random_access_iterator<const int*> >();
     test<const int*, const int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp b/libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp
@@ -35,9 +35,9 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<forward_iterator<int*> >();
-    test<bidirectional_iterator<int*> >();
-    test<random_access_iterator<int*> >();
+    test<legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<int*> >();
     test<int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp b/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
@@ -42,34 +42,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
 
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
 
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
 
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
@@ -102,34 +102,34 @@
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
-    test<input_iterator<const int*>, output_iterator<int*> >();
-    test<input_iterator<const int*>, forward_iterator<int*> >();
-    test<input_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<input_iterator<const int*>, random_access_iterator<int*> >();
-    test<input_iterator<const int*>, int*>();
-
-    test<forward_iterator<const int*>, output_iterator<int*> >();
-    test<forward_iterator<const int*>, forward_iterator<int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<int*> >();
-    test<forward_iterator<const int*>, int*>();
-
-    test<bidirectional_iterator<const int*>, output_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<int*> >();
-    test<bidirectional_iterator<const int*>, int*>();
-
-    test<random_access_iterator<const int*>, output_iterator<int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<int*> >();
-    test<random_access_iterator<const int*>, int*>();
+    test<legacy_input_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_input_iterator<const int*>, int*>();
+
+    test<legacy_forward_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_forward_iterator<const int*>, int*>();
+
+    test<legacy_bidirectional_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_bidirectional_iterator<const int*>, int*>();
+
+    test<legacy_random_access_iterator<const int*>, output_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<int*> >();
+    test<legacy_random_access_iterator<const int*>, int*>();
 
     test<const int*, output_iterator<int*> >();
-    test<const int*, forward_iterator<int*> >();
-    test<const int*, bidirectional_iterator<int*> >();
-    test<const int*, random_access_iterator<int*> >();
+    test<const int*, legacy_forward_iterator<int*> >();
+    test<const int*, legacy_bidirectional_iterator<int*> >();
+    test<const int*, legacy_random_access_iterator<int*> >();
     test<const int*, int*>();
 
 #if TEST_STD_VER > 17
diff --git a/libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp b/libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp
@@ -60,10 +60,10 @@
     test_return_type<float>();
     test_return_type<double>();
 
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp b/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp
@@ -64,10 +64,10 @@
     test_return_type<double, char>();
     test_return_type<char, double>();
 
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
     return true;
diff --git a/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -64,10 +64,10 @@
     test_return_type<double, char>();
     test_return_type<char, double>();
 
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
 
 //  Make sure the math is done using the correct type
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -150,10 +150,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -122,10 +122,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -152,10 +152,10 @@
     basic_tests();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -109,10 +109,10 @@
     test_return_type<char, double>();
 
 //  All the iterator categories
-    test<input_iterator        <const int*> >();
-    test<forward_iterator      <const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
+    test<legacy_input_iterator        <const int*> >();
+    test<legacy_forward_iterator      <const int*> >();
+    test<legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp
@@ -83,25 +83,25 @@
     test_return_type<char, double>();
 
 //  All the iterator categories
-    test<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
-    test<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
-    test<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
-    test<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
-    test<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
-    test<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_forward_iterator      <const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const unsigned int*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
diff --git a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp
@@ -87,25 +87,25 @@
     test_return_type<char, double>();
 
 //  All the iterator categories
-    test<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
-    test<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
-    test<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
-    test<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
-    test<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
-
-    test<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
-    test<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_input_iterator        <const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_forward_iterator      <const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_forward_iterator      <const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_bidirectional_iterator<const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const unsigned int*> >();
+
+    test<legacy_random_access_iterator<const int*>, legacy_input_iterator        <const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator      <const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const unsigned int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const unsigned int*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp
@@ -629,8 +629,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1269,8 +1269,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp
@@ -631,8 +631,8 @@
     {
         const char r[] = "^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::basic);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1258,8 +1258,8 @@
     {
         const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp
@@ -624,8 +624,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr));
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1259,8 +1259,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr));
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp
@@ -646,8 +646,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1289,8 +1289,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp
@@ -30,7 +30,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -42,7 +42,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -55,7 +55,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -68,7 +68,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -81,7 +81,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -94,7 +94,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
diff --git a/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp
@@ -30,7 +30,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -42,7 +42,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -55,7 +55,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -68,7 +68,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -81,7 +81,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
@@ -94,7 +94,7 @@
         std::regex phone_numbers("\\d{3}-\\d{4}");
         const char phone_book[] = "555-1234, 555-2345, 555-3456";
         typedef output_iterator<char*> Out;
-        typedef bidirectional_iterator<const char*> Bi;
+        typedef legacy_bidirectional_iterator<const char*> Bi;
         char buf[100] = {0};
         Out r = std::regex_replace(Out(buf), Bi(std::begin(phone_book)),
                                     Bi(std::end(phone_book)-1), phone_numbers,
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp
@@ -719,8 +719,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::awk);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1449,8 +1449,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::awk);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp
@@ -721,8 +721,8 @@
     {
         const char r[] = "^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::basic);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1438,8 +1438,8 @@
     {
         const wchar_t r[] = L"^[-+]\\{0,1\\}[0-9]\\{1,\\}[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::basic);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp
@@ -699,8 +699,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr));
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1439,8 +1439,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr));
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp b/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp
--- a/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp
+++ b/libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp
@@ -737,8 +737,8 @@
     {
         const char r[] = "^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<char>::length(r);
-        typedef forward_iterator<const char*> FI;
-        typedef bidirectional_iterator<const char*> BI;
+        typedef legacy_forward_iterator<const char*> FI;
+        typedef legacy_bidirectional_iterator<const char*> BI;
         std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended);
         std::match_results<BI> m;
         const char s[] = "-40C";
@@ -1470,8 +1470,8 @@
     {
         const wchar_t r[] = L"^[-+]?[0-9]+[CF]$";
         std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
-        typedef forward_iterator<const wchar_t*> FI;
-        typedef bidirectional_iterator<const wchar_t*> BI;
+        typedef legacy_forward_iterator<const wchar_t*> FI;
+        typedef legacy_bidirectional_iterator<const wchar_t*> BI;
         std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
         std::match_results<BI> m;
         const wchar_t s[] = L"-40C";
diff --git a/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
--- a/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp
@@ -23,8 +23,8 @@
 
 int main(int, char**)
 {
-    typedef input_iterator<std::string::const_iterator> I;
-    typedef forward_iterator<std::string::const_iterator> F;
+    typedef legacy_input_iterator<std::string::const_iterator> I;
+    typedef legacy_forward_iterator<std::string::const_iterator> F;
     std::string s4("(a([bc]))");
     std::regex r2;
 
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
--- a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp
@@ -30,7 +30,7 @@
 
 int main(int, char**)
 {
-    typedef forward_iterator<std::string::const_iterator> F;
+    typedef legacy_forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
     std::string s2("\\(a[bc]\\)");
     std::string s3("\\(a\\([bc]\\)\\)");
diff --git a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
--- a/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
+++ b/libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp
@@ -31,7 +31,7 @@
 
 int main(int, char**)
 {
-    typedef forward_iterator<std::string::const_iterator> F;
+    typedef legacy_forward_iterator<std::string::const_iterator> F;
     std::string s1("\\(a\\)");
     std::string s2("\\(a[bc]\\)");
     std::string s3("\\(a\\([bc]\\)\\)");
diff --git a/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp b/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
--- a/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
+++ b/libcxx/test/std/re/re.traits/lookup_classname.pass.cpp
@@ -30,7 +30,7 @@
 {
     typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
     std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
+    typedef legacy_forward_iterator<const char_type*> F;
     char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
     assert(result == expected);
 }
@@ -43,7 +43,7 @@
 {
     typedef typename std::regex_traits<char_type>::char_class_type char_class_type;
     std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
+    typedef legacy_forward_iterator<const char_type*> F;
     char_class_type result = t.lookup_classname(F(A), F(A + t.length(A)), icase);
     assert((result & expected) == expected);
     LIBCPP_ASSERT((expected | std::regex_traits<char_type>::__regex_word) == result);
diff --git a/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp b/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
--- a/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
+++ b/libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp
@@ -35,7 +35,7 @@
 test(const char_type* A, const std::basic_string<char_type>& expected)
 {
     std::regex_traits<char_type> t;
-    typedef forward_iterator<const char_type*> F;
+    typedef legacy_forward_iterator<const char_type*> F;
     assert(t.lookup_collatename(F(A), F(A + t.length(A))) == expected);
 }
 
diff --git a/libcxx/test/std/re/re.traits/transform.pass.cpp b/libcxx/test/std/re/re.traits/transform.pass.cpp
--- a/libcxx/test/std/re/re.traits/transform.pass.cpp
+++ b/libcxx/test/std/re/re.traits/transform.pass.cpp
@@ -31,7 +31,7 @@
         std::regex_traits<char> t;
         const char a[] = "a";
         const char B[] = "B";
-        typedef forward_iterator<const char*> F;
+        typedef legacy_forward_iterator<const char*> F;
         assert(t.transform(F(a), F(a+1)) > t.transform(F(B), F(B+1)));
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
         assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
@@ -40,7 +40,7 @@
         std::regex_traits<wchar_t> t;
         const wchar_t a[] = L"a";
         const wchar_t B[] = L"B";
-        typedef forward_iterator<const wchar_t*> F;
+        typedef legacy_forward_iterator<const wchar_t*> F;
         assert(t.transform(F(a), F(a+1)) > t.transform(F(B), F(B+1)));
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
         assert(t.transform(F(a), F(a+1)) < t.transform(F(B), F(B+1)));
diff --git a/libcxx/test/std/re/re.traits/transform_primary.pass.cpp b/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
--- a/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
+++ b/libcxx/test/std/re/re.traits/transform_primary.pass.cpp
@@ -33,7 +33,7 @@
         std::regex_traits<char> t;
         const char A[] = "A";
         const char Aacute[] = "\xC1";
-        typedef forward_iterator<const char*> F;
+        typedef legacy_forward_iterator<const char*> F;
         assert(t.transform_primary(F(A), F(A+1)) !=
                t.transform_primary(F(Aacute), F(Aacute+1)));
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
@@ -44,7 +44,7 @@
         std::regex_traits<wchar_t> t;
         const wchar_t A[] = L"A";
         const wchar_t Aacute[] = L"\xC1";
-        typedef forward_iterator<const wchar_t*> F;
+        typedef legacy_forward_iterator<const wchar_t*> F;
         assert(t.transform_primary(F(A), F(A+1)) !=
                t.transform_primary(F(Aacute), F(Aacute+1)));
         t.imbue(std::locale(LOCALE_cs_CZ_ISO8859_2));
diff --git a/libcxx/test/std/strings/basic.string/input_iterator.h b/libcxx/test/std/strings/basic.string/legacy_input_iterator.h
rename from libcxx/test/std/strings/basic.string/input_iterator.h
rename to libcxx/test/std/strings/basic.string/legacy_input_iterator.h
--- a/libcxx/test/std/strings/basic.string/input_iterator.h
+++ b/libcxx/test/std/strings/basic.string/legacy_input_iterator.h
@@ -12,7 +12,7 @@
 #include <iterator>
 
 template <class It>
-class input_iterator
+class legacy_input_iterator
 {
     It it_;
 public:
@@ -22,18 +22,18 @@
     typedef It                                                 pointer;
     typedef typename std::iterator_traits<It>::reference       reference;
 
-    input_iterator() : it_() {}
-    explicit input_iterator(It it) : it_(it) {}
+    legacy_input_iterator() : it_() {}
+    explicit legacy_input_iterator(It it) : it_(it) {}
 
     reference operator*() const {return *it_;}
     pointer operator->() const {return it_;}
 
-    input_iterator& operator++() {++it_; return *this;}
-    input_iterator operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;}
+    legacy_input_iterator& operator++() {++it_; return *this;}
+    legacy_input_iterator operator++(int) {legacy_input_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend bool operator==(const input_iterator& x, const input_iterator& y)
+    friend bool operator==(const legacy_input_iterator& x, const legacy_input_iterator& y)
         {return x.it_ == y.it_;}
-    friend bool operator!=(const input_iterator& x, const input_iterator& y)
+    friend bool operator!=(const legacy_input_iterator& x, const legacy_input_iterator& y)
         {return !(x == y);}
 };
 
diff --git a/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp
@@ -175,7 +175,7 @@
     assert(w == L"abcdef");
   }
   { // (8) w/o allocator
-    using It = input_iterator<const char*>;
+    using It = legacy_input_iterator<const char*>;
     const char* input = "abcdef";
     std::basic_string s(It(input), It(input + 3), std::allocator<char>{});
     ASSERT_SAME_TYPE(decltype(s), std::string);
@@ -183,7 +183,7 @@
   }
   { // (8) w/ allocator
     using ExpectW = std::basic_string<wchar_t, std::char_traits<wchar_t>, test_allocator<wchar_t>>;
-    using It = input_iterator<const wchar_t*>;
+    using It = legacy_input_iterator<const wchar_t*>;
     const wchar_t* input = L"abcdef";
     std::basic_string s(It(input), It(input + 3), test_allocator<wchar_t>{});
     ASSERT_SAME_TYPE(decltype(s), ExpectW);
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp
@@ -20,7 +20,7 @@
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../legacy_input_iterator.h"
 #include "min_allocator.h"
 
 template <class It>
@@ -74,17 +74,17 @@
     test(s, s+50);
     test(s, s+50, A(2));
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s), A(2));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), A(2));
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A(2));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), A(2));
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+10));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A(2));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), A(2));
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+50));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A(2));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+50));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+50), A(2));
     }
 #if TEST_STD_VER >= 11
     {
@@ -103,17 +103,17 @@
     test(s, s+50);
     test(s, s+50, A());
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s), A());
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), A());
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+1));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+1), A());
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), A());
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+10));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+10), A());
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), A());
 
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+50));
-    test(input_iterator<const char*>(s), input_iterator<const char*>(s+50), A());
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+50));
+    test(legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+50), A());
     }
 #endif
     {
diff --git a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp
@@ -33,7 +33,7 @@
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../legacy_input_iterator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../legacy_input_iterator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp b/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp
@@ -39,7 +39,7 @@
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../input_iterator.h"
+#include "../legacy_input_iterator.h"
 #include "min_allocator.h"
 
 int main(int, char**)
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -69,38 +69,38 @@
     test(S("12345678901234567890"), s, s+52,
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("12345"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("12345A"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("12345ABCDEFGHIJ"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("1234567890"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("1234567890A"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("12345678901234567890"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #if TEST_STD_VER >= 11
@@ -128,38 +128,38 @@
     test(S("12345678901234567890"), s, s+52,
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("12345"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("12345A"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("12345ABCDEFGHIJ"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("1234567890"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("1234567890A"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S("12345678901234567890"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("12345678901234567890""A"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("12345678901234567890""ABCDEFGHIJ"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345678901234567890""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
@@ -167,7 +167,7 @@
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
-    typedef input_iterator<TIter> IIter;
+    typedef legacy_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
@@ -205,7 +205,7 @@
     }
 
   { // test with a move iterator that returns char&&
-    typedef forward_iterator<const char*> It;
+    typedef legacy_forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -69,38 +69,38 @@
     test(S("12345678901234567890"), s, s+52,
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #if TEST_STD_VER >= 11
@@ -128,38 +128,38 @@
     test(S("12345678901234567890"), s, s+52,
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S(), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("12345"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("1234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("1234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s),
          S());
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+1),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1),
          S("A"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+10),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10),
          S("ABCDEFGHIJ"));
-    test(S("12345678901234567890"), input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S("12345678901234567890"), legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
@@ -167,7 +167,7 @@
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
-    typedef input_iterator<TIter> IIter;
+    typedef legacy_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
     test_exceptions(S(), IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -72,25 +72,25 @@
     test(S("12345678901234567890"), 20, s, s+52,
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345"));
-    test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345"));
-    test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890"));
-    test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890"));
-    test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
-
-    test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890"));
-    test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890"));
-    test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
-    test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+    test(S("12345"), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("12345"));
+    test(S("12345"), 1, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("1A2345"));
+    test(S("12345"), 4, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
+    test(S("12345"), 5, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+    test(S("1234567890"), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("1234567890"));
+    test(S("1234567890"), 1, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("1A234567890"));
+    test(S("1234567890"), 10, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
+    test(S("1234567890"), 8, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
+
+    test(S("12345678901234567890"), 3, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("12345678901234567890"));
+    test(S("12345678901234567890"), 3, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("123A45678901234567890"));
+    test(S("12345678901234567890"), 15, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
+    test(S("12345678901234567890"), 20, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #if TEST_STD_VER >= 11
@@ -118,25 +118,25 @@
     test(S("12345678901234567890"), 20, s, s+52,
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
 
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S());
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("A"));
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
-    test(S(), 0, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("12345"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345"));
-    test(S("12345"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A2345"));
-    test(S("12345"), 4, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
-    test(S("12345"), 5, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
-
-    test(S("1234567890"), 0, input_iterator<const char*>(s), input_iterator<const char*>(s), S("1234567890"));
-    test(S("1234567890"), 1, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("1A234567890"));
-    test(S("1234567890"), 10, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
-    test(S("1234567890"), 8, input_iterator<const char*>(s), input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
-
-    test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s), S("12345678901234567890"));
-    test(S("12345678901234567890"), 3, input_iterator<const char*>(s), input_iterator<const char*>(s+1), S("123A45678901234567890"));
-    test(S("12345678901234567890"), 15, input_iterator<const char*>(s), input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
-    test(S("12345678901234567890"), 20, input_iterator<const char*>(s), input_iterator<const char*>(s+52),
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S());
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("A"));
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("ABCDEFGHIJ"));
+    test(S(), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+    test(S("12345"), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("12345"));
+    test(S("12345"), 1, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("1A2345"));
+    test(S("12345"), 4, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("1234ABCDEFGHIJ5"));
+    test(S("12345"), 5, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("12345ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
+
+    test(S("1234567890"), 0, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("1234567890"));
+    test(S("1234567890"), 1, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("1A234567890"));
+    test(S("1234567890"), 10, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("1234567890ABCDEFGHIJ"));
+    test(S("1234567890"), 8, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52), S("12345678ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz90"));
+
+    test(S("12345678901234567890"), 3, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s), S("12345678901234567890"));
+    test(S("12345678901234567890"), 3, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+1), S("123A45678901234567890"));
+    test(S("12345678901234567890"), 15, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+10), S("123456789012345ABCDEFGHIJ67890"));
+    test(S("12345678901234567890"), 20, legacy_input_iterator<const char*>(s), legacy_input_iterator<const char*>(s+52),
          S("12345678901234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
     }
 #endif
@@ -144,7 +144,7 @@
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
-    typedef input_iterator<TIter> IIter;
+    typedef legacy_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
@@ -182,7 +182,7 @@
     }
 
   { // test with a move iterator that returns char&&
-    typedef input_iterator<const char*> It;
+    typedef legacy_input_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
@@ -190,7 +190,7 @@
     assert(s == "ABCD");
   }
   { // test with a move iterator that returns char&&
-    typedef forward_iterator<const char*> It;
+    typedef legacy_forward_iterator<const char*> It;
     typedef std::move_iterator<It> MoveIt;
     const char p[] = "ABCD";
     std::string s;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -996,7 +996,7 @@
     { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
-    typedef input_iterator<TIter> IIter;
+    typedef legacy_input_iterator<TIter> IIter;
     const char* s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 4, TIter::TAIncrement)), IIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp
@@ -124,8 +124,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp
@@ -120,8 +120,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp
@@ -138,8 +138,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp
@@ -129,8 +129,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp
@@ -124,8 +124,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp
@@ -119,8 +119,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp
@@ -132,8 +132,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp
@@ -126,8 +126,8 @@
 }
 
 int main(int, char**) {
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
-    test2<random_access_iterator<const char*>, random_access_iterator<const char*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test2<legacy_random_access_iterator<const char*>, legacy_random_access_iterator<const char*> >();
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp
@@ -87,26 +87,26 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<forward_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<forward_iterator<const int*>, random_access_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>>());
 #endif
 
     return 0;
diff --git a/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp b/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp
@@ -96,26 +96,26 @@
 }
 
 int main(int, char**) {
-    test<forward_iterator<const int*>, forward_iterator<const int*> >();
-    test<forward_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<forward_iterator<const int*>, random_access_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >();
-    test<random_access_iterator<const int*>, forward_iterator<const int*> >();
-    test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*>, random_access_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*> >();
+    test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*> >();
 
 #if TEST_STD_VER >= 20
-    static_assert(test<forward_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<forward_iterator<const int*>, random_access_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, forward_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<const int*>>());
-    static_assert(test<random_access_iterator<const int*>, random_access_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_forward_iterator<const int*>, legacy_random_access_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_bidirectional_iterator<const int*>, legacy_random_access_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_forward_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_bidirectional_iterator<const int*>>());
+    static_assert(test<legacy_random_access_iterator<const int*>, legacy_random_access_iterator<const int*>>());
 #endif
 
     return 0;
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp
@@ -46,7 +46,7 @@
     std::destroy(pool, pool + 1);
     assert(counter == 4);
 
-    std::destroy(forward_iterator<Counted*>(pool + 1), forward_iterator<Counted*>(pool + 5));
+    std::destroy(legacy_forward_iterator<Counted*>(pool + 1), legacy_forward_iterator<Counted*>(pool + 5));
     assert(counter == 0);
 
     std::allocator_traits<Alloc>::deallocate(alloc, pool, N);
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp
@@ -47,8 +47,8 @@
     assert(np == pool + 1);
     assert(counter == 4);
 
-    forward_iterator<Counted*> it = std::destroy_n(forward_iterator<Counted*>(pool + 1), 4);
-    assert(it == forward_iterator<Counted*>(pool + 5));
+    legacy_forward_iterator<Counted*> it = std::destroy_n(legacy_forward_iterator<Counted*>(pool + 1), 4);
+    assert(it == legacy_forward_iterator<Counted*>(pool + 5));
     assert(counter == 0);
 
     std::allocator_traits<Alloc>::deallocate(alloc, pool, N);
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp
@@ -57,7 +57,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
@@ -73,7 +73,7 @@
 
 void test_counted()
 {
-    using It = forward_iterator<Counted*>;
+    using It = legacy_forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
@@ -89,7 +89,7 @@
 
 void test_value_initialized()
 {
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     const int N = 5;
     int pool[N] = {-1, -1, -1, -1, -1};
     int* p = pool;
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp
@@ -56,7 +56,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
@@ -72,7 +72,7 @@
 
 void test_counted()
 {
-    using It = forward_iterator<Counted*>;
+    using It = legacy_forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
@@ -90,7 +90,7 @@
 
 void test_value_initialized()
 {
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     const int N = 5;
     int pool[N] = {-1, -1, -1, -1, -1};
     int* p = pool;
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp
@@ -56,7 +56,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
@@ -72,7 +72,7 @@
 
 void test_counted()
 {
-    using It = forward_iterator<Counted*>;
+    using It = legacy_forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
@@ -88,7 +88,7 @@
 
 void test_value_initialized()
 {
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     const int N = 5;
     int pool[N] = {-1, -1, -1, -1, -1};
     int* p = pool;
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -55,7 +55,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
     ThrowsCounted* p = (ThrowsCounted*)pool;
@@ -73,7 +73,7 @@
 
 void test_counted()
 {
-    using It = forward_iterator<Counted*>;
+    using It = legacy_forward_iterator<Counted*>;
     const int N = 5;
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
     Counted* p = (Counted*)pool;
@@ -91,7 +91,7 @@
 
 void test_value_initialized()
 {
-    using It = forward_iterator<int*>;
+    using It = legacy_forward_iterator<int*>;
     const int N = 5;
     int pool[N] = {-1, -1, -1, -1, -1};
     int* p = pool;
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -57,7 +57,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     int values[N] = {1, 2, 3, 4, 5};
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
@@ -79,8 +79,8 @@
 
 void test_counted()
 {
-    using It = input_iterator<int*>;
-    using FIt = forward_iterator<Counted*>;
+    using It = legacy_input_iterator<int*>;
+    using FIt = legacy_forward_iterator<Counted*>;
     const int N = 5;
     int values[N] = {1, 2, 3, 4, 5};
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
diff --git a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
--- a/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ b/libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -57,7 +57,7 @@
 void test_ctor_throws()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    using It = forward_iterator<ThrowsCounted*>;
+    using It = legacy_forward_iterator<ThrowsCounted*>;
     const int N = 5;
     int values[N] = {1, 2, 3, 4, 5};
     alignas(ThrowsCounted) char pool[sizeof(ThrowsCounted)*N] = {};
@@ -79,8 +79,8 @@
 
 void test_counted()
 {
-    using It = input_iterator<int*>;
-    using FIt = forward_iterator<Counted*>;
+    using It = legacy_input_iterator<int*>;
+    using FIt = legacy_forward_iterator<Counted*>;
     const int N = 5;
     int values[N] = {1, 2, 3, 4, 5};
     alignas(Counted) char pool[sizeof(Counted)*N] = {};
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -54,12 +54,12 @@
 
 template <class It,
     class ItTraits = It>
-class input_iterator
+class legacy_input_iterator
 {
     typedef std::iterator_traits<ItTraits> Traits;
     It it_;
 
-    template <class U, class T> friend class input_iterator;
+    template <class U, class T> friend class legacy_input_iterator;
 public:
     typedef          std::input_iterator_tag                   iterator_category;
     typedef typename Traits::value_type                        value_type;
@@ -69,21 +69,21 @@
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 input_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 input_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 legacy_input_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 legacy_input_iterator(It it) : it_(it) {}
     template <class U, class T>
-        TEST_CONSTEXPR_CXX14 input_iterator(const input_iterator<U, T>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 legacy_input_iterator(const legacy_input_iterator<U, T>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 input_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 input_iterator operator++(int)
-        {input_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_input_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_input_iterator operator++(int)
+        {legacy_input_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend TEST_CONSTEXPR_CXX14 bool operator==(const input_iterator& x, const input_iterator& y)
+    friend TEST_CONSTEXPR_CXX14 bool operator==(const legacy_input_iterator& x, const legacy_input_iterator& y)
         {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(const input_iterator& x, const input_iterator& y)
+    friend TEST_CONSTEXPR_CXX14 bool operator!=(const legacy_input_iterator& x, const legacy_input_iterator& y)
         {return !(x == y);}
 
     template <class T>
@@ -93,7 +93,7 @@
 template <class T, class TV, class U, class UV>
 inline
 bool
-operator==(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y)
+operator==(const legacy_input_iterator<T, TV>& x, const legacy_input_iterator<U, UV>& y)
 {
     return x.base() == y.base();
 }
@@ -101,17 +101,17 @@
 template <class T, class TV, class U, class UV>
 inline
 bool
-operator!=(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y)
+operator!=(const legacy_input_iterator<T, TV>& x, const legacy_input_iterator<U, UV>& y)
 {
     return !(x == y);
 }
 
 template <class It>
-class forward_iterator
+class legacy_forward_iterator
 {
     It it_;
 
-    template <class U> friend class forward_iterator;
+    template <class U> friend class legacy_forward_iterator;
 public:
     typedef          std::forward_iterator_tag                 iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
@@ -121,21 +121,21 @@
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 forward_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 forward_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 legacy_forward_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 legacy_forward_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 legacy_forward_iterator(const legacy_forward_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 forward_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 forward_iterator operator++(int)
-        {forward_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_forward_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_forward_iterator operator++(int)
+        {legacy_forward_iterator tmp(*this); ++(*this); return tmp;}
 
-    friend TEST_CONSTEXPR_CXX14 bool operator==(const forward_iterator& x, const forward_iterator& y)
+    friend TEST_CONSTEXPR_CXX14 bool operator==(const legacy_forward_iterator& x, const legacy_forward_iterator& y)
         {return x.it_ == y.it_;}
-    friend TEST_CONSTEXPR_CXX14 bool operator!=(const forward_iterator& x, const forward_iterator& y)
+    friend TEST_CONSTEXPR_CXX14 bool operator!=(const legacy_forward_iterator& x, const legacy_forward_iterator& y)
         {return !(x == y);}
 
     template <class T>
@@ -145,7 +145,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
+operator==(const legacy_forward_iterator<T>& x, const legacy_forward_iterator<U>& y)
 {
     return x.base() == y.base();
 }
@@ -153,17 +153,17 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
+operator!=(const legacy_forward_iterator<T>& x, const legacy_forward_iterator<U>& y)
 {
     return !(x == y);
 }
 
 template <class It>
-class bidirectional_iterator
+class legacy_bidirectional_iterator
 {
     It it_;
 
-    template <class U> friend class bidirectional_iterator;
+    template <class U> friend class legacy_bidirectional_iterator;
 public:
     typedef          std::bidirectional_iterator_tag           iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
@@ -173,21 +173,21 @@
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 bidirectional_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator(const legacy_bidirectional_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int)
-        {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator operator++(int)
+        {legacy_bidirectional_iterator tmp(*this); ++(*this); return tmp;}
 
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int)
-        {bidirectional_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator& operator--() {--it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator operator--(int)
+        {legacy_bidirectional_iterator tmp(*this); --(*this); return tmp;}
 
     template <class T>
     void operator,(T const &) DELETE_FUNCTION;
@@ -196,7 +196,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
+operator==(const legacy_bidirectional_iterator<T>& x, const legacy_bidirectional_iterator<U>& y)
 {
     return x.base() == y.base();
 }
@@ -204,17 +204,17 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
+operator!=(const legacy_bidirectional_iterator<T>& x, const legacy_bidirectional_iterator<U>& y)
 {
     return !(x == y);
 }
 
 template <class It>
-class random_access_iterator
+class legacy_random_access_iterator
 {
     It it_;
 
-    template <class U> friend class random_access_iterator;
+    template <class U> friend class legacy_random_access_iterator;
 public:
     typedef          std::random_access_iterator_tag           iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
@@ -224,30 +224,30 @@
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 random_access_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 random_access_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 legacy_random_access_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 legacy_random_access_iterator(const legacy_random_access_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 random_access_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator++(int)
-        {random_access_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator++(int)
+        {legacy_random_access_iterator tmp(*this); ++(*this); return tmp;}
 
-    TEST_CONSTEXPR_CXX14 random_access_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator--(int)
-        {random_access_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator--() {--it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator--(int)
+        {legacy_random_access_iterator tmp(*this); --(*this); return tmp;}
 
-    TEST_CONSTEXPR_CXX14 random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n) const
-        {random_access_iterator tmp(*this); tmp += n; return tmp;}
-    friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n, random_access_iterator x)
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator+(difference_type n) const
+        {legacy_random_access_iterator tmp(*this); tmp += n; return tmp;}
+    friend TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator+(difference_type n, legacy_random_access_iterator x)
         {x += n; return x;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator& operator-=(difference_type n) {return *this += -n;}
-    TEST_CONSTEXPR_CXX14 random_access_iterator operator-(difference_type n) const
-        {random_access_iterator tmp(*this); tmp -= n; return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator-=(difference_type n) {return *this += -n;}
+    TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator-(difference_type n) const
+        {legacy_random_access_iterator tmp(*this); tmp -= n; return tmp;}
 
     TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
 
@@ -258,7 +258,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator==(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return x.base() == y.base();
 }
@@ -266,7 +266,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator!=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return !(x == y);
 }
@@ -274,7 +274,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator<(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return x.base() < y.base();
 }
@@ -282,7 +282,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator<=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return !(y < x);
 }
@@ -290,7 +290,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator>(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return y < x;
 }
@@ -298,7 +298,7 @@
 template <class T, class U>
 inline
 bool TEST_CONSTEXPR_CXX14
-operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator>=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return !(x < y);
 }
@@ -306,20 +306,20 @@
 template <class T, class U>
 inline TEST_CONSTEXPR_CXX14
 typename std::iterator_traits<T>::difference_type
-operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+operator-(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
 {
     return x.base() - y.base();
 }
 
 #if TEST_STD_VER >= 20
 template <class It>
-class contiguous_iterator
+class legacy_contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
     It it_;
 
-    template <class U> friend class contiguous_iterator;
+    template <class U> friend class legacy_contiguous_iterator;
 public:
     typedef          std::contiguous_iterator_tag              iterator_category;
     typedef typename std::iterator_traits<It>::value_type      value_type;
@@ -330,30 +330,30 @@
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 contiguous_iterator() : it_() {}
-    explicit TEST_CONSTEXPR_CXX14 contiguous_iterator(It it) : it_(it) {}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator(It it) : it_(it) {}
     template <class U>
-        TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) : it_(u.it_) {}
+        TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator(const legacy_contiguous_iterator<U>& u) : it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
-    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator++() {++it_; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator++(int)
-        {contiguous_iterator tmp(*this); ++(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator++(int)
+        {legacy_contiguous_iterator tmp(*this); ++(*this); return tmp;}
 
-    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator--() {--it_; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator--(int)
-        {contiguous_iterator tmp(*this); --(*this); return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator--() {--it_; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator--(int)
+        {legacy_contiguous_iterator tmp(*this); --(*this); return tmp;}
 
-    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n) const
-        {contiguous_iterator tmp(*this); tmp += n; return tmp;}
-    friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n, contiguous_iterator x)
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator+(difference_type n) const
+        {legacy_contiguous_iterator tmp(*this); tmp += n; return tmp;}
+    friend TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator+(difference_type n, legacy_contiguous_iterator x)
         {x += n; return x;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
-    TEST_CONSTEXPR_CXX14 contiguous_iterator operator-(difference_type n) const
-        {contiguous_iterator tmp(*this); tmp -= n; return tmp;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
+    TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator-(difference_type n) const
+        {legacy_contiguous_iterator tmp(*this); tmp -= n; return tmp;}
 
     TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
 
@@ -361,32 +361,32 @@
     void operator,(T const &) DELETE_FUNCTION;
 
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator-(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator-(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() - y.base();
     }
 
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator<(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator<(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() < y.base();
     }
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator>(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator>(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() > y.base();
     }
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator<=(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator<=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() <= y.base();
     }
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator>=(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator>=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() >= y.base();
     }
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator==(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator==(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() == y.base();
     }
     friend TEST_CONSTEXPR_CXX14
-    difference_type operator!=(const contiguous_iterator& x, const contiguous_iterator& y) {
+    difference_type operator!=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
         return x.base() != y.base();
     }
 };
@@ -396,20 +396,20 @@
 inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(input_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(legacy_input_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(legacy_forward_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(legacy_bidirectional_iterator<Iter> i) { return i.base(); }
 
 template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(random_access_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(legacy_random_access_iterator<Iter> i) { return i.base(); }
 
 #if TEST_STD_VER >= 20
 template <class Iter>
-inline TEST_CONSTEXPR_CXX14 Iter base(contiguous_iterator<Iter> i) { return i.base(); }
+inline TEST_CONSTEXPR_CXX14 Iter base(legacy_contiguous_iterator<Iter> i) { return i.base(); }
 #endif
 
 template <class Iter>    // everything else