[libc++] [ranges] Fix `decltype(auto) ranges::iter_move`

[• Quuxplusone]

Summary

The new test fails before this patch.
See

• https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92894#c3
• https://reviews.llvm.org/D119589#inline-1151299

[Mordante]

The GCC bug mentions Fixed for 10.2 and we use GCC 11 in our CI.

[philnik]

In D120417#3340764, @Mordante wrote:

The GCC bug mentions Fixed for 10.2 and we use GCC 11 in our CI.

The bug was a libstdc++ bug.

[jwakely]

In D120417#3340764, @Mordante wrote:

The GCC bug mentions Fixed for 10.2 and we use GCC 11 in our CI.

Fixed by changing libstdc++, which is irrelevant to libc++ because you're not using the libstdc++ code.

[• Quuxplusone]

Riiight. Actually use a projection type with non-external linkage, this time.

[• Quuxplusone]

GCC 11 was still happy with the previous test. Try one basically-not-reduced-at-all from the ranges::min review.

[• Quuxplusone]

I finally hit a reproducing case locally, while writing tests for C++20 move_iterator!

[• Quuxplusone]

https://reviews.llvm.org/harbormaster/unit/view/2832828/ — filed https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104792 for what I consider a bogus GCC warning, but will fix anyway.

[• Quuxplusone]

Fix GCC buildkite warning by removing unused typedefs.

libcxx/include/__iterator/iter_move.h

 
 template <class _Tp>
 concept __unqualified_iter_move =
   __class_or_enum<remove_cvref_t<_Tp>> &&
   requires (_Tp&& __t) {
     iter_move(std::forward<_Tp>(__t));
   };
 
+template<class _Tp>
+concept __move_deref =
+  !__unqualified_iter_move<_Tp> &&
+  requires (_Tp&& __t) {
+    *__t;
+    requires is_lvalue_reference_v<decltype(*__t)>;
+  };
+
+template<class _Tp>
+concept __just_deref =
+  !__unqualified_iter_move<_Tp> &&
+  !__move_deref<_Tp> &&
+  requires (_Tp&& __t) {
+    *__t;
+    requires (!is_lvalue_reference_v<decltype(*__t)>);
+  };
+
 // [iterator.cust.move]
 
 struct __fn {
   template<class _Ip>
     requires __unqualified_iter_move<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
     noexcept(noexcept(iter_move(std::forward<_Ip>(__i))))
   {
     return iter_move(std::forward<_Ip>(__i));
   }
 
   template<class _Ip>
-    requires (!__unqualified_iter_move<_Ip>) &&
-             requires { *declval<_Ip>(); }
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
+    requires __move_deref<_Ip>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
+    noexcept(noexcept(std::move(*std::forward<_Ip>(__i))))
+    -> decltype(      std::move(*std::forward<_Ip>(__i)))
+    { return          std::move(*std::forward<_Ip>(__i)); }
+
+  template<class _Ip>
+    requires __just_deref<_Ip>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
     noexcept(noexcept(*std::forward<_Ip>(__i)))
-  {
-    if constexpr (is_lvalue_reference_v<decltype(*declval<_Ip>())>) {
-      return std::move(*std::forward<_Ip>(__i));
-    } else {
-      return *std::forward<_Ip>(__i);
-    }
-  }
+    -> decltype(      *std::forward<_Ip>(__i))
+    { return          *std::forward<_Ip>(__i); }
 };
 } // namespace __iter_move
 
 inline namespace __cpo {
   inline constexpr auto iter_move = __iter_move::__fn{};
 } // namespace __cpo
 } // namespace ranges
 

libcxx/test/std/iterators/iterator.requirements/iterator.cust/iterator.cust.move/iter_rvalue_reference_t.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
 
 // template<class I>
 // using iter_rvalue_reference;
 
 #include <iterator>
 
-#include <concepts>
-#include <list>
-#include <vector>
+static_assert(std::same_as<std::iter_rvalue_reference_t<int*>, int&&>);
+static_assert(std::same_as<std::iter_rvalue_reference_t<const int*>, const int&&>);
 
-static_assert(std::same_as<std::iter_rvalue_reference_t<std::vector<int>::iterator&>, int&&>);
-static_assert(std::same_as<std::iter_rvalue_reference_t<std::vector<int>::const_iterator>, int const&&>);
-static_assert(std::same_as<std::iter_rvalue_reference_t<std::list<int const>::iterator>, int const&&>);
-
-int main(int, char**) { return 0; }
+void test_undefined_internal() {
+  struct A {
+    using value_type = int;
+    using difference_type = int;
+    int& operator*() const;
+  };
+  static_assert(std::same_as<std::iter_rvalue_reference_t<A>, int&&>);
+}