[libcxx] adds `std::incrementable_traits` to <iterator>

[cjdb]

Summary

Implements parts of:

• P0896R4 The One Ranges Proposal

Depends on D99041

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

44

This is surprising, but I guess it falls out naturally because int[] is subtractable?
Please add tests for int[10], int(*)(), int(&)(), and int() as well.

[• Quuxplusone]

libcxx/include/iterator

459

This is the only reason <iterator> needs to include <concepts> in C++20 mode, right?
@ldionne, how about we just use is_integral_v here instead?

template<class _Tp>
concept __has_integral_minus =
  !__has_difference_type_member<_Tp> &&
  requires(const _Tp& __x, const _Tp& __y) {
    requires is_integral_v<decltype( __x - __y )>;
  };

(And/or, wait for <concepts> to stop depending on <iterator>; D99041, D99124.)

I note that the name __has_integral_minus is slightly misleading; it currently means __has_integral_minus_without_difference_type. The paper standard doesn't factor out these concepts, so we have no exposition-only names to imitate here. Maybe __incrementable_traits_use_difference_type<_Tp> and __incrementable_traits_use_minus<_Tp> would be better? But I don't really object to the current name even if I do find it "slightly misleading."

469

Just declval<_Tp>(), not std::declval<_Tp>(). (If it had any arguments, then definitely _VSTD::declval to prevent ADL — but it has no arguments. Actually we still have a ton of places that do _VSTD::declval, so I'm okay with that spelling too. Just not std::.)

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

23

Almost all places where you write incrementable_traits, you should be writing difference_type — has_difference_type, difference_type_matches, check_difference_type.

159

"with_cv"? I see no cv-qualifiers here.
Also, my usual opinion on noexcept here: noexcept is absolutely irrelevant to this test, and so it would be nice not to see it at all. At the very least, please make at least one of these tests check what happens when the subtraction operation is non-noexcept, because that's the realistic case in the wild.

[cjdb]

applies @Quuxplusone's feedback

libcxx/include/iterator

459

This is the only reason <iterator> needs to include <concepts> in C++20 mode, right?

For this patch? Yes.

It's a part of the synopsis, so in general, no.

(And/or, wait for <concepts> to stop depending on <iterator>; D99041, D99124.)

That was my intention, hence "Depends on D99041".

The paper standard doesn't factor out these concepts, so we have no exposition-only names to imitate here. Maybe __incrementable_traits_use_difference_type<_Tp> and __incrementable_traits_use_minus<_Tp> would be better?

Right. I think I got the idea of naming these from readable.traits, so __has_member_difference_type (sic) is probably best for consistency. As for __has_integral_minus, I'm ambivalent, so long as it's consistent.

469

Eh, ADL isn't a concern here. Removed.

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

44

See below for int(*)() and friends.

[Mordante]

Can you also make sure the patch passes CI?

libcxx/include/iterator

16

Can you add the required includes?
http://eel.is/c++draft/iterator.synopsis

#include <compare>              // see [compare.syn]
#include <concepts>             // see [concepts.syn]

429

Maybe also add compare while you're at it.

459

The synopsis requires concepts http://eel.is/c++draft/iterator.synopsis

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

2

http://eel.is/c++draft/incrementable.traits#3 Users may specialize incrementable_­traits on program-defined types.
can you add a test for this?

[cjdb]

partially applies @Mordante's feedback

[cjdb]

In D99141#2648240, @Mordante wrote:

Can you also make sure the patch passes CI?

This is failing CI because of a bug in GCC 10 that was fixed in trunk (example). @ldionne should I add an include guard around the offending line or should we upgrade our CI's GCC?

libcxx/include/iterator

16

I've added it for <concepts>, but will leave <compare> for the person who adds that functionality (probably me in a future patch).

429

See above.

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

32–37

Take the suggested edit.

44

Please add int[10].

223

My usual complaints about hundreds of lines of tests, which test very little.
Please remove a large percentage of lines 94–222, and replace them with:

• One test that fails when line 458's const _Tp& __x is replaced with const _Tp x. (You currently lack any.)
• One test that fails when line 458's const _Tp& __x is replaced with _Tp& x. (You currently lack any.)
• One test that fails when line 458's const _Tp& __x is replaced with _Tp x. (You currently lack any.)

[cjdb]

adds test coverage

[cjdb]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

32–37

The suggested edit doesn't add anything constructive and appears to be a stylistic preference, so there's nothing to change.

223

My usual complaints about hundreds of lines of tests, which test very little.
Please remove a large percentage of lines 94–222

As mentioned in previous patches: I have been asked to add tests, and my comprehensive coverage has been encouraged by several others, including two maintainers.

There are many lines, yes, but each of these tests ensures that cv-qualifiers and reference qualifiers are correctly handled.

and replace them with:

• One test that fails when line 458's const _Tp& __x is replaced with const _Tp x. (You currently lack any.)
• One test that fails when line 458's const _Tp& __x is replaced with _Tp& x. (You currently lack any.)
• One test that fails when line 458's const _Tp& __x is replaced with _Tp x. (You currently lack any.)

I have added these three and more.

[zoecarver]

Thanks!

libcxx/include/iterator

472

Hmm. I really feel like we should have a better way to track what is implemented, what is blocked on other patches, etc. TODOs might be OK for now, but I'd like to sort this out.

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

223

I don't feel opposition to lots of tests, even if they might seem excessive. Though, it might be good to have a few simple tests at the top or bottom that are easily verifiable and human-readable that just show "this works right in the common case". That being said, this patch LGTM (but let's make sure Arthur is also OK with it).

[• Quuxplusone]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

223

Well, I wouldn't say I'm "OK" with it; but I agree I haven't got the clout to block this patch series until it looks the way I think it should.

The number of tests in a patch should generally be proportional to the number of lines-of-code changed: here Chris is adding 24 LOC, so the tests should be on that order of magnitude.
In any given patch, each test should usually guard against some specific failure mode; failure modes are usually of the form "what happens if line X of the patch bit-rots under maintenance?" So for example, "what happens if line 458's const _Tp& is replaced with _Tp?" Tests that can't be traced back to a specific failure mode are automatically suspect, because in my experience (both here and elsewhere in life) "hundreds of tests" is often a substitute for "any tests that actually test something."

Another way to put it is, test-code is just like ordinary code. Writing hundreds of lines of code can be useful, but it can also indicate that you need to take a step back to look at the problem you're trying to solve. Once you understand the problem being solved, you might find that an elegant fix is available.

The hundred-line rough draft can still be useful! Looking at Chris's "rough draft" with its hundreds of lines of const_lvalue_ref_volatile_rvalue_ref_subtraction gave me the clue "okay, cvref-qualifiers are important to this code somehow." Then I looked at the problem being solved — "okay, we need to test that something might bit-rot in this code, in the area of cvref-qualifiers specifically." That's how I found that none of these tests were testing what they intended. The next step is to write a surgical patch that solves the problem; I think I can write the new test for each of the three bullet points above in about 5 lines each. With the smaller patch in hand, the big patch is no longer technically necessary — and therefore I personally wouldn't check it in. (Although, again, I understand that I'm not the gatekeeper here, and the big patch is quite likely to get checked in regardless.)

[Mordante]

Can you fix the Apple build failures? (Guess it's caused by the parent commit.)

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

223

I'm personally also not too fond of the amount of tests and I agree with @Quuxplusone. However some maintainers have asked for verbose tests for some of the concepts in earlier reviews. Maybe we should discuss on discord what we expect of unit tests and how verbose. I don't like to block this review on that discussion; the tests aren't wrong and we can always reduce the number of tests later.

[cjdb]

fixes include guard to guard on concepts

[cjdb]

adds internal ranges feature-test macro

[• Quuxplusone]

libcxx/include/__config

851 ↗

(On Diff #335200)

Please use <= 17, for consistency with similar lines in this file. (We tend to guard C++2a stuff on > 17. I don't think there's anything special about the Ranges stuff in this respect, right?)

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

35–36

Note that T const is the same type as T whenever T is a reference type. Therefore, any place in this file that instantiates check_incrementable_traits<Foo&> is suspicious — it's simply static-asserting that the difference type of T is the difference type of T.
I suggest that you add static_assert(!std::is_reference_v<T>) inside this template, and then re-run the tests, and investigate/fix any failures that arise from that.
I also suggest that if you actually expect result to be true in all cases, you should add

assert(result);

inside this function. (Or is it okay if result is false, sometimes? I didn't closely examine all the call sites.)

[ldionne]

I'd like to put an end to comments about "too many tests" once and for all. I think we all agree that test coverage is a good property to have. I think we also agree that readability is a good property to have, and that code duplication is bad. We want both, as much as possible.

I think what we're seeing here is an example where we have a lot of code coverage, which is great, however the cost (right now) is a lot of repetition, and hence decreased readability. For me, the solution is not to remove the test coverage, but instead to implement it without reducing readability so much. Here's an example of how this can be done (there are other ways, for example we could use templates instead but I just hacked this together). This replaces lines 174 to 702. Yes it's still not *small*, but it's much better and IMO easier to read, while not dropping any of the coverage. And it would be easy to make it even better by using two nested "loops" over all qualifiers, but it's unclear to me that would actually increase readability.

#define TEST_NOT_DIFFERENCE_TYPE(qual1, qual2)                                    \
  struct TEST_CONCAT(test_subtraction_,__LINE__) {                                     \
    friend int operator-(TEST_CONCAT(test_subtraction_,__LINE__) qual1,                \
                         TEST_CONCAT(test_subtraction_,__LINE__) qual2);               \
  };                                                                              \
  static_assert(!check_has_difference_type<TEST_CONCAT(test_subtraction_,__LINE__)>)   \
/**/

TEST_NOT_DIFFERENCE_TYPE(&&, &&);
TEST_NOT_DIFFERENCE_TYPE(&, &);
TEST_NOT_DIFFERENCE_TYPE(&, const&);
TEST_NOT_DIFFERENCE_TYPE(&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(&, &&);
TEST_NOT_DIFFERENCE_TYPE(&, const&&);
TEST_NOT_DIFFERENCE_TYPE(&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const&, &);
TEST_NOT_DIFFERENCE_TYPE(const&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(const&, &&);
TEST_NOT_DIFFERENCE_TYPE(const&, const&&);
TEST_NOT_DIFFERENCE_TYPE(const&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, &);
TEST_NOT_DIFFERENCE_TYPE(volatile&, const&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, &&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, const&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, &);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, &&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, const&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(&&, &);
TEST_NOT_DIFFERENCE_TYPE(&&, const&);
TEST_NOT_DIFFERENCE_TYPE(&&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(&&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(&&, &&);
TEST_NOT_DIFFERENCE_TYPE(&&, const&&);
TEST_NOT_DIFFERENCE_TYPE(&&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(&&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const&&, &);
TEST_NOT_DIFFERENCE_TYPE(const&&, const&);
TEST_NOT_DIFFERENCE_TYPE(const&&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(const&&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(const&&, &&);
TEST_NOT_DIFFERENCE_TYPE(const&&, const&&);
TEST_NOT_DIFFERENCE_TYPE(const&&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const&&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, &);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, const&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, &&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, const&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, &);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, const&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, volatile&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, const volatile&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, &&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, const&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, const volatile&&);
TEST_NOT_DIFFERENCE_TYPE(&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(const&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(volatile&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(&&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(const&&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(volatile&&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(const volatile&&, /*by value*/);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, &);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, const&);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, volatile&);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, &&);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, const&&);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, volatile&&);
TEST_NOT_DIFFERENCE_TYPE(/*by value*/, const volatile&&);

WDYT? If we have to do this sort of thing frequently, we could also bundle a few utilities under support/ to reduce duplication further.

[zoecarver]

I'd like to put an end to comments about "too many tests" once and for all. I think we all agree that test coverage is a good property to have. I think we also agree that readability is a good property to have, and that code duplication is bad. We want both, as much as possible.

[...]

I really like your suggestion. The only two things I'd say are

1. We could take that even further and have a test macro that generates all the const/ref/volatile combinations we want (this is sort of like what you were saying with the two loops). Then we could just pass it a macro that generated the tests for any given concept.
2. These tests are good because they cover as much code as possible, but they make it harder to verify what's actually being tested (especially if it's two macros deep). I'd suggest that we have the macro tests and some simple, easily verifyable tests that verify the basic/common case.

Using macros like this will also make it easy to write lots of tests quickly, so it shouldn't be too hard to back port to the other concepts that have already landed.

[cjdb]

applies @ldionne's proposed test framework

[cjdb]

In D99141#2669722, @ldionne wrote:

I'd like to put an end to comments about "too many tests" once and for all. I think we all agree that test coverage is a good property to have. I think we also agree that readability is a good property to have, and that code duplication is bad. We want both, as much as possible.

I think what we're seeing here is an example where we have a lot of code coverage, which is great, however the cost (right now) is a lot of repetition, and hence decreased readability. For me, the solution is not to remove the test coverage, but instead to implement it without reducing readability so much. Here's an example of how this can be done (there are other ways, for example we could use templates instead but I just hacked this together). This replaces lines 174 to 702. Yes it's still not *small*, but it's much better and IMO easier to read, while not dropping any of the coverage. And it would be easy to make it even better by using two nested "loops" over all qualifiers, but it's unclear to me that would actually increase readability.

...

WDYT? If we have to do this sort of thing frequently, we could also bundle a few utilities under support/ to reduce duplication further.

Now that I know we're not afraid of macros, I'll employ this where large tests are necessary.

libcxx/include/__config

851 ↗

(On Diff #335200)

Please use <= 17, for consistency with similar lines in this file.

Done.

(We tend to guard C++2a stuff on > 17. I don't _think_ there's anything special about the Ranges stuff in this respect, right?)

Not sure I'm following this line of thought, so I'm leaving the comment as unresolved for now.

libcxx/include/iterator

472

In general: yes please.

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.pass.cpp

35–36

Note that T const is the same type as T whenever T is a reference type. Therefore, any place in this file that instantiates check_incrementable_traits<Foo&> is suspicious — it's simply static-asserting that the difference type of T is the difference type of T.
I suggest that you add static_assert(!std::is_reference_v<T>) inside this template, and then re-run the tests, and investigate/fix any failures that arise from that.

Lines 63-70 should already account for this, unless you're asking we check T& against T const& and friends.

I also suggest that if you actually expect result to be true in all cases, you should add

assert(result);

inside this function. (Or is it okay if result is false, sometimes? I didn't closely examine all the call sites.)

Lines 89 and 90-1 expect false.

[miscco]

I really like @ldionne suggestion. I am a bit unhappy about it being a macro, but meh.

FYI, this is the MSVC test set which is kind of the same but less extensive:

https://github.com/microsoft/STL/blob/fb2f89f9366b1c170587ff37e39b962dd8ead3d6/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp#L667-L721

[zoecarver]

This still LGTM. I think we should land this to get stuff unblocked! (After another reviewer approves.)

libcxx/include/__config

851 ↗

(On Diff #335200)

Not sure I'm following this line of thought, so I'm leaving the comment as unresolved for now.

I don't think this is needed anymore, because C++20 has been released. We did this pre-c++20 (when it was still C++2a) because we weren't sure it would be released in C++20 (i.e., if there was a global pandemic...). But, it was still released on time, and it is C++20, so I think we can guard on that now.

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.compile.pass.cpp

149 ↗

(On Diff #335404)

What's the comment for?

245 ↗

(On Diff #335404)

What's going on here? Why is this commented?

[cjdb]

libcxx/include/__config

851 ↗

(On Diff #335200)

I still don't understand, sorry 😭

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.compile.pass.cpp

149 ↗

(On Diff #335404)

Paging @ldionne. He's not the only Boost dev I've seen do this.

245 ↗

(On Diff #335404)

I think it would be best to keep the commented out lines there to show these permutations weren't forgotten, but they can't be enabled because they actually pass.

[Mordante]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.compile.pass.cpp

149 ↗

(On Diff #335404)

Isn't it because line 148 ends with a \? Just to avoid when writing code on line 149 to be part of the macro.

[cjdb]

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.compile.pass.cpp

149 ↗

(On Diff #335404)

Yeah, but why does line 148 end with \?

[ldionne]

Ship it with comments applied and CI passing!

libcxx/include/__config

852 ↗

(On Diff #335404)

FWIW, I'm fine with defining this for now, however as soon as we only support compilers that implement concepts, we will get rid of this and instead use just #if _LIBCPP_STD_VER >= 20 to guard concepts code. Agreed?

libcxx/include/iterator

461

IMO this name is misleading because you're really checking whether T has an integral minus AND no member difference type. I think it would be cleaner to take the !__has_member_difference_type out of this helper concept and use it directly below in incrementable_traits.

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.compile.pass.cpp

149 ↗

(On Diff #335404)

Good question, I do it as a reflex now. I'm not sure where it came from originally. I know at some point I had a tool to automatically add \ at the end of macro lines and it would be keyed on /**/ to stop IIRC, but I'm not sure why we do this historically.

153 ↗

(On Diff #335404)

You could use this common idiom to show that you explicitly wanted the macro to expand to nothing, and you didn't forget to escape the line break with \:

#define NO_QUALIFIER /*nothing*/

[cjdb]

rebases to activate CI

[thakis]

libcxx/include/iterator

444

This breaks using this header with -std=c++14 apparently: http://45.33.8.238/linux/43983/step_4.txt

Looks like _LIBCPP_HAS_NO_RANGES is supposed to be defined in that case, but maybe it doesn't work right?

[thakis]

libcxx/include/iterator

444

Oh wait, this might be a bot config problem. Please ignore for now.

[thakis]

libcxx/include/iterator

444

Yes, was a problem on my end. All good now, sorry for the noise.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P0482R6 <https://wg21.link/P0482R6>`__","CWG","char8_t: A type for UTF-8 characters and strings","San Diego","|In Progress|",""
 "`P0487R1 <https://wg21.link/P0487R1>`__","LWG","Fixing ``operator>>(basic_istream&, CharT*)``\  (LWG 2499)","San Diego","|Complete|","8.0"
 "`P0591R4 <https://wg21.link/P0591R4>`__","LWG","Utility functions to implement uses-allocator construction","San Diego","* *",""
 "`P0595R2 <https://wg21.link/P0595R2>`__","CWG","P0595R2 std::is_constant_evaluated()","San Diego","|Complete|","9.0"
 "`P0602R4 <https://wg21.link/P0602R4>`__","LWG","variant and optional should propagate copy/move triviality","San Diego","|Complete|","8.0"
 "`P0608R3 <https://wg21.link/P0608R3>`__","LWG","A sane variant converting constructor","San Diego","|Complete|","9.0"
 "`P0655R1 <https://wg21.link/P0655R1>`__","LWG","visit<R>: Explicit Return Type for visit","San Diego","|Complete|","12.0"
 "`P0771R1 <https://wg21.link/P0771R1>`__","LWG","std::function move constructor should be noexcept","San Diego","|Complete|","6.0"
-"`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","* *",""
+"`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","|In Progress|",""
 "`P0899R1 <https://wg21.link/P0899R1>`__","LWG","P0899R1 - LWG 3016 is not a defect","San Diego","|Nothing To Do|",""
 "`P0919R3 <https://wg21.link/P0919R3>`__","LWG","Heterogeneous lookup for unordered containers","San Diego","|Complete|","12.0"
 "`P0972R0 <https://wg21.link/P0972R0>`__","LWG","<chrono> ``zero()``\ , ``min()``\ , and ``max()``\  should be noexcept","San Diego","|Complete|","8.0"
 "`P1006R1 <https://wg21.link/P1006R1>`__","LWG","Constexpr in std::pointer_traits","San Diego","|Complete|","8.0"
 "`P1007R3 <https://wg21.link/P1007R3>`__","LWG","``std::assume_aligned``\ ","San Diego","* *",""
 "`P1020R1 <https://wg21.link/P1020R1>`__","LWG","Smart pointer creation with default initialization","San Diego","* *",""
 "`P1032R1 <https://wg21.link/P1032R1>`__","LWG","Misc constexpr bits","San Diego","|Complete|","13.0"
 "`P1085R2 <https://wg21.link/P1085R2>`__","LWG","Should Span be Regular?","San Diego","|Complete|","8.0"

libcxx/include/iterator

 // -*- C++ -*-
 //===-------------------------- iterator ----------------------------------===//
 //
 // 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_ITERATOR
 #define _LIBCPP_ITERATOR
 
 /*
     iterator synopsis
 
+#include <concepts>
+
 namespace std
 {
+template<class> struct incrementable_traits; // since C++20
 
 template<class Iterator>
 struct iterator_traits
 {
     typedef typename Iterator::difference_type difference_type;
     typedef typename Iterator::value_type value_type;
     typedef typename Iterator::pointer pointer;
     typedef typename Iterator::reference reference;

 #include <iosfwd> // for forward declarations of vector and string.
 #include <__functional_base>
 #include <type_traits>
 #include <cstddef>
 #include <initializer_list>
 #include <__memory/base.h>
 #include <__memory/pointer_traits.h>
 #include <version>
+#include <concepts>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+// [incrementable.traits]
+template<class> struct incrementable_traits {};
+
+template<class _Tp>
+requires is_object_v<_Tp>
+struct incrementable_traits<_Tp*> {
+  using difference_type = ptrdiff_t;
+};
+
+template<class _Ip>
+struct incrementable_traits<const _Ip> : incrementable_traits<_Ip> {};
+
+template<class _Tp>
+concept __has_member_difference_type = requires { typename _Tp::difference_type; };
+
+template<__has_member_difference_type _Tp>
+struct incrementable_traits<_Tp> {
+  using difference_type = typename _Tp::difference_type;
+};
+
+template<class _Tp>
+concept __has_integral_minus =
+  !__has_member_difference_type<_Tp> &&
+  requires(const _Tp& __x, const _Tp& __y) {
+    { __x - __y } -> integral;
+  };
+
+template<__has_integral_minus _Tp>
+struct incrementable_traits<_Tp> {
+  using difference_type = make_signed_t<decltype(declval<_Tp>() - declval<_Tp>())>;
+};
+
+// TODO(cjdb): add iter_difference_t once iterator_traits is cleaned up.
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
 template <class _Iter>
 struct _LIBCPP_TEMPLATE_VIS iterator_traits;
 
 struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};

libcxx/test/std/iterators/iterator.requirements/iterator.assoc.types/incrementable.traits/incrementable_traits.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 T>
+// struct incrementable_traits;
+
+#include <iterator>
+
+#include <concepts>
+
+// clang-format off
+template <class T>
+concept check_has_difference_type = requires {
+  typename std::incrementable_traits<T>::difference_type;
+};
+
+template <class T, class Expected>
+concept check_difference_type_matches =
+  check_has_difference_type<T> &&
+  std::same_as<typename std::incrementable_traits<T>::difference_type, Expected>;
+// clang-format on
+
+template <class T, class Expected>
+[[nodiscard]] constexpr bool check_incrementable_traits() noexcept {
+  constexpr bool result = check_difference_type_matches<T, Expected>;
+  static_assert(check_difference_type_matches<T const, Expected> == result);
+  return result;
+}
+
+static_assert(check_incrementable_traits<float*, std::ptrdiff_t>());
+static_assert(check_incrementable_traits<float const*, std::ptrdiff_t>());
+static_assert(check_incrementable_traits<float volatile*, std::ptrdiff_t>());
+static_assert(
+    check_incrementable_traits<float const volatile*, std::ptrdiff_t>());
+static_assert(check_incrementable_traits<float**, std::ptrdiff_t>());
+
+static_assert(check_incrementable_traits<int[], std::ptrdiff_t>());
+static_assert(check_incrementable_traits<int[10], std::ptrdiff_t>());
+
+static_assert(check_incrementable_traits<char, int>());
+static_assert(check_incrementable_traits<signed char, int>());
+static_assert(check_incrementable_traits<unsigned char, int>());
+static_assert(check_incrementable_traits<short, int>());
+static_assert(check_incrementable_traits<unsigned short, int>());
+static_assert(check_incrementable_traits<int, int>());
+static_assert(check_incrementable_traits<unsigned int, int>());
+static_assert(check_incrementable_traits<long, long>());
+static_assert(check_incrementable_traits<unsigned long, long>());
+static_assert(check_incrementable_traits<long long, long long>());
+static_assert(check_incrementable_traits<unsigned long long, long long>());
+
+static_assert(check_incrementable_traits<int&, int>());
+static_assert(check_incrementable_traits<int const&, int>());
+static_assert(check_incrementable_traits<int volatile&, int>());
+static_assert(check_incrementable_traits<int const volatile&, int>());
+static_assert(check_incrementable_traits<int&&, int>());
+static_assert(check_incrementable_traits<int const&&, int>());
+static_assert(check_incrementable_traits<int volatile&&, int>());
+static_assert(check_incrementable_traits<int const volatile&&, int>());
+
+static_assert(check_incrementable_traits<int volatile, int>());
+static_assert(check_incrementable_traits<int* volatile, std::ptrdiff_t>());
+
+struct integral_difference_type {
+  using difference_type = int;
+};
+static_assert(check_incrementable_traits<integral_difference_type, int>());
+
+struct non_integral_difference_type {
+  using difference_type = void;
+};
+static_assert(check_incrementable_traits<non_integral_difference_type, void>());
+
+struct int_subtraction {
+  friend int operator-(int_subtraction, int_subtraction) noexcept;
+};
+static_assert(check_incrementable_traits<int_subtraction, int>());
+static_assert(!check_incrementable_traits<int_subtraction volatile&, int>());
+static_assert(
+    !check_incrementable_traits<int_subtraction const volatile&, int>());
+
+struct char_subtraction {
+  friend char operator-(char_subtraction, char_subtraction) noexcept;
+};
+static_assert(check_incrementable_traits<char_subtraction, signed char>());
+
+struct unsigned_int_subtraction_with_cv {
+  friend unsigned int
+  operator-(unsigned_int_subtraction_with_cv const&,
+            unsigned_int_subtraction_with_cv const&) noexcept;
+  friend unsigned int
+  operator-(unsigned_int_subtraction_with_cv const volatile&,
+            unsigned_int_subtraction_with_cv const volatile&) noexcept;
+};
+static_assert(
+    check_incrementable_traits<unsigned_int_subtraction_with_cv, int>());
+static_assert(check_incrementable_traits<
+              unsigned_int_subtraction_with_cv volatile&, int>());
+static_assert(check_incrementable_traits<
+              unsigned_int_subtraction_with_cv const volatile&, int>());
+
+struct specialised_incrementable_traits {};
+namespace std {
+template <>
+struct incrementable_traits<specialised_incrementable_traits> {
+  using difference_type = int;
+};
+} // namespace std
+static_assert(
+    check_incrementable_traits<specialised_incrementable_traits, int>());
+
+static_assert(!check_has_difference_type<void>);
+static_assert(!check_has_difference_type<float>);
+static_assert(!check_has_difference_type<double>);
+static_assert(!check_has_difference_type<long double>);
+static_assert(!check_has_difference_type<float&>);
+static_assert(!check_has_difference_type<float const&>);
+
+static_assert(!check_has_difference_type<void*>);
+static_assert(!check_has_difference_type<std::nullptr_t>);
+static_assert(!check_has_difference_type<int()>);
+static_assert(!check_has_difference_type<int() noexcept>);
+static_assert(!check_has_difference_type<int (*)()>);
+static_assert(!check_has_difference_type<int (*)() noexcept>);
+static_assert(!check_has_difference_type<int (&)()>);
+static_assert(!check_has_difference_type<int (&)() noexcept>);
+
+struct empty {};
+static_assert(!check_has_difference_type<empty>);
+static_assert(!check_has_difference_type<int empty::*>);
+static_assert(!check_has_difference_type<int (empty::*)()>);
+static_assert(!check_has_difference_type<int (empty::*)() noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() const>);
+static_assert(!check_has_difference_type<int (empty::*)() const noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() volatile>);
+static_assert(!check_has_difference_type<int (empty::*)() volatile noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() const volatile>);
+static_assert(
+    !check_has_difference_type<int (empty::*)() const volatile noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() &>);
+static_assert(!check_has_difference_type<int (empty::*)() & noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() const&>);
+static_assert(!check_has_difference_type<int (empty::*)() const & noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() volatile&>);
+static_assert(!check_has_difference_type<int (empty::*)() volatile & noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() const volatile&>);
+static_assert(
+    !check_has_difference_type<int (empty::*)() const volatile & noexcept>);
+static_assert(!check_has_difference_type<int (empty::*)() &&>);
+static_assert(!check_has_difference_type < int (empty::*)() && noexcept >);
+static_assert(!check_has_difference_type<int (empty::*)() const&&>);
+static_assert(!check_has_difference_type < int (empty::*)() const&& noexcept >);
+static_assert(!check_has_difference_type<int (empty::*)() volatile&&>);
+static_assert(!check_has_difference_type <
+              int (empty::*)() volatile&& noexcept >);
+static_assert(!check_has_difference_type<int (empty::*)() const volatile&&>);
+static_assert(!check_has_difference_type < int (empty::*)()
+                                               const volatile&& noexcept >);
+
+struct void_subtraction {
+  friend void operator-(void_subtraction, void_subtraction) noexcept;
+};
+static_assert(!check_has_difference_type<void_subtraction>);
+
+struct rvalue_ref_subtraction_can_throw {
+  friend int operator-(rvalue_ref_subtraction_can_throw&&,
+                       rvalue_ref_subtraction_can_throw&&);
+};
+static_assert(!check_has_difference_type<rvalue_ref_subtraction_can_throw>);
+
+struct lvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_lvalue_ref_subtraction&,
+                       lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_lvalue_ref_subtraction>);
+
+struct lvalue_ref_const_lvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_const_lvalue_ref_subtraction&,
+                       lvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(
+    !check_has_difference_type<lvalue_ref_const_lvalue_ref_subtraction>);
+
+struct lvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_volatile_lvalue_ref_subtraction&,
+                       lvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(
+    !check_has_difference_type<lvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct lvalue_ref_cv_lvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_cv_lvalue_ref_subtraction&,
+                       lvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct lvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_rvalue_ref_subtraction&,
+                       lvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_rvalue_ref_subtraction>);
+
+struct lvalue_ref_const_rvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_const_rvalue_ref_subtraction&,
+                       lvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<lvalue_ref_const_rvalue_ref_subtraction>);
+
+struct lvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_volatile_rvalue_ref_subtraction&,
+                       lvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(
+    !check_has_difference_type<lvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct lvalue_ref_cv_rvalue_ref_subtraction {
+  friend int operator-(lvalue_ref_cv_rvalue_ref_subtraction&,
+                       lvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct const_lvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(const_lvalue_ref_lvalue_ref_subtraction const&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(
+    !check_has_difference_type<const_lvalue_ref_lvalue_ref_subtraction>);
+
+struct const_lvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(const_lvalue_ref_volatile_lvalue_ref_subtraction const&,
+            const_lvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(!check_has_difference_type<
+              const_lvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct const_lvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(const_lvalue_ref_rvalue_ref_subtraction const&,
+                       const_lvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(
+    !check_has_difference_type<const_lvalue_ref_rvalue_ref_subtraction>);
+
+struct const_lvalue_ref_const_rvalue_ref_subtraction {
+  friend int operator-(const_lvalue_ref_const_rvalue_ref_subtraction const&,
+                       const_lvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<const_lvalue_ref_const_rvalue_ref_subtraction>);
+
+struct const_lvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(const_lvalue_ref_volatile_rvalue_ref_subtraction const&,
+            const_lvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(!check_has_difference_type<
+              const_lvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct const_lvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(const_lvalue_ref_cv_rvalue_ref_subtraction const&,
+            const_lvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<const_lvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(volatile_lvalue_ref_lvalue_ref_subtraction volatile&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_lvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_const_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_const_lvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(!check_has_difference_type<
+              volatile_lvalue_ref_const_lvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_volatile_lvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(!check_has_difference_type<
+              volatile_lvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_cv_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_cv_lvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(volatile_lvalue_ref_rvalue_ref_subtraction volatile&,
+                       volatile_lvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_rvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_const_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_const_rvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(!check_has_difference_type<
+              volatile_lvalue_ref_const_rvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_volatile_rvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(!check_has_difference_type<
+              volatile_lvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct volatile_lvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_lvalue_ref_cv_rvalue_ref_subtraction volatile&,
+            volatile_lvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(cv_lvalue_ref_lvalue_ref_subtraction const volatile&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(!check_has_difference_type<cv_lvalue_ref_lvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(cv_lvalue_ref_volatile_lvalue_ref_subtraction const volatile&,
+            cv_lvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(
+    !check_has_difference_type<cv_lvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(cv_lvalue_ref_rvalue_ref_subtraction const volatile&,
+                       cv_lvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(!check_has_difference_type<cv_lvalue_ref_rvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_const_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_lvalue_ref_const_rvalue_ref_subtraction const volatile&,
+            cv_lvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<cv_lvalue_ref_const_rvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_lvalue_ref_volatile_rvalue_ref_subtraction const volatile&,
+            cv_lvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(
+    !check_has_difference_type<cv_lvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct cv_lvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_lvalue_ref_cv_rvalue_ref_subtraction const volatile&,
+            cv_lvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<cv_lvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct rvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_lvalue_ref_subtraction&&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(!check_has_difference_type<rvalue_ref_lvalue_ref_subtraction>);
+
+struct rvalue_ref_const_lvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_const_lvalue_ref_subtraction&&,
+                       rvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(
+    !check_has_difference_type<rvalue_ref_const_lvalue_ref_subtraction>);
+
+struct rvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_volatile_lvalue_ref_subtraction&&,
+                       rvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(
+    !check_has_difference_type<rvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct rvalue_ref_cv_lvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_cv_lvalue_ref_subtraction&&,
+                       rvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(!check_has_difference_type<rvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct rvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_rvalue_ref_subtraction&&,
+                       rvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(!check_has_difference_type<rvalue_ref_rvalue_ref_subtraction>);
+
+struct rvalue_ref_const_rvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_const_rvalue_ref_subtraction&&,
+                       rvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<rvalue_ref_const_rvalue_ref_subtraction>);
+
+struct rvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_volatile_rvalue_ref_subtraction&&,
+                       rvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(
+    !check_has_difference_type<rvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct rvalue_ref_cv_rvalue_ref_subtraction {
+  friend int operator-(rvalue_ref_cv_rvalue_ref_subtraction&&,
+                       rvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(!check_has_difference_type<rvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct const_rvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(const_rvalue_ref_lvalue_ref_subtraction const&&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_lvalue_ref_subtraction>);
+
+struct const_rvalue_ref_const_lvalue_ref_subtraction {
+  friend int operator-(const_rvalue_ref_const_lvalue_ref_subtraction const&&,
+                       const_rvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_const_lvalue_ref_subtraction>);
+
+struct const_rvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(const_rvalue_ref_volatile_lvalue_ref_subtraction const&&,
+            const_rvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(!check_has_difference_type<
+              const_rvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct const_rvalue_ref_cv_lvalue_ref_subtraction {
+  friend int
+  operator-(const_rvalue_ref_cv_lvalue_ref_subtraction const&&,
+            const_rvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct const_rvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(const_rvalue_ref_rvalue_ref_subtraction const&&,
+                       const_rvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_rvalue_ref_subtraction>);
+
+struct const_rvalue_ref_const_rvalue_ref_subtraction {
+  friend int operator-(const_rvalue_ref_const_rvalue_ref_subtraction const&&,
+                       const_rvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_const_rvalue_ref_subtraction>);
+
+struct const_rvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(const_rvalue_ref_volatile_rvalue_ref_subtraction const&&,
+            const_rvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(!check_has_difference_type<
+              const_rvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct const_rvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(const_rvalue_ref_cv_rvalue_ref_subtraction const&&,
+            const_rvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<const_rvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(volatile_rvalue_ref_lvalue_ref_subtraction volatile&&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(
+    !check_has_difference_type<volatile_rvalue_ref_lvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_const_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_const_lvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(!check_has_difference_type<
+              volatile_rvalue_ref_const_lvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_volatile_lvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(!check_has_difference_type<
+              volatile_rvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_cv_lvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_cv_lvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(
+    !check_has_difference_type<volatile_rvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(volatile_rvalue_ref_rvalue_ref_subtraction volatile&&,
+                       volatile_rvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(
+    !check_has_difference_type<volatile_rvalue_ref_rvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_const_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_const_rvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(!check_has_difference_type<
+              volatile_rvalue_ref_const_rvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_volatile_rvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(!check_has_difference_type<
+              volatile_rvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct volatile_rvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(volatile_rvalue_ref_cv_rvalue_ref_subtraction volatile&&,
+            volatile_rvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<volatile_rvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_lvalue_ref_subtraction {
+  friend int operator-(cv_rvalue_ref_lvalue_ref_subtraction const volatile&&,
+                       const_lvalue_ref_lvalue_ref_subtraction&);
+};
+static_assert(!check_has_difference_type<cv_rvalue_ref_lvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_const_lvalue_ref_subtraction {
+  friend int
+  operator-(cv_rvalue_ref_const_lvalue_ref_subtraction const volatile&&,
+            cv_rvalue_ref_const_lvalue_ref_subtraction const&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_const_lvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_volatile_lvalue_ref_subtraction {
+  friend int
+  operator-(cv_rvalue_ref_volatile_lvalue_ref_subtraction const volatile&&,
+            cv_rvalue_ref_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_volatile_lvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_cv_lvalue_ref_subtraction {
+  friend int operator-(cv_rvalue_ref_cv_lvalue_ref_subtraction const volatile&&,
+                       cv_rvalue_ref_cv_lvalue_ref_subtraction const volatile&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_cv_lvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_rvalue_ref_subtraction {
+  friend int operator-(cv_rvalue_ref_rvalue_ref_subtraction const volatile&&,
+                       cv_rvalue_ref_rvalue_ref_subtraction&&);
+};
+static_assert(!check_has_difference_type<cv_rvalue_ref_rvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_const_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_rvalue_ref_const_rvalue_ref_subtraction const volatile&&,
+            cv_rvalue_ref_const_rvalue_ref_subtraction const&&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_const_rvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_volatile_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_rvalue_ref_volatile_rvalue_ref_subtraction const volatile&&,
+            cv_rvalue_ref_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_volatile_rvalue_ref_subtraction>);
+
+struct cv_rvalue_ref_cv_rvalue_ref_subtraction {
+  friend int
+  operator-(cv_rvalue_ref_cv_rvalue_ref_subtraction const volatile&&,
+            cv_rvalue_ref_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(
+    !check_has_difference_type<cv_rvalue_ref_cv_rvalue_ref_subtraction>);
+
+struct lvalue_ref_lvalue_subtraction {
+  friend int operator-(lvalue_ref_lvalue_subtraction&,
+                       lvalue_ref_lvalue_subtraction);
+};
+static_assert(!check_has_difference_type<lvalue_ref_lvalue_subtraction>);
+
+struct const_lvalue_ref_lvalue_subtraction {
+  friend int operator-(const_lvalue_ref_lvalue_subtraction const&,
+                       const_lvalue_ref_lvalue_subtraction);
+};
+static_assert(check_has_difference_type<const_lvalue_ref_lvalue_subtraction>);
+
+struct volatile_lvalue_ref_lvalue_subtraction {
+  friend int operator-(volatile_lvalue_ref_lvalue_subtraction volatile&,
+                       volatile_lvalue_ref_lvalue_subtraction);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_lvalue_subtraction>);
+
+struct rvalue_ref_lvalue_subtraction {
+  friend int operator-(rvalue_ref_lvalue_subtraction&&,
+                       rvalue_ref_lvalue_subtraction);
+};
+static_assert(!check_has_difference_type<lvalue_ref_lvalue_subtraction>);
+
+struct const_rvalue_ref_lvalue_subtraction {
+  friend int operator-(const_rvalue_ref_lvalue_subtraction const&&,
+                       const_rvalue_ref_lvalue_subtraction);
+};
+static_assert(check_has_difference_type<const_lvalue_ref_lvalue_subtraction>);
+
+struct volatile_rvalue_ref_lvalue_subtraction {
+  friend int operator-(volatile_rvalue_ref_lvalue_subtraction volatile&&,
+                       volatile_rvalue_ref_lvalue_subtraction);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_lvalue_subtraction>);
+
+struct cv_rvalue_ref_lvalue_subtraction {
+  friend int operator-(cv_rvalue_ref_lvalue_subtraction const volatile&&,
+                       cv_rvalue_ref_lvalue_subtraction);
+};
+static_assert(!check_has_difference_type<cv_rvalue_ref_lvalue_subtraction>);
+
+struct lvalue_lvalue_ref_subtraction {
+  friend int operator-(lvalue_lvalue_ref_subtraction,
+                       lvalue_lvalue_ref_subtraction&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_lvalue_subtraction>);
+
+struct lvalue_const_lvalue_ref_subtraction {
+  friend int operator-(lvalue_const_lvalue_ref_subtraction,
+                       lvalue_const_lvalue_ref_subtraction const&);
+};
+static_assert(check_has_difference_type<const_lvalue_ref_lvalue_subtraction>);
+
+struct lvalue_volatile_lvalue_ref_subtraction {
+  friend int operator-(lvalue_volatile_lvalue_ref_subtraction,
+                       lvalue_volatile_lvalue_ref_subtraction volatile&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_lvalue_subtraction>);
+
+struct lvalue_rvalue_ref_subtraction {
+  friend int operator-(lvalue_rvalue_ref_subtraction,
+                       lvalue_rvalue_ref_subtraction&&);
+};
+static_assert(!check_has_difference_type<lvalue_ref_lvalue_subtraction>);
+
+struct lvalue_const_rvalue_ref_subtraction {
+  friend int operator-(lvalue_const_rvalue_ref_subtraction,
+                       lvalue_const_rvalue_ref_subtraction const&&);
+};
+static_assert(!check_has_difference_type<lvalue_const_rvalue_ref_subtraction>);
+
+struct lvalue_volatile_rvalue_ref_subtraction {
+  friend int operator-(lvalue_volatile_rvalue_ref_subtraction,
+                       lvalue_volatile_rvalue_ref_subtraction volatile&&);
+};
+static_assert(
+    !check_has_difference_type<volatile_lvalue_ref_lvalue_subtraction>);
+
+struct lvalue_cv_rvalue_ref_subtraction {
+  friend int operator-(lvalue_cv_rvalue_ref_subtraction,
+                       lvalue_cv_rvalue_ref_subtraction const volatile&&);
+};
+static_assert(!check_has_difference_type<lvalue_cv_rvalue_ref_subtraction>);
+
+int main(int, char**) { return 0; }