[NFC] [llvm] Forward forwarding references

[ccotter]

Summary

Update function bodies to forward forwarding references.
I spotted this while authoring a clang-tidy tool for CppCoreGuideline F.19

[ccotter]

• Add more

[ccotter]

• Fix BitVector

llvm/include/llvm/ADT/BitVector.h

 //===- llvm/ADT/BitVector.h - Bit vectors -----------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
bool test(const BitVector &RHS) const {
     for (; i != ThisWords ; ++i)
       if (Bits[i] != 0)
         return true;
 
     return false;
   }
 
   template <class F, class... ArgTys>
-  static BitVector &apply(F &&f, BitVector &Out, BitVector const &Arg,
+  static BitVector &apply(const F &f, BitVector &Out, BitVector const &Arg,
                           ArgTys const &...Args) {
     assert(llvm::all_of(
                std::initializer_list<unsigned>{Args.size()...},
                [&Arg](auto const &BV) { return Arg.size() == BV; }) &&
            "consistent sizes");
     Out.resize(Arg.size());
     for (size_type I = 0, E = Arg.Bits.size(); I != E; ++I)
       Out.Bits[I] = f(Arg.Bits[I], Args.Bits[I]...);

llvm/include/llvm/Support/Error.h

 //===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
-    return H(static_cast<ErrT &>(*E));
+    return std::forward<HandlerT>(H)(static_cast<ErrT &>(*E));
   }
 };
 
 // Specialization functions of the form 'void (const ErrT&)'.
 template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
-    H(static_cast<ErrT &>(*E));
+    std::forward<HandlerT>(H)(static_cast<ErrT &>(*E));
     return Error::success();
   }
 };
 
 /// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
 class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
-    return H(std::move(SubE));
+    return std::forward<HandlerT>(H)(std::move(SubE));
   }
 };
 
 /// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
 template <typename ErrT>
 class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
 public:
   static bool appliesTo(const ErrorInfoBase &E) {
     return E.template isA<ErrT>();
   }
 
   template <typename HandlerT>
   static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
     assert(appliesTo(*E) && "Applying incorrect handler");
     std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
-    H(std::move(SubE));
+    std::forward<HandlerT>(H)(std::move(SubE));
     return Error::success();
   }
 };
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
 class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};

llvm/include/llvm/Support/HashBuilder.h

 //===- llvm/Support/HashBuilder.h - Convenient hashing interface-*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
class HashBuilderImpl : public HashBuilderBase<HasherT> {
   static_assert(Endianness != support::endianness::native,
                 "HashBuilder should canonicalize endianness");
 
 public:
   explicit HashBuilderImpl(HasherT &Hasher)
       : HashBuilderBase<HasherT>(Hasher) {}
   template <typename... ArgTypes>
   explicit HashBuilderImpl(ArgTypes &&...Args)
-      : HashBuilderBase<HasherT>(Args...) {}
+      : HashBuilderBase<HasherT>(std::forward<ArgTypes>(Args)...) {}
 
   /// Implement hashing for hashable data types, e.g. integral or enum values.
   template <typename T>
   std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value,
                    HashBuilderImpl &>
   add(T Value) {
     return adjustForEndiannessAndAdd(Value);
   }