[libc++] Remove cpp17_input_iterator.h

[• Quuxplusone]

Seems plausible to me, but why on earth does this file exist? Shouldn't whoever-uses-it just be using test/support/test_iterators.h instead?
I notice that the header guard's name is incorrect too, and I assume that's simply an artifact of this file's getting accidentally caught up in the big input_iterator->cpp17_input_iterator rename circa last year.
Could you dig into whether we can just use test_iterators.h in the appropriate places and git rm this file?

[philnik]

• Remove cpp17_input_iterator.h

[• Quuxplusone]

Awesome, LGTM if CI is green.

Pre-existing issues that could be worth fixing in a followup PR if you're interested:

• iter_alloc.pass.cpp should be named iter_iter.pass.cpp/iter_iter_alloc.pass.cpp.
• It should test all the different test iterators, not just It=char* and It=cpp17_input_iterator<const char*>.
• It should be refactored in the obvious way to test<It>() instead of test(It, It), to cut down on repetition.

libcxx/test/std/strings/basic.string/cpp17_input_iterator.h

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef INPUT_ITERATOR_H
-#define INPUT_ITERATOR_H
-
-#include <iterator>
-
-template <class It>
-class cpp17_input_iterator
-{
-    It it_;
-public:
-    typedef typename std::input_iterator_tag                   iterator_category;
-    typedef typename std::iterator_traits<It>::value_type      value_type;
-    typedef typename std::iterator_traits<It>::difference_type difference_type;
-    typedef It                                                 pointer;
-    typedef typename std::iterator_traits<It>::reference       reference;
-
-    cpp17_input_iterator() : it_() {}
-    explicit cpp17_input_iterator(It it) : it_(it) {}
-
-    reference operator*() const {return *it_;}
-    pointer operator->() const {return it_;}
-
-    cpp17_input_iterator& operator++() {++it_; return *this;}
-    cpp17_input_iterator operator++(int) {cpp17_input_iterator tmp(*this); ++(*this); return tmp;}
-
-    friend bool operator==(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
-        {return x.it_ == y.it_;}
-    friend bool operator!=(const cpp17_input_iterator& x, const cpp17_input_iterator& y)
-        {return !(x == y);}
-};
-
-#endif // INPUT_ITERATOR_H

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

 
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../cpp17_input_iterator.h"
+#include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class It>
 TEST_CONSTEXPR_CXX20 void
 test(It first, It last)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, test_allocator<charT> > S;
     typedef typename S::allocator_type A;
     S s2(first, last);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
-    for (It it = first; it != last; ++it, ++i)
+    for (It it = first; it != last;) {
         assert(s2[i] == *it);
+        ++it;
+        ++i;
+    }
     assert(s2.get_allocator() == A());
     assert(s2.capacity() >= s2.size());
 }
 
 template <class It, class A>
 TEST_CONSTEXPR_CXX20 void
 test(It first, It last, const A& a)
 {
     typedef typename std::iterator_traits<It>::value_type charT;
     typedef std::basic_string<charT, std::char_traits<charT>, A> S;
     S s2(first, last, a);
     LIBCPP_ASSERT(s2.__invariants());
     assert(s2.size() == static_cast<std::size_t>(std::distance(first, last)));
     unsigned i = 0;
-    for (It it = first; it != last; ++it, ++i)
+    for (It it = first; it != last;) {
         assert(s2[i] == *it);
+        ++it;
+        ++i;
+    }
     assert(s2.get_allocator() == a);
     assert(s2.capacity() >= s2.size());
 }
 
 bool test() {
   {
     typedef test_allocator<char> A;
     const char* s = "12345678901234567890123456789012345678901234567890";

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

 
 #include <string>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
 bool test() {
   {
     const char* s = "12345678901234";
     std::basic_string s1(s, s+10);  // Can't use {} here
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1(sv);
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

 #include <string>
 #include <string_view>
 #include <iterator>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../cpp17_input_iterator.h"
 #include "min_allocator.h"
 
 bool test() {
   {
     std::string_view sv = "12345678901234";
     std::basic_string s1{sv, 0, 4};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");