Modify the comment of ErrorHandlerTraits in llvm/Support/Error.h

[yihanaa]

Summary

Modify the comment of ErrorHandlerTraits in llvm/Support/Error.h

[yihanaa]

Modify the comment of ErrorHandlerTraits in llvm/Support/Error.h

[yihanaa]

Modify the comment of ErrorHandlerTraits in llvm/Support/Error.h

[MaskRay]

The fix is correct but do you think the code self explains?

[yihanaa]

In D92002#2412962, @MaskRay wrote:

The fix is correct but do you think the code self explains?

Thank you for your reply, I'm a newble, and I happened to find this problem while reading the code, maybe you can fix it later.😉

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
 //
 //===----------------------------------------------------------------------===//
 //

 
 /// Helper for testing applicability of, and applying, handlers for
 /// ErrorInfo types.
 template <typename HandlerT>
 class ErrorHandlerTraits
     : public ErrorHandlerTraits<decltype(
           &std::remove_reference<HandlerT>::type::operator())> {};
 
-// Specialization functions of the form 'Error (const ErrT&)'.
+// Specialization functions of the form 'Error (ErrT&)'.
 template <typename ErrT> class ErrorHandlerTraits<Error (&)(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");
     return H(static_cast<ErrT &>(*E));
   }
 };
 
-// Specialization functions of the form 'void (const ErrT&)'.
+// Specialization functions of the form 'void (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) {
public:
   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));
     return Error::success();
   }
 };
 
-// Specialization for member functions of the form 'RetT (const ErrT&)'.
+// Specialization for member functions of the form 'RetT (ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
 class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
-// Specialization for member functions of the form 'RetT (const ErrT&) const'.
+// Specialization for member functions of the form 'RetT (ErrT&) const'.
 template <typename C, typename RetT, typename ErrT>
 class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
 
 // Specialization for member functions of the form 'RetT (const ErrT&)'.
 template <typename C, typename RetT, typename ErrT>
 class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
     : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};