Fix build failure with GCC 11 in C++20 mode

[Godin]

Summary

See https://wg21.link/cwg2237

[shafik]

LGTM but I want to give a chance for others to chime in.

[Godin]

Thank you for the review @shafik !

As a note: this change is similar to the https://reviews.llvm.org/rG95d0d8e9e9d10da3cfa503fbba405e740aea3cc1 by @rsmith

[dexonsmith]

LGTM too.

clang/lib/AST/ASTImporter.cpp

8412–8415

Might be nice to remove the implied <T>s in the parameters/returns (here and elsewhere) as a follow up; a bit noisy to read those, even if it doesn't cause a build failure (probably separately from this patch).

[Godin]

Can someone please commit this on my behalf since I do not have commit rights?

clang/lib/AST/ASTImporter.cpp

8412–8415

Thank you for the review @dexonsmith !

I will also prefer such cleanup to be done separately.

[Godin]

ping

clang/lib/AST/ASTImporter.cpp

Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
 
   return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
 }
 
 // To use this object, it should be created before the new attribute is created,
 // and destructed after it is created. The construction already performs the
 // import of the data.
 template <typename T> struct AttrArgImporter {
-  AttrArgImporter<T>(const AttrArgImporter<T> &) = delete;
-  AttrArgImporter<T>(AttrArgImporter<T> &&) = default;
+  AttrArgImporter(const AttrArgImporter<T> &) = delete;
+  AttrArgImporter(AttrArgImporter<T> &&) = default;
   AttrArgImporter<T> &operator=(const AttrArgImporter<T> &) = delete;
   AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) = default;
 
   AttrArgImporter(ASTNodeImporter &I, Error &Err, const T &From)
       : To(I.importChecked(Err, From)) {}
 
   const T &value() { return To; }
 
 private:
   T To;
 };
 
 // To use this object, it should be created before the new attribute is created,
 // and destructed after it is created. The construction already performs the
 // import of the data. The array data is accessible in a pointer form, this form
 // is used by the attribute classes. This object should be created once for the
 // array data to be imported (the array size is not imported, just copied).
 template <typename T> struct AttrArgArrayImporter {
-  AttrArgArrayImporter<T>(const AttrArgArrayImporter<T> &) = delete;
-  AttrArgArrayImporter<T>(AttrArgArrayImporter<T> &&) = default;
+  AttrArgArrayImporter(const AttrArgArrayImporter<T> &) = delete;
+  AttrArgArrayImporter(AttrArgArrayImporter<T> &&) = default;
   AttrArgArrayImporter<T> &operator=(const AttrArgArrayImporter<T> &) = delete;
   AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) = default;
 
   AttrArgArrayImporter(ASTNodeImporter &I, Error &Err,
                        const llvm::iterator_range<T *> &From,
                        unsigned ArraySize) {
     if (Err)
       return;

llvm/include/llvm/CodeGen/LiveInterval.h

~LiveInterval() {
       clearSubRanges();
     }
 
     template<typename T>
     class SingleLinkedListIterator {
       T *P;
 
     public:
-      SingleLinkedListIterator<T>(T *P) : P(P) {}
+      SingleLinkedListIterator(T *P) : P(P) {}
 
       SingleLinkedListIterator<T> &operator++() {
         P = P->Next;
         return *this;
       }
       SingleLinkedListIterator<T> operator++(int) {
         SingleLinkedListIterator res = *this;
         ++*this;

llvm/include/llvm/Support/BinaryStreamArray.h

 class FixedStreamArrayIterator
     : public iterator_facade_base<FixedStreamArrayIterator<T>,
                                   std::random_access_iterator_tag, const T> {
 
 public:
   FixedStreamArrayIterator(const FixedStreamArray<T> &Array, uint32_t Index)
       : Array(Array), Index(Index) {}
 
-  FixedStreamArrayIterator<T>(const FixedStreamArrayIterator<T> &Other)
+  FixedStreamArrayIterator(const FixedStreamArrayIterator<T> &Other)
       : Array(Other.Array), Index(Other.Index) {}
   FixedStreamArrayIterator<T> &
   operator=(const FixedStreamArrayIterator<T> &Other) {
     Array = Other.Array;
     Index = Other.Index;
     return *this;
   }
 

llvm/lib/Passes/StandardInstrumentations.cpp

return any_cast<const LazyCallGraph::SCC *>(IR)
         ->begin()
         ->getFunction()
         .getParent();
   return nullptr;
 }
 
 } // namespace
 
-template <typename T> ChangeReporter<T>::~ChangeReporter<T>() {
+template <typename T> ChangeReporter<T>::~ChangeReporter() {
   assert(BeforeStack.empty() && "Problem with Change Printer stack.");
 }
 
 template <typename T>
 bool ChangeReporter<T>::isInterestingFunction(const Function &F) {
   return isFunctionInPrintList(F.getName());
 }