diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -214,16 +214,14 @@
 
 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;
@@ -231,25 +229,23 @@
 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.
@@ -489,11 +485,8 @@
 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"
@@ -575,8 +568,8 @@
 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
diff --git a/llvm/include/llvm/ADT/iterator.h b/llvm/include/llvm/ADT/iterator.h
--- a/llvm/include/llvm/ADT/iterator.h
+++ b/llvm/include/llvm/ADT/iterator.h
@@ -291,7 +291,7 @@
   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; }
 };
@@ -301,8 +301,8 @@
 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,
@@ -329,8 +329,8 @@
 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,