[clang] Warning for non-final classes with final destructors

[logan-5]

Summary

Marking a class' destructor final prevents the class from being inherited from. However, it is a subtle and awkward way to express that at best, and unintended at worst. It may also generate worse code (in other compilers) than marking the class itself final. For these reasons, this revision adds a warning for nonfinal classes with final destructors, with a note to suggest marking the class final to silence the warning.

See https://reviews.llvm.org/D66621 for more background.

Patch by logan-5 (Logan Smith)

[xbolva00]

Looks fine

[• Quuxplusone]

clang/include/clang/Basic/DiagnosticSemaKinds.td

2204 ↗

(On Diff #217032)

Is there any good reason to spell it dtor in the preceding file but destructor in this one? I think the spelling should be consistent one way or the other. Helps with greppability/maintainability.

clang/test/SemaCXX/warn-final-dtor-nonfinal-class.cpp

12 ↗

(On Diff #217032)

Should there be a test for the sealed spelling?

[logan-5]

Addressed some feedback.

[hjyamauchi]

LGTM.

[logan-5]

Thanks. I'll need someone with commit access to help me out with this.

[thakis]

This is a cool warning. Could the note have a fixit attached to it, so that it's easy to mass-clean-up the warning automatically?

[xbolva00]

Done.

rL370737/rL370740

cfe/trunk/lib/Sema/SemaDeclCXX.cpp

void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   if (Record->isAbstract()) {
     if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {
       Diag(Record->getLocation(), diag::warn_abstract_final_class)
         << FA->isSpelledAsSealed();
       DiagnoseAbstractType(Record);
     }
   }
 
+  // Warn if the class has a final destructor but is not itself marked final.
+  if (!Record->hasAttr<FinalAttr>()) {
+    if (const CXXDestructorDecl *dtor = Record->getDestructor()) {
+      if (const FinalAttr *FA = dtor->getAttr<FinalAttr>()) {
+        Diag(FA->getLocation(), diag::warn_final_dtor_non_final_class)
+          << FA->isSpelledAsSealed();
+        Diag(Record->getLocation(), diag::note_final_dtor_non_final_class_silence)
+          << Context.getRecordType(Record)
+          << FA->isSpelledAsSealed();
+      }
+    }
+  }
+
   // See if trivial_abi has to be dropped.
   if (Record->hasAttr<TrivialABIAttr>())
     checkIllFormedTrivialABIStruct(*Record);
 
   // Set HasTrivialSpecialMemberForCall if the record has attribute
   // "trivial_abi".
   bool HasTrivialABI = Record->hasAttr<TrivialABIAttr>();
 

cfe/trunk/test/SemaCXX/MicrosoftExtensions.cpp

#if __cplusplus <= 199711L
   // expected-warning@+2 {{'override' keyword is a C++11 extension}}
 #endif
   virtual void OverrideMe() override;
 };
 
 // expected-error@+1 {{base 'SealedType' is marked 'sealed'}}
 struct InheritFromSealed : SealedType {};
 
+class SealedDestructor { // expected-note {{mark 'SealedDestructor' as 'sealed' to silence this warning}}
+    // expected-warning@+1 {{'sealed' keyword is a Microsoft extension}}
+    virtual ~SealedDestructor() sealed; // expected-warning {{class with destructor marked 'sealed' cannot be inherited from}}
+};
+
 void AfterClassBody() {
   // expected-warning@+1 {{attribute 'deprecated' is ignored, place it after "struct" to apply attribute to type declaration}}
   struct D {} __declspec(deprecated);
 
   struct __declspec(align(4)) S {} __declspec(align(8)) s1;
   S s2;
   _Static_assert(__alignof(S) == 4, "");
   _Static_assert(__alignof(s1) == 8, "");

cfe/trunk/test/SemaCXX/warn-final-dtor-non-final-class.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s -Wfinal-dtor-non-final-class
+
+class A {
+    ~A();
+};
+
+class B { // expected-note {{mark 'B' as 'final' to silence this warning}}
+    virtual ~B() final; // expected-warning {{class with destructor marked 'final' cannot be inherited from}}
+};
+
+class C final {
+    virtual ~C() final;
+};