[NFCI] Remove unneeded std::forward

[ychen]

Summary

Found out when discussing D83902

When the return value of forward is rvalue, we get a const iterator out of std::begin/end, which is not expected.

llvm/include/llvm/ADT/STLExtras.h

 //===----------------------------------------------------------------------===//
 //     Extra additions to <iterator>
 //===----------------------------------------------------------------------===//
 
 namespace adl_detail {
 
 using std::begin;
 
-template <typename ContainerTy>
-decltype(auto) adl_begin(ContainerTy &&container) {
-  return begin(std::forward<ContainerTy>(container));
+template <typename ContainerTy> auto adl_begin(ContainerTy &&container) {
+  return begin(container);
 }
 
 using std::end;
 
-template <typename ContainerTy>
-decltype(auto) adl_end(ContainerTy &&container) {
-  return end(std::forward<ContainerTy>(container));
+template <typename ContainerTy> auto adl_end(ContainerTy &&container) {
+  return end(container);
 }
 
 using std::swap;
 
 template <typename T>
 void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
                                                        std::declval<T>()))) {
-  swap(std::forward<T>(lhs), std::forward<T>(rhs));
+  swap(lhs, rhs);
 }
 
 } // end namespace adl_detail
 
-template <typename ContainerTy>
-decltype(auto) adl_begin(ContainerTy &&container) {
-  return adl_detail::adl_begin(std::forward<ContainerTy>(container));
+template <typename ContainerTy> auto adl_begin(ContainerTy &&container) {
+  return adl_detail::adl_begin(container);
 }
 
-template <typename ContainerTy>
-decltype(auto) adl_end(ContainerTy &&container) {
-  return adl_detail::adl_end(std::forward<ContainerTy>(container));
+template <typename ContainerTy> auto adl_end(ContainerTy &&container) {
+  return adl_detail::adl_end(container);
 }
 
 template <typename T>
 void adl_swap(T &&lhs, T &&rhs) noexcept(
     noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
-  adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
+  adl_detail::adl_swap(lhs, rhs);
 }
 
 /// Test whether \p RangeOrContainer is empty. Similar to C++17 std::empty.
 template <typename T>
 constexpr bool empty(const T &RangeOrContainer) {
   return adl_begin(RangeOrContainer) == adl_end(RangeOrContainer);
 }
 

 /// lifetime of that temporary is not kept by the returned range object, and the
 /// temporary is going to be dropped on the floor after the make_iterator_range
 /// full expression that contains this function call.
 template <typename RangeT, typename PredicateT>
 iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
 make_filter_range(RangeT &&Range, PredicateT Pred) {
   using FilterIteratorT =
       filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
-  return make_range(
-      FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
-                      std::end(std::forward<RangeT>(Range)), Pred),
-      FilterIteratorT(std::end(std::forward<RangeT>(Range)),
-                      std::end(std::forward<RangeT>(Range)), Pred));
+  return make_range(FilterIteratorT(std::begin(Range), std::end(Range), Pred),
+                    FilterIteratorT(std::end(Range), std::end(Range), Pred));
 }
 
 /// A pseudo-iterator adaptor that is designed to implement "early increment"
 /// style loops.
 ///
 /// This is *not a normal iterator* and should almost never be used directly. It
 /// is intended primarily to be used with range based for loops and some range
 /// algorithms.

 /// range based for loops and other range algorithms that explicitly guarantee
 /// to dereference exactly once each element, and to increment exactly once each
 /// element.
 template <typename RangeT>
 iterator_range<early_inc_iterator_impl<detail::IterOfRange<RangeT>>>
 make_early_inc_range(RangeT &&Range) {
   using EarlyIncIteratorT =
       early_inc_iterator_impl<detail::IterOfRange<RangeT>>;
-  return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
-                    EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
+  return make_range(EarlyIncIteratorT(std::begin(Range)),
+                    EarlyIncIteratorT(std::end(Range)));
 }
 
 // forward declarations required by zip_shortest/zip_first/zip_longest
 template <typename R, typename UnaryPredicate>
 bool all_of(R &&range, UnaryPredicate P);
 template <typename R, typename UnaryPredicate>
 bool any_of(R &&range, UnaryPredicate P);
 

llvm/include/llvm/ADT/iterator.h

 struct pointee_iterator
     : iterator_adaptor_base<
           pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
           T> {
   pointee_iterator() = default;
   template <typename U>
   pointee_iterator(U &&u)
-      : pointee_iterator::iterator_adaptor_base(std::forward<U &&>(u)) {}
+      : pointee_iterator::iterator_adaptor_base(std::forward<U>(u)) {}
 
   T &operator*() const { return **this->I; }
 };
 
 template <typename RangeT, typename WrappedIteratorT =
                                decltype(std::begin(std::declval<RangeT>()))>
 iterator_range<pointee_iterator<WrappedIteratorT>>
 make_pointee_range(RangeT &&Range) {
   using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
-  return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
-                    PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
+  return make_range(PointeeIteratorT(std::begin(Range)),
+                    PointeeIteratorT(std::end(Range)));
 }
 
 template <typename WrappedIteratorT,
           typename T = decltype(&*std::declval<WrappedIteratorT>())>
 class pointer_iterator
     : public iterator_adaptor_base<
           pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
           typename std::iterator_traits<WrappedIteratorT>::iterator_category,
public:
   const T &operator*() const { return Ptr = &*this->I; }
 };
 
 template <typename RangeT, typename WrappedIteratorT =
                                decltype(std::begin(std::declval<RangeT>()))>
 iterator_range<pointer_iterator<WrappedIteratorT>>
 make_pointer_range(RangeT &&Range) {
   using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
-  return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
-                    PointerIteratorT(std::end(std::forward<RangeT>(Range))));
+  return make_range(PointerIteratorT(std::begin(Range)),
+                    PointerIteratorT(std::end(Range)));
 }
 
 template <typename WrappedIteratorT,
           typename T1 = std::remove_reference_t<decltype(
               **std::declval<WrappedIteratorT>())>,
           typename T2 = std::add_pointer_t<T1>>
 using raw_pointer_iterator =
     pointer_iterator<pointee_iterator<WrappedIteratorT, T1>, T2>;