[libcxx][iterator] adds `std::weakly_incrementable` and `std::incrementable`

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal`

Depends on D100073.

[cjdb]

renames all the cryptic types imported from cjdb-ranges

[cjdb]

corrects typo tanking CI

[cjdb]

updates synopsis, rebases to activate CI

[cjdb]

adds subsumption tests

[zoecarver]

This LGTM sans the small nits.

libcxx/include/iterator

1897

I assume this wasn't intentional.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp

202

(Non-blocking.) Does it really make sense to test vector and optional, particularly? It seems pretty obvious that these aren't incrementable.

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp

53

You test this exact same thing in the other file. Let's only test it in one place (this file makes more sense to me than the other one).

214

Same comment.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

krebases to activate CI

[ldionne]

This LGTM generally speaking, but I'd like to understand the story for signed-integer-class types.

libcxx/include/__iterator/concepts.h

62

From http://eel.is/c++draft/iterator.concept.winc#11:

An integer-like type I is signed-integer-like if it models signed_­integral<I> or if it is a signed-integer-class type.

Here, we detect if it models signed_­integral, but not if it's a signed-integer-class type. Reading the description of what a signed-integer-class type is (starting at http://eel.is/c++draft/iterator.concept.winc#2), it's not clear to me how to even check for that. Do you know what's the intent of the standard here?

libcxx/include/iterator

59

I think those comments could be dropped since they don't add much IMO. Feel free to leave in this patch and we'll address that as a NFC on the whole file later.

[cjdb]

rebases to activate CI

[cjdb]

libcxx/include/__iterator/concepts.h

62

http://wg21.link/p1522 conveys the full discussion, but the tl;dr is that LWG were concerned about the distances causing overflow between two iterators in the same range (e.g. iota_view). Implementers (and only implementers) are free to provide integer class types with an range larger than long long. We don't do this (our __int128_t is an extended integral type), so we can get away with this definition (which I learnt in Belfast is allowed, cc @tcanens).

Implementing __is_signed_integer_like to account for class types is computationally complex and really error-prone to get right (similar to the old std::boolean concept), so I'd prefer not to do it without first having a class type that we care about.

libcxx/include/iterator

59

Let's leave it for an NFC, for consistency's sake? (i.e. I plan to add them to all future iterator concept patches, and then we can delete them in one fell swoop.)

[ldionne]

I like that we're splitting the conformance tests into their own files like iterator_concept_conformance.compile.pass.cpp.

Ship it once you fix the CI, which fails in a few places (e.g. https://buildkite.com/llvm-project/libcxx-ci/builds/2701#e2424e5f-d53f-4f92-a971-328527c80682).

libcxx/include/__iterator/concepts.h

62

Thanks a lot for the reference! So it does look like we indeed don't need to do anything here unless/until we decide to add a user-defined integer-class type.

[cjdb]

rebases to get CI working properly

[cjdb]

rebases to include revert fix

[cjdb]

rebases to activate CI

[cjdb]

rebases to get Windows CI fixed

libcxx/include/__iterator/concepts.h

 concept indirectly_writable =
   requires(_Out&& __o, _Tp&& __t) {
     *__o = _VSTD::forward<_Tp>(__t);                        // not required to be equality-preserving
     *_VSTD::forward<_Out>(__o) = _VSTD::forward<_Tp>(__t);  // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*__o) = _VSTD::forward<_Tp>(__t);                       // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
   };
 
+// [iterator.concept.winc]
+template<class _Tp>
+inline constexpr bool __is_signed_integer_like = signed_integral<_Tp>;
+
+template<class _Ip>
+concept weakly_incrementable =
+  default_initializable<_Ip> &&
+  movable<_Ip> &&
+  requires(_Ip __i) {
+    typename iter_difference_t<_Ip>;
+    requires __is_signed_integer_like<iter_difference_t<_Ip> >;
+    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
+    __i++;                        // not required to be equality-preserving
+  };
+
+// [iterator.concept.inc]
+template<class _Ip>
+concept incrementable =
+  regular<_Ip> &&
+  weakly_incrementable<_Ip> &&
+  requires(_Ip __i) {
+    { __i++ } -> same_as<_Ip>;
+  };
+
 // clang-format on
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/iterator

 // [iterator.concept.readable], concept indirectly_­readable
 template<class In>
   concept indirectly_readable = see below;                // since C++20
 
 // [iterator.concept.writable], concept indirectly_­writable
 template<class Out, class T>
   concept indirectly_writable = see below;                // since C++20
 
+// [iterator.concept.winc], concept weakly_­incrementable
+template<class I>
+  concept weakly_incrementable = see below;                // since C++20
+
+// [iterator.concept.inc], concept incrementable
+template<class I>
+  concept incrementable = see below;                       // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;

 #include <__config>
 #include <iosfwd> // for forward declarations of vector and string.
 #include <__functional_base>
 #include <type_traits>
 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
+#include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <version>
 
else
       ++__iter;
   }
 
   return __old_size - __c.size();
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_ITERATOR

libcxx/test/std/containers/associative/map/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::map<int, int>::iterator;
 using const_iterator = std::map<int, int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/associative/multimap/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::multimap<int, int>::iterator;
 using const_iterator = std::multimap<int, int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/associative/multiset/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::multiset<int>::iterator;
 using const_iterator = std::multiset<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/associative/set/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::set<int>::iterator;
 using const_iterator = std::set<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/array/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 using iterator = std::array<int, 10>::iterator;
 using const_iterator = std::array<int, 10>::const_iterator;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, int>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/deque/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::deque<int>::iterator;
 using const_iterator = std::deque<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/forwardlist/forwardlist.iter/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::forward_list<int>::iterator;
 using const_iterator = std::forward_list<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/list/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::list<int>::iterator;
 using const_iterator = std::list<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/vector.bool/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::vector<bool>::iterator;
 using const_iterator = std::vector<bool>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/sequences/vector/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::vector<int>::iterator;
 using const_iterator = std::vector<int>::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/containers/unord/unord.map/iterator_concept_conformance.compile.pass.cpp

 using iterator = std::unordered_map<int, int>::iterator;
 using const_iterator = std::unordered_map<int, int>::const_iterator;
 using local_iterator = std::unordered_map<int, int>::local_iterator;
 using const_local_iterator = std::unordered_map<int, int>::const_local_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);

libcxx/test/std/containers/unord/unord.multimap/iterator_concept_conformance.compile.pass.cpp

 using iterator = std::unordered_multimap<int, int>::iterator;
 using const_iterator = std::unordered_multimap<int, int>::const_iterator;
 using local_iterator = std::unordered_multimap<int, int>::local_iterator;
 using const_local_iterator = std::unordered_multimap<int, int>::const_local_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);

libcxx/test/std/containers/unord/unord.multiset/iterator_concept_conformance.compile.pass.cpp

 using iterator = std::unordered_multiset<int>::iterator;
 using const_iterator = std::unordered_multiset<int>::const_iterator;
 using local_iterator = std::unordered_multiset<int>::local_iterator;
 using const_local_iterator = std::unordered_multiset<int>::const_local_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);

libcxx/test/std/containers/unord/unord.set/iterator_concept_conformance.compile.pass.cpp

 using iterator = std::unordered_set<int>::iterator;
 using const_iterator = std::unordered_set<int>::const_iterator;
 using local_iterator = std::unordered_set<int>::local_iterator;
 using const_local_iterator = std::unordered_set<int>::const_local_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);
 
 static_assert(std::indirectly_readable<local_iterator>);
 static_assert(!std::indirectly_writable<local_iterator, value_type>);
+static_assert(std::incrementable<local_iterator>);
 
 static_assert(std::indirectly_readable<const_local_iterator>);
 static_assert(!std::indirectly_writable<const_local_iterator, value_type>);
+static_assert(std::incrementable<const_local_iterator>);

libcxx/test/std/containers/views/span.iterators/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 using iterator = std::span<int>::iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);

libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.pass.cpp

 // directory_iterator, recursive_directory_iterator
 
 #include "filesystem_include.h"
 
 #include <iterator>
 
 static_assert(std::indirectly_readable<fs::directory_iterator>);
 static_assert(!std::indirectly_writable<fs::directory_iterator, fs::directory_iterator::value_type>);
+static_assert(std::weakly_incrementable<fs::directory_iterator>);
+static_assert(!std::incrementable<fs::directory_iterator>);
 
 static_assert(std::indirectly_readable<fs::recursive_directory_iterator>);
 static_assert(
     !std::indirectly_writable<fs::recursive_directory_iterator, fs::recursive_directory_iterator::value_type>);
+static_assert(std::weakly_incrementable<fs::recursive_directory_iterator>);
+static_assert(!std::incrementable<fs::recursive_directory_iterator>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.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 LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+#define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+
+struct postfix_increment_returns_void {
+  using difference_type = int;
+  postfix_increment_returns_void& operator++();
+  void operator++(int);
+};
+
+struct postfix_increment_returns_copy {
+  using difference_type = int;
+  postfix_increment_returns_copy& operator++();
+  postfix_increment_returns_copy operator++(int);
+};
+
+struct has_integral_minus {
+  has_integral_minus& operator++();
+  has_integral_minus operator++(int);
+
+  long operator-(has_integral_minus) const;
+};
+
+struct has_distinct_difference_type_and_minus {
+  using difference_type = short;
+
+  has_distinct_difference_type_and_minus& operator++();
+  has_distinct_difference_type_and_minus operator++(int);
+
+  long operator-(has_distinct_difference_type_and_minus) const;
+};
+
+struct missing_difference_type {
+  missing_difference_type& operator++();
+  void operator++(int);
+};
+
+struct floating_difference_type {
+  using difference_type = float;
+
+  floating_difference_type& operator++();
+  void operator++(int);
+};
+
+struct non_const_minus {
+  non_const_minus& operator++();
+  non_const_minus operator++(int);
+
+  long operator-(non_const_minus);
+};
+
+struct non_integral_minus {
+  non_integral_minus& operator++();
+  non_integral_minus operator++(int);
+
+  void operator-(non_integral_minus);
+};
+
+struct bad_difference_type_good_minus {
+  using difference_type = float;
+
+  bad_difference_type_good_minus& operator++();
+  void operator++(int);
+
+  int operator-(bad_difference_type_good_minus) const;
+};
+
+struct not_default_initializable {
+  using difference_type = int;
+  not_default_initializable() = delete;
+
+  not_default_initializable& operator++();
+  void operator++(int);
+};
+
+struct not_movable {
+  using difference_type = int;
+
+  not_movable() = default;
+  not_movable(not_movable&&) = delete;
+
+  not_movable& operator++();
+  void operator++(int);
+};
+
+struct preinc_not_declared {
+  using difference_type = int;
+
+  void operator++(int);
+};
+
+struct postinc_not_declared {
+  using difference_type = int;
+
+  postinc_not_declared& operator++();
+};
+
+struct incrementable_with_difference_type {
+  using difference_type = int;
+
+  incrementable_with_difference_type& operator++();
+  incrementable_with_difference_type operator++(int);
+
+  bool operator==(incrementable_with_difference_type const&) const;
+};
+
+struct incrementable_without_difference_type {
+  incrementable_without_difference_type& operator++();
+  incrementable_without_difference_type operator++(int);
+
+  bool operator==(incrementable_without_difference_type const&) const;
+
+  int operator-(incrementable_without_difference_type) const;
+};
+
+struct difference_type_and_void_minus {
+  using difference_type = int;
+
+  difference_type_and_void_minus& operator++();
+  difference_type_and_void_minus operator++(int);
+
+  bool operator==(difference_type_and_void_minus const&) const;
+
+  void operator-(difference_type_and_void_minus) const;
+};
+
+struct noncopyable_with_difference_type {
+  using difference_type = int;
+
+  noncopyable_with_difference_type() = default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type&&) = default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type const&) = delete;
+
+  noncopyable_with_difference_type& operator=(noncopyable_with_difference_type&&) = default;
+  noncopyable_with_difference_type& operator=(noncopyable_with_difference_type const&) = delete;
+
+  noncopyable_with_difference_type& operator++();
+  noncopyable_with_difference_type operator++(int);
+
+  bool operator==(noncopyable_with_difference_type const&) const;
+};
+
+struct noncopyable_without_difference_type {
+  noncopyable_without_difference_type() = default;
+  noncopyable_without_difference_type(noncopyable_without_difference_type&&) = default;
+  noncopyable_without_difference_type(noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type& operator=(noncopyable_without_difference_type&&) = default;
+  noncopyable_without_difference_type& operator=(noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type& operator++();
+  noncopyable_without_difference_type operator++(int);
+
+  int operator-(noncopyable_without_difference_type const&) const;
+
+  bool operator==(noncopyable_without_difference_type const&) const;
+};
+
+struct noncopyable_with_difference_type_and_minus {
+  using difference_type = int;
+
+  noncopyable_with_difference_type_and_minus() = default;
+  noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus& operator++();
+  noncopyable_with_difference_type_and_minus operator++(int);
+
+  int operator-(noncopyable_with_difference_type_and_minus const&) const;
+
+  bool operator==(noncopyable_with_difference_type_and_minus const&) const;
+};
+
+#endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept indirectly_readable;
+
+#include <iterator>
+
+#include <concepts>
+#include <memory>
+#include <optional>
+
+#include "../incrementable.h"
+
+static_assert(std::incrementable<int>);
+static_assert(std::incrementable<int*>);
+static_assert(std::incrementable<int**>);
+
+static_assert(!std::incrementable<postfix_increment_returns_void>);
+static_assert(!std::incrementable<postfix_increment_returns_copy>);
+static_assert(!std::incrementable<has_integral_minus>);
+static_assert(!std::incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::incrementable<missing_difference_type>);
+static_assert(!std::incrementable<floating_difference_type>);
+static_assert(!std::incrementable<non_const_minus>);
+static_assert(!std::incrementable<non_integral_minus>);
+static_assert(!std::incrementable<bad_difference_type_good_minus>);
+static_assert(!std::incrementable<not_default_initializable>);
+static_assert(!std::incrementable<not_movable>);
+static_assert(!std::incrementable<preinc_not_declared>);
+static_assert(!std::incrementable<postinc_not_declared>);
+static_assert(std::incrementable<incrementable_with_difference_type>);
+static_assert(std::incrementable<incrementable_without_difference_type>);
+static_assert(std::incrementable<difference_type_and_void_minus>);
+static_assert(!std::incrementable<noncopyable_with_difference_type>);
+static_assert(!std::incrementable<noncopyable_without_difference_type>);
+static_assert(!std::incrementable<noncopyable_with_difference_type_and_minus>);

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// iterator, reverse_iterator
-
-#include <span>
+// template<class T>
+// concept incrementable;
 
 #include <iterator>
 
-using iterator = std::span<int>::iterator;
-using value_type = iterator::value_type;
+#include <concepts>
+
+// clang-format off
+template<std::weakly_incrementable I>
+requires std::regular<I>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::incrementable>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
 
-static_assert(std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(check_subsumption<int*>());

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: gcc-10
 
-// iterator, reverse_iterator
-
-#include <span>
+// template<class T>
+// concept weakly_incrementable;
 
 #include <iterator>
 
-using iterator = std::span<int>::iterator;
-using value_type = iterator::value_type;
+#include <concepts>
+
+// clang-format off
+template<std::default_initializable I>
+requires std::movable<I>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return false;
+}
+
+template<std::weakly_incrementable>
+[[nodiscard]] constexpr bool check_subsumption() {
+  return true;
+}
+// clang-format on
 
-static_assert(std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(check_subsumption<int*>());

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept std::weakly_incrementable;
+
+#include <iterator>
+
+#include <concepts>
+#include <memory>
+#include <optional>
+
+#include "../incrementable.h"
+
+static_assert(std::weakly_incrementable<int>);
+static_assert(std::weakly_incrementable<int*>);
+static_assert(std::weakly_incrementable<int**>);
+static_assert(!std::weakly_incrementable<int[]>);
+static_assert(!std::weakly_incrementable<int[10]>);
+static_assert(!std::weakly_incrementable<double>);
+static_assert(!std::weakly_incrementable<int&>);
+static_assert(!std::weakly_incrementable<int()>);
+static_assert(!std::weakly_incrementable<int (*)()>);
+static_assert(!std::weakly_incrementable<int (&)()>);
+
+struct S {};
+static_assert(!std::weakly_incrementable<int S::*>);
+
+#define CHECK_POINTER_TO_MEMBER_FUNCTIONS(qualifier)                                                                   \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier>);                                                   \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier noexcept>);                                          \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&>);                                                  \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier & noexcept>);                                        \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&&>);                                                 \
+  static_assert(!std::weakly_incrementable < int (S::*)() qualifier&& noexcept >);
+
+#define NO_QUALIFIER
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(NO_QUALIFIER);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(volatile);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const volatile);
+
+static_assert(std::weakly_incrementable<postfix_increment_returns_void>);
+static_assert(std::weakly_incrementable<postfix_increment_returns_copy>);
+static_assert(std::weakly_incrementable<has_integral_minus>);
+static_assert(std::weakly_incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::weakly_incrementable<missing_difference_type>);
+static_assert(!std::weakly_incrementable<floating_difference_type>);
+static_assert(!std::weakly_incrementable<non_const_minus>);
+static_assert(!std::weakly_incrementable<non_integral_minus>);
+static_assert(!std::weakly_incrementable<bad_difference_type_good_minus>);
+static_assert(!std::weakly_incrementable<not_default_initializable>);
+static_assert(!std::weakly_incrementable<not_movable>);
+static_assert(!std::weakly_incrementable<preinc_not_declared>);
+static_assert(!std::weakly_incrementable<postinc_not_declared>);
+static_assert(std::weakly_incrementable<incrementable_with_difference_type>);
+static_assert(std::weakly_incrementable<incrementable_without_difference_type>);
+static_assert(std::weakly_incrementable<difference_type_and_void_minus>);
+static_assert(std::weakly_incrementable<noncopyable_with_difference_type>);
+static_assert(std::weakly_incrementable<noncopyable_without_difference_type>);
+static_assert(std::weakly_incrementable<noncopyable_with_difference_type_and_minus>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <vector>
 
 using iterator = std::back_insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <list>
 
 using iterator = std::front_insert_iterator<std::list<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <vector>
 
 using iterator = std::insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/iterator_concept_conformance.compile.pass.cpp

 
 // move_iterator
 
 #include <iterator>
 
 using iterator = std::move_iterator<int*>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/iterator_concept_conformance.compile.pass.cpp

 
 // reverse_iterator
 
 #include <iterator>
 
 using iterator = std::reverse_iterator<int*>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);

libcxx/test/std/iterators/stream.iterators/istream.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <iosfwd>
 
 using iterator = std::istream_iterator<int, std::istream>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, int>);
+static_assert(std::incrementable<iterator>);

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 #include <istream>
 #include <string>
 
 using iterator = std::istreambuf_iterator<char>;
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(!std::incrementable<iterator>);

libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <iosfwd>
 
 using iterator = std::ostream_iterator<int, std::ostream>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
+static_assert(!std::weakly_incrementable<iterator>);

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 #include <ostream>
 #include <string>
 
 using iterator = std::ostreambuf_iterator<char>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, char>);
+static_assert(!std::weakly_incrementable<iterator>);

libcxx/test/std/re/re.iter/re.regiter/iterator_concept_conformance.compile.pass.cpp

 // regex_iterator
 
 #include <regex>
 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::cregex_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_iterator, char>);
+static_assert(std::incrementable<std::cregex_iterator>);

libcxx/test/std/re/re.iter/re.tokiter/iterator_concept_conformance.compile.pass.cpp

 // regex_token_iterator
 
 #include <regex>
 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::cregex_token_iterator>);
 static_assert(!std::indirectly_writable<std::cregex_token_iterator, char>);
+static_assert(std::incrementable<std::cregex_token_iterator>);

libcxx/test/std/strings/basic.string/string.iterators/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 using iterator = std::string::iterator;
 using const_iterator = std::string::const_iterator;
 using value_type = iterator::value_type;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, value_type>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, value_type>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/strings/string.view/string.view.iterators/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 using iterator = std::string_view::iterator;
 using const_iterator = std::string_view::const_iterator;
 
 static_assert(std::indirectly_readable<iterator>);
 static_assert(!std::indirectly_writable<iterator, char>);
+static_assert(std::incrementable<iterator>);
 
 static_assert(std::indirectly_readable<const_iterator>);
 static_assert(!std::indirectly_writable<const_iterator, char>);
+static_assert(std::incrementable<const_iterator>);

libcxx/test/std/utilities/memory/unique.ptr/iterator_concept_conformance.compile.pass.cpp

 // unique_ptr
 
 #include <memory>
 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::unique_ptr<int> >);
 static_assert(std::indirectly_writable<std::unique_ptr<int>, int>);
+static_assert(!std::weakly_incrementable<std::unique_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::unique_ptr<void> >);
 static_assert(!std::indirectly_writable<std::unique_ptr<void>, void>);
+static_assert(!std::weakly_incrementable<std::unique_ptr<void> >);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/iterator_concept_conformance.compile.pass.cpp

 // shared_ptr
 
 #include <memory>
 
 #include <iterator>
 
 static_assert(std::indirectly_readable<std::shared_ptr<int> >);
 static_assert(std::indirectly_writable<std::shared_ptr<int>, int>);
+static_assert(!std::weakly_incrementable<std::shared_ptr<int> >);
 
 static_assert(!std::indirectly_readable<std::shared_ptr<void> >);
 static_assert(!std::indirectly_writable<std::shared_ptr<void>, void>);
+static_assert(!std::weakly_incrementable<std::shared_ptr<void> >);

libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp

 // unique_ptr
 
 #include <optional>
 
 #include <iterator>
 
 static_assert(!std::indirectly_readable<std::optional<int> >);
 static_assert(!std::indirectly_writable<std::optional<int>, int>);
+static_assert(!std::weakly_incrementable<std::optional<int> >);