Avoid _Iter_diff_t in parameters of std function templates

stl/inc/algorithm

@@ -5412,7 +5412,8 @@ void random_shuffle(_RanIt _First, _RanIt _Last) { // shuffle [_First, _Last) us
 
 #if _HAS_CXX20
 _EXPORT_STD template <class _FwdIt>
-constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
+constexpr _FwdIt shift_left(
+    _FwdIt _First, const _FwdIt _Last, typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) {
     // shift [_First, _Last) left by _Pos_to_shift
     // positions; returns the end of the resulting range
     _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
@@ -5446,15 +5447,17 @@ constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_Fwd
 }
 
 _EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
-_FwdIt shift_left(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept /* terminates */ {
+_FwdIt shift_left(_ExPo&&, _FwdIt _First, _FwdIt _Last,
+    typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) noexcept /* terminates */ {
     // shift [_First, _Last) left by _Pos_to_shift positions
     // not parallelized as benchmarks show it isn't worth it
     _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
     return _STD shift_left(_First, _Last, _Pos_to_shift);
 }
 
 _EXPORT_STD template <class _FwdIt>
-constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
+constexpr _FwdIt shift_right(
+    _FwdIt _First, const _FwdIt _Last, typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) {
     // shift [_First, _Last) right by _Pos_to_shift
     // positions; returns the beginning of the resulting range
     _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/5)");
@@ -5528,7 +5531,8 @@ constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_Fw
 }
 
 _EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
-_FwdIt shift_right(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept /* terminates */ {
+_FwdIt shift_right(_ExPo&&, _FwdIt _First, _FwdIt _Last,
+    typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) noexcept /* terminates */ {
     // shift [_First, _Last) right by _Pos_to_shift positions
     // not parallelized as benchmarks show it isn't worth it
     _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);

stl/inc/xutility

@@ -1464,7 +1464,8 @@ constexpr _InIt _Next_iter(_InIt _First) { // increment iterator
 }
 
 _EXPORT_STD template <class _InIt>
-_NODISCARD _CONSTEXPR17 _InIt next(_InIt _First, _Iter_diff_t<_InIt> _Off = 1) { // increment iterator
+_NODISCARD _CONSTEXPR17 _InIt next(
+    _InIt _First, typename iterator_traits<_InIt>::difference_type _Off = 1) { // increment iterator
     static_assert(_Is_ranges_input_iter_v<_InIt>, "next requires input iterator");
 
     _STD advance(_First, _Off);
@@ -1477,7 +1478,8 @@ constexpr _BidIt _Prev_iter(_BidIt _First) { // decrement iterator
 }
 
 _EXPORT_STD template <class _BidIt>
-_NODISCARD _CONSTEXPR17 _BidIt prev(_BidIt _First, _Iter_diff_t<_BidIt> _Off = 1) { // decrement iterator
+_NODISCARD _CONSTEXPR17 _BidIt prev(
+    _BidIt _First, typename iterator_traits<_BidIt>::difference_type _Off = 1) { // decrement iterator
     static_assert(_Is_ranges_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");
 
     _STD advance(_First, -_Off);

tests/std/test.lst

@@ -732,3 +732,4 @@ tests\VSO_0849827_multicontainer_emplace_hint_position
 tests\VSO_0938757_attribute_order
 tests\VSO_0961751_hash_range_erase
 tests\VSO_0971246_legacy_await_headers
+tests\VSO_1925201_iter_traits

tests/std/tests/VSO_1925201_iter_traits/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_20_matrix.lst

tests/std/tests/VSO_1925201_iter_traits/test.compile.pass.cpp

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <concepts>
+#include <iterator>
+
+// Defend against regression of DevCom-10532126, in which several function templates used
+// `_Iter_diff_t<meow>` as a parameter type instead of the specified
+// `typename iterator_traits<meow>::difference_type`. The two are equivalent in C++17, but in C++20
+// _Iter_diff_t<meow> becomes iter_difference_t<meow>. We thought the difference was not observable,
+// but it interferes with concept overloading.
+
+using std::iter_value_t, std::iterator_traits, std::same_as;
+using std::next, std::prev, std::shift_left, std::shift_right;
+
+struct meow {};
+
+constexpr meow* nil = nullptr;
+
+template <class I>
+concept Meowerator = same_as<iter_value_t<I>, meow>;
+
+template <Meowerator I>
+void next(I, typename iterator_traits<I>::difference_type = 1) {}
+
+template <Meowerator I>
+void prev(I, typename iterator_traits<I>::difference_type = 1) {}
+
+template <Meowerator I>
+void shift_left(I, I, typename iterator_traits<I>::difference_type) {}
+template <Meowerator I>
+void shift_right(I, I, typename iterator_traits<I>::difference_type) {}
+// Note that we intentionally do not test the ExecutionPolicy overloads of shift_meow. They are
+// constrained via an unspecified mechanism to "not participate in overload resolution unless
+// is_execution_policy_v<ExecutionPolicy> is true", effectively making concept overloading
+// impossible (or at least non-portable).
+
+static_assert(same_as<void, decltype(next(nil))>);
+static_assert(same_as<void, decltype(next(nil, 42))>);
+
+static_assert(same_as<void, decltype(prev(nil))>);
+static_assert(same_as<void, decltype(prev(nil, 42))>);
+
+#ifndef __clang__ // TRANSITION, LLVM-75404
+static_assert(same_as<void, decltype(shift_left(nil, nil, 42))>);
+static_assert(same_as<void, decltype(shift_right(nil, nil, 42))>);
+#endif // TRANSITION, LLVM-75404