[libcxx] patch for implementing ranges::find_last

[phyBrackets]

Summary

patch for implementing https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1223r5.pdf

[huixie90]

libcxx/include/__algorithm/ranges_find_last.h

2

Please add tests for all the algorithms' behaviour and constraints.
You can take a look at this to get an idea about how we test algorithms
https://reviews.llvm.org/D130404

30

is the paper C++23? If so, should it be

#if _LIBCPP_STD_VER >= 23

same applies to other files in the patch

40

question. can we use static operator() now?

libcxx/include/__algorithm/ranges_find_last_if.h

37

There are several issues.

1. In general __last is a sentinel (as supposed to be an iterator). The only thing you can do about it is to compare with an iterator. so you cannot use operator-- for a sentinel.
2. The algorithm's requirement is forward_iterator (instead of bidirectional_iterator). operator-- does not exist for forward_iteartor. You will probably need to dispatch to different implementations depending on whether it is common_range, bidirectional_range, sized_sentinel_for/sized_range

[fsb4000]

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if_not.pass.cpp

217

Should be static_assert?

[fsb4000]

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if.pass.cpp

231

static_assert

[fsb4000]

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last.pass.cpp

246

static_assert

[fsb4000]

libcxx/docs/Status/Cxx2bPapers.csv

58

instead of

"","|ranges|"

should be

"17.0","|ranges|"

[Mordante]

Thanks for your patch. I only want over it lightly. I will do an full review after the current open issues are addressed.

libcxx/include/__algorithm/ranges_find_last.h

30

@phyBrackets can you mark items as done when they are done? That makes reviewing these changes a lot easier.

40

Why would that not be possible, I've seen this used in other ranges patches too.

56

Please run clang-format on new files, I'm quite sure this indention is off.

libcxx/include/__algorithm/ranges_find_last_if.h

39

Please don't use auto everywhere, this just makes things harder to read.
Please make sure all names are __uglified, for example result too,

libcxx/include/__algorithm/ranges_find_last_if_not.h

43

naming is hard, but let's try to use something better than just a number.
How about __not_pred since this is basically the inverse of the predicate given.

Another option is just not giving this predicate a name and write it in the return statement on the next line.

libcxx/include/algorithm

102

This indention is off.

104

Please align all these since entries.

libcxx/include/module.modulemap.in

365

Please fix the alignment of the {.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last.pass.cpp

82

Here you should use std::same_as<return type> auto method. For example have a look at
libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if.pass.cpp

106

Please use clang-format on these tests, this looks wrong.

libcxx/utils/data/ignore_format.txt

119 ↗

(On Diff #506629)

The ignore list is there since we don't want to reformat our entire code base and have merge conflicts for existing patches. New files should always be formatted.

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

170

Typically we don't update the bazel files, there is a post-commit bot that does that.

[var-const]

So sorry it took me so long to get to this review!

libcxx/include/__algorithm/ranges_find_last.h

16

Is this used?

17

Is this used?

38–39

This formatting looks really weird, is it produced by clang-format? (If so, feel free to disable it for these lines by adding a // clang-format off comment, then reenable with // clang-format on)

39

Can you also add _LIBCPP_NODISCARD_EXT to all the new algorithms? We want to mark these as [[nodiscard]] since they have no side effects and are only used to produce a value, but since they aren't marked as such in the Standard, we have to do it as an extension. Please also update the test/libcxx/diagnostics/ranges.nodiscard_extensions.verify.cpp test file.

41

Question: what's the case where forward would make a difference? Do we have a test for that?

62

>= 23.

libcxx/include/__algorithm/ranges_find_last_if.h

39

Normally we simply increment __first, no need to create a separate variable.

39–47

Recreating the whole __result each time seems a little wasteful, consider:

_Ip __result = __last;
while (__first != __last) {
  if (std::invoke(__pred, std::invoke(__proj, * __first))) {
    __result = __first;
  }
  ++__first;
}
return {__result, __last};

45

For a bidirectional common range, it seems more efficient to iterate from the end -- then you can return as soon as you find an element satisfying the predicate. For a bidirectional non-common range, it might still be more efficient to create an iterator from the sentinel and go from the end (though this is debatable).

55

Missing _LIBCPP_HIDE_FROM_ABI.

58

Please add a newline after this line.

63

Missing _LIBCPP_HIDE_FROM_ABI.

77

>= 23.

libcxx/include/__algorithm/ranges_find_last_if_not.h

16

iterator_operations.h might be unnecessary.

43

Do we have a test that fails if we remove this forward?

43

Very optional: __negate_pred or __negated_pred?

52

To avoid duplicating this logic, consider instead delegating to the iterator version of find_last_if_not.

65

>= 23

libcxx/include/algorithm

102

Nit: please fix indentation here.

104

Nit: can these comments (// since C++23) be aligned?

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last.pass.cpp

82

Looks not done?

146

This test should also apply to the iterator version of the algorithm, right? (applies to the other two test files as well)

165

Wrong indentation.

176

Do the other two files need an equivalent test?

216

Does this have to be constexpr?

231

The other files use BooleanComparable, can this be made consistent?

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if.pass.cpp

10

Note: most comments in this file apply to the other two test files as well.

36

s/HasFindIfIt/HasFindLastIfIt/, same for the range version below.

54

Please also add a case where HasFindLastIfPred is true (to test the test, so to speak).

72

Can we add a few more test cases?

• empty range;
• 1-element range;
• no element satisfies the predicate;
• all elements satisfy the predicate;
• the element being searched is the first one;
• the element being searched is the last one.

74

This formatting is incorrect, continuations should be indented.

74

Why is it mutable?

79

Please reuse the input between the iterator version and the range version, it cuts down boilerplate and makes it easier to verify that the two test cases are equivalent.

88

It's better if the tests for these very similar algorithms are as uniform as possible. The find_last_if_not test file calls this helper NonConstComparableLvalue while the find_last test file has both NonConstComparableLValue and NonConstComparableRValue . Can this be consistent?

89

Are all 4 overloads necessary? If so, please add a short comment to explain why.

96

Consider using types::for_each to cut down on the boilerplate a little.

98

Can these types be ordered from most to least restrictive? (or vice versa)

103

Can you rephrase the called with the iterator directly bit? It reads as if the projection receives an iterator as an argument, which isn't the case. I think something like called with the reference to the element the iterator is pointing to would be more technically correct (though this can definitely be improved).

107

Please make the projection a named variable and reuse it between the iterator version and the range version.

108–109

Optional: consider adding blank lines between scopes (throughout). I find code easier to read when it's split into logical blocks, and different scopes offer a very straightforward point for splitting.

122

How about s/other/index/?

131

(throughout) You can reuse these helper types between the iterator version and the range version to reduce boilerplate.

144

Nit: s/end + 1/past-the-end/.

144

I would move this test to test_iterators.

159

Nit: I'd use decltype(auto). In this case the difference isn't really relevant, but IMO it's better to just always use decltype(auto) which catches the exact return type and never have to think about it.

183

Please see if the types from test/support/counting_{projection,predicates}.h can be used here.

209

Can you please elaborate a little on this comment? I'm not sure how it relates to the test (which seems to check whether a predicate that takes arguments by a non-const reference works with the algorithm).

222

Please move this test case to test_iterators.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if_not.pass.cpp

74

Can we use a simpler predicate? These tests should check the most basic logic and be as easy to read as possible.

119

Last element?

255

Please also update test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp and the *robust* test files where applicable (searching for ranges::find_if among the *robust* test files should give a good idea of which ones to update).

[ldionne]

@phyBrackets Do you have any plans to keep working on this?

[phyBrackets]

Probably yes , I was just a bit busy with gsoc project and nowdays i am a bit sick! I will get over this patch as soon as possible.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_constexpr_cmath``                     *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_memory``                    ``202202L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_typeinfo``                  ``202106L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_expected``                            ``202202L``
     ------------------------------------------------- -----------------
+    ``__cpp_lib_find_last``                           ``202207L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_forward_like``                        ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_invoke_r``                            ``202106L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_move_only_function``                  *unimplemented*
     ------------------------------------------------- -----------------

libcxx/docs/ReleaseNotes.rst

 
 What's New in Libc++ 17.0.0?
 ============================
 
 Implemented Papers
 ------------------
 - P2520R0 - ``move_iterator<T*>`` should be a random access iterator
 - P1328R1 - ``constexpr type_info::operator==()``
+- P1223R5 - ``find_last``
 
 Improvements and New Features
 -----------------------------
 - ``std::equal`` and ``std::ranges::equal`` are now forwarding to ``std::memcmp`` for integral types and pointers,
   which can lead up to 40x performance improvements.
 
 - ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe
   libc++ mode is enabled.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_with``","February 2022","","","|ranges|"
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","","","|ranges|"
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","","","|ranges|"
 "","","","","","",""
 "`P0009R18 <https://wg21.link/P0009R18>`__","LWG","mdspan: A Non-Owning Multidimensional Array Reference","July 2022","",""
 "`P0429R9 <https://wg21.link/P0429R9>`__","LWG","A Standard ``flat_map``","July 2022","",""
 "`P1169R4 <https://wg21.link/P1169R4>`__","LWG","``static operator()``","July 2022","|Complete|","16.0"
 "`P1222R4 <https://wg21.link/P1222R4>`__","LWG","A Standard ``flat_set``","July 2022","",""
-"`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","","","|ranges|"
+"`P1223R5 <https://wg21.link/P1223R5>`__","LWG","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","July 2022","|Complete|","17.0","|ranges|"
 "`P1467R9 <https://wg21.link/P1467R9>`__","LWG","Extended ``floating-point`` types and standard names","July 2022","",""
 "`P1642R11 <https://wg21.link/P1642R11>`__","LWG","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","July 2022","",""
 "`P1899R3 <https://wg21.link/P1899R3>`__","LWG","``stride_view``","July 2022","","","|ranges|"
 "`P2093R14 <https://wg21.link/P2093R14>`__","LWG","Formatted output","July 2022","",""
 "`P2165R4 <https://wg21.link/P2165R4>`__","LWG","Compatibility between ``tuple``, ``pair`` and ``tuple-like`` objects","July 2022","",""
 "`P2278R4 <https://wg21.link/P2278R4>`__","LWG","``cbegin`` should always return a constant iterator","July 2022","","","|ranges|"
 "`P2286R8 <https://wg21.link/P2286R8>`__","LWG","Formatting Ranges","July 2022","|Complete|","16.0","|format| |ranges|"
 "`P2291R3 <https://wg21.link/P2291R3>`__","LWG","Add Constexpr Modifiers to Functions ``to_chars`` and ``from_chars`` for Integral Types in ``<charconv>`` Header","July 2022","|Complete|","16.0"

libcxx/include/CMakeLists.txt

set(files
   __algorithm/ranges_equal_range.h
   __algorithm/ranges_fill.h
   __algorithm/ranges_fill_n.h
   __algorithm/ranges_find.h
   __algorithm/ranges_find_end.h
   __algorithm/ranges_find_first_of.h
   __algorithm/ranges_find_if.h
   __algorithm/ranges_find_if_not.h
+  __algorithm/ranges_find_last.h
+  __algorithm/ranges_find_last_if.h
+  __algorithm/ranges_find_last_if_not.h
   __algorithm/ranges_for_each.h
   __algorithm/ranges_for_each_n.h
   __algorithm/ranges_generate.h
   __algorithm/ranges_generate_n.h
   __algorithm/ranges_includes.h
   __algorithm/ranges_inplace_merge.h
   __algorithm/ranges_is_heap.h
   __algorithm/ranges_is_heap_until.h

libcxx/include/__algorithm/ranges_find_last.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___ALGORITHM_RANGES_FIND_LAST_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+
+#include <__algorithm/ranges_find_last_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __find_last {
+struct __fn {
+  template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*>
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Ip>
+  operator()(_Ip __first, _Sp __last, const _Tp& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
+    return ranges::__find_last_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <forward_range _Rp, class _Tp, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rp>, _Proj>, const _Tp*>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Rp>
+  operator()(_Rp&& __r, const _Tp& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
+    return ranges::__find_last_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
+  }
+};
+} // namespace __find_last
+
+inline namespace __cpo {
+inline constexpr auto find_last = __find_last::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 23
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
 No newline at end of file

libcxx/include/__algorithm/ranges_find_last_if.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___ALGORITHM_RANGES_FIND_LAST_IF_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Ip, class _Sp, class _Pred, class _Proj>
+_LIBCPP_HIDE_FROM_ABI static constexpr subrange<_Ip>
+__find_last_if_impl(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj) {
+    auto current = __first;
+    subrange<_Ip> result {__last, __last};
+    while (current != __last) {
+        if (std::invoke(__pred, std::invoke(__proj, *current))) {
+            result = {current, __last};
+        }
+        ++current;
+    }
+    return result;
+}
+
+namespace __find_last_if {
+struct __fn {
+  template <forward_range _Rp,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  _LIBCPP_NODISCARD_EXT constexpr borrowed_subrange_t<_Rp>
+  operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__find_last_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
+  }
+  template <forward_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+  _LIBCPP_NODISCARD_EXT constexpr subrange<_Ip>
+  operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__find_last_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+};
+} // namespace __find_last_if
+
+inline namespace __cpo {
+inline constexpr auto find_last_if = __find_last_if::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 23
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_H
 No newline at end of file

libcxx/include/__algorithm/ranges_find_last_if_not.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___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
+
+#include <__algorithm/ranges_find_last_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __find_last_if_not {
+struct __fn {
+  template <forward_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Ip>
+  operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+    return ranges::__find_last_if_impl(std::move(__first), std::move(__last), __pred2, __proj);
+  }
+
+  template <forward_range _Rp,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Rp>
+  operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+    return ranges::__find_last_if_impl(ranges::begin(__r), ranges::end(__r), __pred2, __proj);
+  }
+};
+} // namespace __find_last_if_not
+
+inline namespace __cpo {
+inline constexpr auto find_last_if_not = __find_last_if_not::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 23
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_IF_NOT_H
 No newline at end of file

libcxx/include/algorithm

template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});                                  // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr borrowed_iterator_t<R>
       find_if_not(R&& r, Pred pred, Proj proj = {});                                                      // since C++20
 
+        template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+  requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+     constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});              // since
+C++23
+
+  template<forward_range R, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    constexpr borrowed_subrange_t<R>
+      ranges::find_last(R&& r, const T& value, Proj proj = {});                           //since C++23
+
+  template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});                // since
+C++23
+
+  template<forward_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_subrange_t<R>
+      ranges::find_last_if(R&& r, Pred pred, Proj proj = {});                             // since C++23
+
+  template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});            // since
+C++23
+
+  template<forward_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_subrange_t<R>
+      ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});                          // since C++23
+
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});                               // since C++20
 

 #include <__algorithm/ranges_equal_range.h>
 #include <__algorithm/ranges_fill.h>
 #include <__algorithm/ranges_fill_n.h>
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_end.h>
 #include <__algorithm/ranges_find_first_of.h>
 #include <__algorithm/ranges_find_if.h>
 #include <__algorithm/ranges_find_if_not.h>
+#include <__algorithm/ranges_find_last.h>
+#include <__algorithm/ranges_find_last_if.h>
+#include <__algorithm/ranges_find_last_if_not.h>
 #include <__algorithm/ranges_for_each.h>
 #include <__algorithm/ranges_for_each_n.h>
 #include <__algorithm/ranges_generate.h>
 #include <__algorithm/ranges_generate_n.h>
 #include <__algorithm/ranges_includes.h>
 #include <__algorithm/ranges_inplace_merge.h>
 #include <__algorithm/ranges_is_heap.h>
 #include <__algorithm/ranges_is_heap_until.h>

libcxx/include/module.modulemap.in

module __algorithm {
       }
       module ranges_fill                     { private header "__algorithm/ranges_fill.h" }
       module ranges_fill_n                   { private header "__algorithm/ranges_fill_n.h" }
       module ranges_find                     { private header "__algorithm/ranges_find.h" }
       module ranges_find_end                 { private header "__algorithm/ranges_find_end.h" }
       module ranges_find_first_of            { private header "__algorithm/ranges_find_first_of.h" }
       module ranges_find_if                  { private header "__algorithm/ranges_find_if.h" }
       module ranges_find_if_not              { private header "__algorithm/ranges_find_if_not.h" }
+      module ranges_find_last                  { private header "__algorithm/ranges_find_last.h" }
+      module ranges_find_last_if             { private header "__algorithm/ranges_find_last_if.h" }
+      module ranges_find_last_if_not             { private header "__algorithm/ranges_find_last_if_not.h" }
       module ranges_for_each {
         private header "__algorithm/ranges_for_each.h"
         export algorithm.__algorithm.in_fun_result
       }
       module ranges_for_each_n {
         private header "__algorithm/ranges_for_each_n.h"
         export algorithm.__algorithm.in_fun_result
       }

libcxx/include/version

 __cpp_lib_erase_if                                      202002L <deque> <forward_list> <list>
                                                                 <map> <set> <string>
                                                                 <unordered_map> <unordered_set> <vector>
 __cpp_lib_exchange_function                             201304L <utility>
 __cpp_lib_execution                                     201902L <execution>
                                                         201603L // C++17
 __cpp_lib_expected                                      202202L <expected>
 __cpp_lib_filesystem                                    201703L <filesystem>
+__cpp_lib_find_last                                     202207L <algorithm>
 __cpp_lib_format                                        202106L <format>
 __cpp_lib_forward_like                                  202207L <utility>
 __cpp_lib_gcd_lcm                                       201606L <numeric>
 __cpp_lib_generic_associative_lookup                    201304L <map> <set>
 __cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set>
 __cpp_lib_hardware_interference_size                    201703L <new>
 __cpp_lib_has_unique_object_representations             201606L <type_traits>
 __cpp_lib_hypot                                         201603L <cmath>

 # define __cpp_lib_byteswap                             202110L
 # define __cpp_lib_constexpr_bitset                     202207L
 # define __cpp_lib_constexpr_charconv                   202207L
 // # define __cpp_lib_constexpr_cmath                      202202L
 # undef  __cpp_lib_constexpr_memory
 # define __cpp_lib_constexpr_memory                     202202L
 # define __cpp_lib_constexpr_typeinfo                   202106L
 # define __cpp_lib_expected                             202202L
+# define __cpp_lib_find_last                            202207L
 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 # define __cpp_lib_ranges_as_rvalue                     202207L

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__algorithm/ranges_equal_range.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal_range.h'}}
 #include <__algorithm/ranges_fill.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill.h'}}
 #include <__algorithm/ranges_fill_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill_n.h'}}
 #include <__algorithm/ranges_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
 #include <__algorithm/ranges_find_end.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_end.h'}}
 #include <__algorithm/ranges_find_first_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_first_of.h'}}
 #include <__algorithm/ranges_find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
 #include <__algorithm/ranges_find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
+#include <__algorithm/ranges_find_last.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_last.h'}}
+#include <__algorithm/ranges_find_last_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_last_if.h'}}
+#include <__algorithm/ranges_find_last_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_last_if_not.h'}}
 #include <__algorithm/ranges_for_each.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each.h'}}
 #include <__algorithm/ranges_for_each_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each_n.h'}}
 #include <__algorithm/ranges_generate.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_generate.h'}}
 #include <__algorithm/ranges_generate_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_generate_n.h'}}
 #include <__algorithm/ranges_includes.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_includes.h'}}
 #include <__algorithm/ranges_inplace_merge.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_inplace_merge.h'}}
 #include <__algorithm/ranges_is_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_heap.h'}}
 #include <__algorithm/ranges_is_heap_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_heap_until.h'}}

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+//   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+//  constexpr subrange<I> ranges::find_last(I first, S last, const T& value, Proj proj = {});
+// template<forward_range R, class T, class Proj = identity>
+//   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+//  constexpr borrowed_subrange_t<R>
+// ranges::find_last(R&& r, const T& value, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "boolean_testable.h"
+#include "test_iterators.h"
+
+struct NotEqualityComparable {};
+
+template <class It, class Sent = It>
+concept HasFindIt = requires(It it, Sent sent) { std::ranges::find_last(it, sent, *it); };
+static_assert(HasFindIt<int*>);
+static_assert(!HasFindIt<NotEqualityComparable*>);
+static_assert(!HasFindIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIt<int*, int>);
+static_assert(!HasFindIt<int, int*>);
+
+template <class Range, class ValT>
+concept HasFindR = requires(Range r) { std::ranges::find_last(r, ValT{}); };
+static_assert(HasFindR<std::array<int, 1>, int>);
+static_assert(!HasFindR<int, int>);
+static_assert(!HasFindR<std::array<NotEqualityComparable, 1>, NotEqualityComparable>);
+static_assert(!HasFindR<InputRangeNotDerivedFrom, int>);
+static_assert(!HasFindR<InputRangeNotIndirectlyReadable, int>);
+static_assert(!HasFindR<InputRangeNotInputOrOutputIterator, int>);
+static_assert(!HasFindR<InputRangeNotSentinelSemiregular, int>);
+static_assert(!HasFindR<InputRangeNotSentinelEqualityComparableWith, int>);
+
+struct OneWayComparable {
+  bool isLeft;
+  friend constexpr bool operator==(OneWayComparable l, OneWayComparable) { return l.isLeft; }
+};
+
+struct NonConstComparableLValue {
+  friend constexpr bool operator==(const NonConstComparableLValue&, const NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, const NonConstComparableLValue&) { return true; }
+};
+
+struct NonConstComparableRValue {
+  friend constexpr bool operator==(const NonConstComparableRValue&, const NonConstComparableRValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableRValue&&, const NonConstComparableRValue&&) { return false; }
+  friend constexpr bool operator==(NonConstComparableRValue&&, NonConstComparableRValue&&) { return false; }
+  friend constexpr bool operator==(NonConstComparableRValue&&, const NonConstComparableRValue&) { return true; }
+};
+
+constexpr bool test() {
+
+  {
+    // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last(a, a + 4, a + 3, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last(a, a + 3, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+  }
+
+  { // check that the end element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last(a, 0, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last(a, a + 3, 0, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+  }
+
+  { // check that end + 1 iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_last(a, a + 3, 0);
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_last(a, 0);
+      assert(ret.data() == a + 3);
+    }
+  }
+
+  {
+    // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find_last(std::array{1, 2}, 3);
+  }
+
+  {
+    // check that an iterator is returned with a borrowing range
+    int a[] = {1, 1, 2, 3, 4};
+    auto ret = std::ranges::find_last(std::views::all(a), 1);
+    assert(ret.data() == a + 1);
+    assert(*(ret.data()) == 1);
+  }
+
+  {
+    // check that std::invoke is used
+    struct S { int i; };
+    S a[] = { S{1}, S{3}, S{2} };
+    auto ret = std::ranges::find_last(a, 4, &S::i);
+    assert(ret.data() == a + 3);
+  }
+
+  {
+    // count invocations of the projection
+    {
+      int a[] = {1, 2, 2, 3, 4};
+      int projection_count = 0;
+      auto ret = std::ranges::find_last(a, a + 5, 2, [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 2);
+      assert(*(ret.data()) == 2);
+      assert(projection_count == 5);
+    }
+    {
+      int a[] = {1, 2, 2, 3, 4};
+      int projection_count = 0;
+      auto ret = std::ranges::find_last(a, 2, [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 2);
+      assert(*(ret.data()) == 2);
+      assert(projection_count == 5);
+    }
+  }
+
+  {
+    // check comparison order
+    {
+      OneWayComparable a[] = { OneWayComparable{true} };
+      auto ret = std::ranges::find_last(a, a + 1, OneWayComparable{false});
+      assert(ret.data() == a);
+    }
+    {
+      OneWayComparable a[] = { OneWayComparable{true} };
+      auto ret = std::ranges::find_last(a, OneWayComparable{false});
+      assert(ret.data() == a);
+    }
+  }
+
+  {
+    // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_last(a, a + 1, NonConstComparableLValue{});
+      assert(ret.data() == a);
+    }
+    {
+      using It = std::move_iterator<NonConstComparableRValue*>;
+      NonConstComparableRValue a[] = { NonConstComparableRValue{} };
+      auto ret = std::ranges::find_last(It(a), It(a + 1), NonConstComparableRValue{});
+      assert(ret.begin().base() == a);
+    }
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_last(a, NonConstComparableLValue{});
+      assert(ret.data() == a);
+    }
+    {
+      using It = std::move_iterator<NonConstComparableRValue*>;
+      NonConstComparableRValue a[] = { NonConstComparableRValue{} };
+      auto range = std::ranges::subrange(It(a), It(a + 1));
+      auto ret = std::ranges::find_last(range, NonConstComparableRValue{});
+      assert(ret.begin().base() == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int ,0> a = {};
+      constexpr int search_value = 1;
+      auto ret = std::ranges::find_last(a.begin(), a.end(), search_value);
+      assert(ret.data() == a.end());
+    }
+    {
+      std::array<int, 0> a = {};
+      constexpr int search_value = 1;
+      auto ret = std::ranges::find_last(a, search_value);
+      assert(ret.data() == a.end());
+    }
+  }
+
+  {
+    // check that the implicit conversion to bool works
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 3, 4};
+      auto ret = std::ranges::find_last(a, a + 4, StrictComparable<int>{2});
+      assert(ret.data() == a + 2);
+    }
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 3, 4};
+      auto ret = std::ranges::find_last(a, StrictComparable<int>{2});
+      assert(ret.data() == a + 2);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//  constexpr subrange<I> ranges::find_last_if(I first, S last, Pred pred, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//  constexpr borrowed_subrange_t<R>
+// ranges::find_last_if(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "boolean_testable.h"
+#include "test_iterators.h"
+
+struct Predicate {
+  bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindIfIt = requires(It it, Sent sent) {
+  std::ranges::find_last_if(it, sent, Predicate{});
+};
+static_assert(HasFindIfIt<int*>);
+static_assert(!HasFindIfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIfIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIfIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIfIt<int*, int>);
+static_assert(!HasFindIfIt<int, int*>);
+
+template <class Pred>
+concept HasFindIfPred = requires(int* it, Pred pred) {
+  std::ranges::find_last_if(it, it, pred);
+};
+
+static_assert(!HasFindIfPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindIfPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindIfR = requires(R r) {
+  std::ranges::find_last_if(r, Predicate{});
+};
+static_assert(HasFindIfR<std::array<int, 0>>);
+static_assert(!HasFindIfR<int>);
+static_assert(!HasFindIfR<InputRangeNotDerivedFrom>);
+static_assert(!HasFindIfR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasFindIfR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasFindIfR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasFindIfR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  {
+    int a[] = {1, 2, 3, 4};
+    auto ret = std::ranges::find_last_if(It(a), Sent(It(a + 4)), [](int x) mutable { return x == 4; });
+    assert(base(ret.begin()) == a + 3);
+    assert(*ret.begin() == 4);
+  }
+  {
+    int a[] = {1, 2, 3, 4};
+    auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+    auto ret = std::ranges::find_last_if(range, [](int x) mutable { return x == 4; });
+    assert(base(ret.begin()) == a + 3);
+    assert(*ret.begin() == 4);
+  }
+}
+
+struct NonConstComparable {
+  friend constexpr bool operator==(const NonConstComparable&, const NonConstComparable&) { return false; }
+  friend constexpr bool operator==(NonConstComparable&, NonConstComparable&) { return false; }
+  friend constexpr bool operator==(const NonConstComparable&, NonConstComparable&) { return false; }
+  friend constexpr bool operator==(NonConstComparable&, const NonConstComparable&) { return true; }
+};
+
+ constexpr bool test() {
+  test_iterators<int*>();
+  test_iterators<const int*>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+
+  {
+    // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last_if(
+      a, a + 4, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[]  = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last_if(
+      a, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+  }
+
+  {
+    // check that the last element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last_if(a, [](int i) { return i == 0; }, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[]    = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last_if(
+      a, a + 3, [](int i) { return i == 0; }, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+  }
+
+  {
+    // check that end + 1 iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_last_if(a, a + 3, [](int) { return false; });
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[]  = {1, 1, 1};
+      auto ret = std::ranges::find_last_if(a, [](int) { return false; });
+      assert(ret.data() == a + 3);
+    }
+  }
+
+  {
+  // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find_last_if(std::array{1, 2}, [](int) { return false; });
+  }
+
+  {
+  // check that an iterator is returned with a borrowing range
+    int a[]  = {1, 1, 2, 3, 4};
+    auto ret = std::ranges::find_last_if(std::views::all(a), [](int) { return true; });
+    assert(ret.data() == a + 4);
+  }
+
+  {
+  // check that std::invoke is used
+    struct S { int i; };
+    S a[]    = {S{1}, S{3}, S{2}};
+    auto ret = std::ranges::find_last_if(a, [](int) { return false; }, &S::i);
+    assert(ret.data() == a + 3);
+  }
+
+  {
+  // count projection and predicate invocation count
+    {
+      int a[] = {1, 2, 2, 3, 4};
+      int predicate_count  = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_last_if(a, a + 5,
+                                      [&](int i) { ++predicate_count; return i == 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 2);
+      assert(*(ret.data()) == 2);
+      assert(predicate_count == 5);
+      assert(projection_count == 5);
+    }
+    {
+      int a[] = {1, 2, 2, 3, 4};
+      int predicate_count  = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_last_if(a,
+                                      [&](int i) { ++predicate_count; return i == 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 2);
+      assert(*(ret.data()) == 2);
+      assert(predicate_count == 5);
+      assert(projection_count == 5);
+    }
+  }
+
+  {
+    // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparable a[] = {NonConstComparable{}};
+      auto ret = std::ranges::find_last_if(a, a + 1, [](auto&& e) { return e == NonConstComparable{}; });
+      assert(ret.data() == a);
+    }
+    {
+      NonConstComparable a[] = {NonConstComparable{}};
+      auto ret = std::ranges::find_last_if(a, [](auto&& e) { return e == NonConstComparable{}; });
+      assert(ret.data() == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find_last_if(a.begin(), a.end(), [](int) { return true; });
+      assert(ret.data() == a.begin());
+    }
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find_last_if(a, [](int) { return true; });
+      assert(ret.data() == a.begin());
+    }
+  }
+
+  {
+  // check that the implicit conversion to bool works
+    {
+      int a[]  = {1, 2, 3, 3, 4};
+      auto ret = std::ranges::find_last_if(a, a + 4, [](const int& i) { return BooleanTestable{i == 3}; });
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[]  = {1, 2, 3, 3, 4};
+      auto ret = std::ranges::find_last_if(a, [](const int& b) { return BooleanTestable{b == 3}; });
+      assert(ret.data() == a + 3);
+    }
+  }
+
+ return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
 No newline at end of file

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_last_if_not.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//  constexpr subrange<I> ranges::find_last_if_not(I first, S last, Pred pred, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//  constexpr borrowed_subrange_t<R>
+// ranges::find_last_if_not(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "boolean_testable.h"
+#include "test_iterators.h"
+
+struct Predicate {
+  bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindIfNotIt = requires(It it, Sent sent) { std::ranges::find_last_if_not(it, sent, Predicate{}); };
+static_assert(HasFindIfNotIt<int*>);
+static_assert(!HasFindIfNotIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIfNotIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIfNotIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIfNotIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIfNotIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIfNotIt<int*, int>);
+static_assert(!HasFindIfNotIt<int, int*>);
+
+template <class Pred>
+concept HasFindIfNotPred = requires(int* it, Pred pred) {std::ranges::find_last_if_not(it, it, pred); };
+
+static_assert(!HasFindIfNotPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindIfNotPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindIfNotR = requires(R r) { std::ranges::find_last_if_not(r, Predicate{}); };
+static_assert(HasFindIfNotR<std::array<int, 0>>);
+static_assert(!HasFindIfNotR<int>);
+static_assert(!HasFindIfNotR<InputRangeNotDerivedFrom>);
+static_assert(!HasFindIfNotR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasFindIfNotR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasFindIfNotR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasFindIfNotR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  {
+    int a[] = {1, 2, 3, 4, 5};
+    auto ret = std::ranges::find_last_if_not(It(a), Sent(It(a + 5)), [c = 0](int) mutable { return c++ <= 2; });
+    assert(base(ret.begin()) == a + 4);
+    assert(*ret.begin() == 5);
+  }
+  {
+    int a[] = {1, 2, 3, 4, 5};
+    auto range = std::ranges::subrange(It(a), Sent(It(a + 5)));
+    auto ret = std::ranges::find_last_if_not(range, [c = 0](int) mutable { return c++ <= 2; });
+    assert(base(ret.begin()) == a + 4);
+    assert(*ret.begin() == 5);
+  }
+}
+
+struct NonConstComparableLValue {
+  friend constexpr bool operator==(const NonConstComparableLValue&, const NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, const NonConstComparableLValue&) { return true; }
+};
+
+constexpr bool test() {
+  test_iterators<int*>();
+  test_iterators<const int*>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+
+  { // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::find_last_if_not(a, a + 5, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::find_last_if_not(a, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; });
+      assert(ret.data() == a + 3);
+    }
+  }
+
+  {
+    // check that the first element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last_if_not(a, [](int i){ return i != 0; }, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_last_if_not(a, a + 3, [](int i) { return i != 0; }, &S::comp);
+      assert(ret.data() == a + 2);
+      assert(ret.data()->comp == 0);
+      assert(ret.data()->other == 1);
+    }
+  }
+
+  {
+    // check that end iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_last_if_not(a, a + 3, [](int) { return false; });
+      assert(ret.data() == a + 2);
+    }
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_last_if_not(a, [](int){ return false; });
+      assert(ret.data() == a + 2);
+    }
+  }
+
+  { // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find_last_if_not(std::array{1, 2}, [](int){ return true; });
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    int a[] = {1, 2, 3, 4};
+    auto ret = std::ranges::find_last_if_not(std::views::all(a), [](int){ return false; });
+    assert(ret.data() == a + 3);
+    assert(*ret.data() == 4);
+  }
+
+  { // check that std::invoke is used
+    struct S { int i; };
+    S a[] = { S{1}, S{3}, S{2} };
+    auto ret = std::ranges::find_last_if_not(a, [](int) { return true; }, &S::i);
+    assert(ret.data() == a + 3);
+  }
+
+  { // count projection and predicate invocation count
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_last_if_not(a, a + 4,
+                                      [&](int i) { ++predicate_count; return i != 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 1);
+      assert(*ret.data() == 2);
+      assert(predicate_count == 4);
+      assert(projection_count == 4);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_last_if_not(a,
+                                      [&](int i) { ++predicate_count; return i != 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret.data() == a + 1);
+      assert(*ret.data() == 2);
+      assert(predicate_count == 4);
+      assert(projection_count == 4);
+    }
+  }
+
+  { // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_last_if_not(a, a + 1, [](auto&& e) { return e != NonConstComparableLValue{}; });
+      assert(ret.data() == a);
+    }
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_last_if_not(a, [](auto&& e) { return e != NonConstComparableLValue{}; });
+      assert(ret.data() == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int ,0> a = {};
+      auto ret = std::ranges::find_last_if_not(a.begin(), a.end(), [](int) { return true; });
+      assert(ret.data() == a.begin());
+    }
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find_last_if_not(a, [](int) { return true; });
+      assert(ret.data() == a.begin());
+    }
+  }
+
+  {
+    // check that the implicit conversion to bool works
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last_if_not(a, a + 4, [](const int& i) { return BooleanTestable{i != 3}; });
+      assert(ret.data() == a + 2);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_last_if_not(a, [](const int& b) { return BooleanTestable{b != 3}; });
+      assert(ret.data() == a + 2);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp

 
 // <algorithm>
 
 // Test the feature test macros defined by <algorithm>
 
 /*  Constant                                 Value
     __cpp_lib_clamp                          201603L [C++17]
     __cpp_lib_constexpr_algorithms           201806L [C++20]
+    __cpp_lib_find_last                      202207L [C++2b]
     __cpp_lib_parallel_algorithm             201603L [C++17]
     __cpp_lib_ranges                         202106L [C++20]
     __cpp_lib_ranges_starts_ends_with        202106L [C++2b]
     __cpp_lib_robust_nonmodifying_seq_ops    201304L [C++14]
     __cpp_lib_sample                         201603L [C++17]
     __cpp_lib_shift                          201806L [C++20]
 */
 
 #include <algorithm>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_clamp
 #   error "__cpp_lib_clamp should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should not be defined before c++20"
 # endif
 

 # ifdef __cpp_lib_clamp
 #   error "__cpp_lib_clamp should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should not be defined before c++20"
 # endif
 

 # if __cpp_lib_clamp != 201603L
 #   error "__cpp_lib_clamp should have the value 201603L in c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should be defined in c++17"
 #   endif
 #   if __cpp_lib_parallel_algorithm != 201603L
 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++17"
 #   endif
 # else // _LIBCPP_VERSION

 
 # ifndef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_algorithms != 201806L
 #   error "__cpp_lib_constexpr_algorithms should have the value 201806L in c++20"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should be defined in c++20"
 #   endif
 #   if __cpp_lib_parallel_algorithm != 201603L
 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++20"
 #   endif
 # else // _LIBCPP_VERSION

 
 # ifndef __cpp_lib_constexpr_algorithms
 #   error "__cpp_lib_constexpr_algorithms should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_algorithms != 201806L
 #   error "__cpp_lib_constexpr_algorithms should have the value 201806L in c++2b"
 # endif
 
+# ifndef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should be defined in c++2b"
+# endif
+# if __cpp_lib_find_last != 202207L
+#   error "__cpp_lib_find_last should have the value 202207L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should be defined in c++2b"
 #   endif
 #   if __cpp_lib_parallel_algorithm != 201603L
 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++20]
     __cpp_lib_erase_if                             202002L [C++20]
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]
                                                    201902L [C++20]
     __cpp_lib_expected                             202202L [C++2b]
     __cpp_lib_filesystem                           201703L [C++17]
+    __cpp_lib_find_last                            202207L [C++2b]
     __cpp_lib_format                               202106L [C++20]
     __cpp_lib_forward_like                         202207L [C++2b]
     __cpp_lib_gcd_lcm                              201606L [C++17]
     __cpp_lib_generic_associative_lookup           201304L [C++14]
     __cpp_lib_generic_unordered_lookup             201811L [C++20]
     __cpp_lib_hardware_interference_size           201703L [C++17]
     __cpp_lib_has_unique_object_representations    201606L [C++17]
     __cpp_lib_hypot                                201603L [C++17]

 # ifdef __cpp_lib_expected
 #   error "__cpp_lib_expected should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_filesystem
 #   error "__cpp_lib_filesystem should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_format
 #   error "__cpp_lib_format should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_forward_like
 #   error "__cpp_lib_forward_like should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_expected
 #   error "__cpp_lib_expected should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_filesystem
 #   error "__cpp_lib_filesystem should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_format
 #   error "__cpp_lib_format should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_forward_like
 #   error "__cpp_lib_forward_like should not be defined before c++2b"
 # endif
 

 #     error "__cpp_lib_filesystem should have the value 201703L in c++17"
 #   endif
 # else
 #   ifdef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)' is not met!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_format
 #   error "__cpp_lib_format should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_forward_like
 #   error "__cpp_lib_forward_like should not be defined before c++2b"
 # endif
 

 #     error "__cpp_lib_filesystem should have the value 201703L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)' is not met!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++20"
 #   endif
 #   if __cpp_lib_format != 202106L
 #     error "__cpp_lib_format should have the value 202106L in c++20"
 #   endif
 # else // _LIBCPP_VERSION

 #     error "__cpp_lib_filesystem should have the value 201703L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should not be defined when the requirement '!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)' is not met!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_find_last
+#   error "__cpp_lib_find_last should be defined in c++2b"
+# endif
+# if __cpp_lib_find_last != 202207L
+#   error "__cpp_lib_find_last should have the value 202207L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_format
 #     error "__cpp_lib_format should be defined in c++2b"
 #   endif
 #   if __cpp_lib_format != 202106L
 #     error "__cpp_lib_format should have the value 202106L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "headers": ["expected"],
   }, {
     "name": "__cpp_lib_filesystem",
     "values": { "c++17": 201703 },
     "headers": ["filesystem"],
     "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
     "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)"
   }, {
+    "name": "__cpp_lib_find_last",
+    "values": { "c++2b": 202207 },
+    "headers": ["algorithm"],
+   }, {
     "name": "__cpp_lib_format",
     "values": {
         # "c++20": 201907 Not implemented P1361R2 Integration of chrono with text formatting
         # "c++20": 202106 Fully implemented
         # "c++20": 202110 Not implemented P2372R3 Fixing locale handling in chrono formatters
         "c++20": 202106,
         # "c++23": 202207, Not implemented P2419R2 Clarify handling of encodings in localized formatting of chrono types
         },

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "__algorithm/ranges_equal_range.h",
       "__algorithm/ranges_fill.h",
       "__algorithm/ranges_fill_n.h",
       "__algorithm/ranges_find.h",
       "__algorithm/ranges_find_end.h",
       "__algorithm/ranges_find_first_of.h",
       "__algorithm/ranges_find_if.h",
       "__algorithm/ranges_find_if_not.h",
+      "__algorithm/ranges_find_last.h",
+      "__algorithm/ranges_find_last_if.h",
+      "__algorithm/ranges_find_last_if_not.h",
       "__algorithm/ranges_for_each.h",
       "__algorithm/ranges_for_each_n.h",
       "__algorithm/ranges_generate.h",
       "__algorithm/ranges_generate_n.h",
       "__algorithm/ranges_includes.h",
       "__algorithm/ranges_inplace_merge.h",
       "__algorithm/ranges_is_heap.h",
       "__algorithm/ranges_is_heap_until.h",