[SemaCXX] Validate destructor is valid for dependent classes

[royjacobson]

Summary

We didn't check that a destructor's name matches the directly enclosing class if the class was dependent.
I enabled the check we already had for non-dependent types, which seems to work. Added appropriate tests.

Fixes GitHub issue #56772

[royjacobson]

Fix the C++20 check

[shafik]

LGTM but let's have Erich take a look.

clang/lib/Sema/SemaDecl.cpp

11499

The FIXME goes back a while, I wonder how long ago we fixed this.

[erichkeane]

Hmm... I'm a little shocked that didn't error before, while we did the 2nd pass through the destructor. A little shocking this made it this far...

The fix looks fine to me, I wish I knew why we had that check there, but I got lost in the subversion history.

Anyway, LGTM with 1 nit.. ALSO needs a release note.

clang/test/SemaCXX/member-class-11.cpp

30

Nit: Need newline at end of file (C++98 rule).

[royjacobson]

Add newline and release notes.

[hubert.reinterpretcast]

This does not work for friend declarations.

template <typename T>
struct A {
  friend T::S::~S();
private:
  static constexpr int secret = 42;
};

struct Q {
  struct S { ~S(); };
};

Q::S::~S() {
  void foo(int);
  foo(A<Q>::secret);
}

clang/docs/ReleaseNotes.rst

 Major New Features
 ------------------
 
 Bug Fixes
 ---------
 - Fixes an accepts-invalid bug in C when using a ``_Noreturn`` function
   specifier on something other than a function declaration. This fixes
   `Issue 56800 <https://github.com/llvm/llvm-project/issues/56800>`_.
+- Fix `#56772 <https://github.com/llvm/llvm-project/issues/56772>`_ - invalid
+  destructor names were incorrectly accepted on template classes.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now correctly diagnose as ill-formed a constant expression where an
   enum without a fixed underlying type is set to a value outside the range of
   the enumeration's values. Fixes
   `Issue 50055: <https://github.com/llvm/llvm-project/issues/50055>`_.
 

clang/lib/Sema/SemaDecl.cpp

if (getLangOpts().CPlusPlus) {
     // C++-specific checks.
     if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
       CheckConstructor(Constructor);
     } else if (CXXDestructorDecl *Destructor =
                 dyn_cast<CXXDestructorDecl>(NewFD)) {
       CXXRecordDecl *Record = Destructor->getParent();
       QualType ClassType = Context.getTypeDeclType(Record);
 
-      // FIXME: Shouldn't we be able to perform this check even when the class
-      // type is dependent? Both gcc and edg can handle that.
-      if (!ClassType->isDependentType()) {
-        DeclarationName Name
-          = Context.DeclarationNames.getCXXDestructorName(
-                                        Context.getCanonicalType(ClassType));
-        if (NewFD->getDeclName() != Name) {
-          Diag(NewFD->getLocation(), diag::err_destructor_name);
-          NewFD->setInvalidDecl();
-          return Redeclaration;
-        }
-      }
+      DeclarationName Name = Context.DeclarationNames.getCXXDestructorName(
     } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(NewFD)) {
       if (auto *TD = Guide->getDescribedFunctionTemplate())
         CheckDeductionGuideTemplate(TD);
 
       // A deduction guide is not on the list of entities that can be
       // explicitly specialized.
       if (Guide->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
         Diag(Guide->getBeginLoc(), diag::err_deduction_guide_specialized)

clang/test/SemaCXX/member-class-11.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
 
 struct rdar9677163 {
   struct Y { ~Y(); };
   struct Z { ~Z(); };
   Y::~Y() { } // expected-error{{non-friend class member '~Y' cannot have a qualified name}}
   ~Z(); // expected-error{{expected the class name after '~' to name the enclosing class}}
 };
+
+namespace GH56772 {
+
+template<class T>
+struct A {
+  ~A<T>();
+};
+#if __cplusplus >= 202002L
+// FIXME: This isn't valid in C++20 and later.
+#endif
+
+struct B;
+
+template<class T>
+struct C {
+  ~B(); // expected-error {{expected the class name after '~' to name the enclosing class}}
+};
+
+}