[Sema] Add a note to point to the inaccessible destructor.

[davide]

Summary

This is an attempt to fix a FIXME from a previous commits, and now the testcase in PR24260 emits the following diagnostics:

std.cpp:8:5: error: call to implicitly-deleted default constructor of 'Y'

Y y;
  ^

std.cpp:5:5: note: default constructor of 'Y' is implicitly deleted because field

    'x' has an inaccessible destructor
X x;
  ^

std.cpp:2:3: note: destructor is declared here

~X();  // private
^

1 error generated.

I didn't put the name of the class in the note, because it seems pretty obvious from SourceLoc. I can change that, if needed.

[rsmith]

lib/Sema/SemaDeclCXX.cpp

5575–5581

This doesn't seem right: you're producing a note for a destructor no matter which special member function was found to be inaccessible. The best thing to do would be to ask the SemaAccess code to produce the relevant note (see DiagnoseAccessPath); that way you can produce a note that says "declared private here" or whatever else is relevant (which can sometimes be that a virtual base destructor is inaccessible due to a private access path, for instance).

[davide]

Thanks for the review. Are you OK with un-statitcize
DiagnoseAccessPath so that SemaDeclCXX can call it -- or do you prefer
to introduce a wrapper?

[rsmith]

I would suggest adding a bool Diagnose parameter to CheckAccess and to Sema::isSpecialMemberAccessibleForDeletion.

include/clang/Basic/DiagnosticSemaKinds.td

   "expected the class name after '~' to name a destructor">;
 def err_ident_in_dtor_not_a_type : Error<
   "identifier %0 in object destruction expression does not name a type">;
 def err_destructor_expr_type_mismatch : Error<
   "destructor type %0 in object destruction expression does not match the "
   "type %1 of the object being destroyed">;
 def note_destructor_type_here : Note<
   "type %0 is declared here">;
+def note_destructor_here : Note<"destructor is declared here">;
 
 def err_destructor_template : Error<
   "destructor cannot be declared as a template">;
 
 // C++ initialization
 def err_init_conversion_failed : Error<
   "cannot initialize %select{a variable|a parameter|return object|an "
   "exception object|a member subobject|an array element|a new value|a value|a "

lib/Sema/SemaDeclCXX.cpp

       S.Diag(Base->getLocStart(),
              diag::note_deleted_special_member_class_subobject)
         << CSM << MD->getParent() << /*IsField*/false
         << Base->getType() << DiagKind << IsDtorCallInCtor;
     }
 
     if (DiagKind == 1)
       S.NoteDeletedFunction(Decl);
-    // FIXME: Explain inaccessibility if DiagKind == 3.
+    if (DiagKind == 3) {
+      // Explain the reasons of inaccessibility.
+      if (Field) {
+        if (CXXRecordDecl *C = Field->getType()->getAsCXXRecordDecl()) {
+          CXXDestructorDecl *D = S.LookupDestructor(C);
+          if (D && !D->isImplicit())
+            S.Diag(D->getLocStart(), diag::note_destructor_here);
+        }
+      }
+    }
   }
 
   return true;
 }
 
 /// Check whether we should delete a special member function due to having a
 /// direct or virtual base class or non-static data member of class type M.
 bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(

test/CXX/special/class.copy/implicit-move.cpp

struct ContainsPrivateMove {
   PrivateMove pm;
 };
 
 struct PrivateDestructor {
   PrivateDestructor() noexcept;
   PrivateDestructor(const PrivateDestructor &) noexcept(false);
   PrivateDestructor(PrivateDestructor &&) noexcept;
 private:
-  ~PrivateDestructor() noexcept;
+  ~PrivateDestructor() noexcept; // expected-note{{destructor is declared here}}
 };
 
 struct InheritsPrivateDestructor : PrivateDestructor {}; // expected-note{{base class 'PrivateDestructor' has an inaccessible destructor}}
 struct ContainsPrivateDestructor {
   PrivateDestructor pd; // expected-note{{field 'pd' has an inaccessible destructor}}
 };
 
 struct NonTrivialCopyOnly {

test/CXX/special/class.copy/p11.0x.copy.cpp

 struct InaccessibleCopyBase : NoAccess {}; // expected-note {{copy constructor of 'InaccessibleCopyBase' is implicitly deleted because base class 'NoAccess' has an inaccessible copy constructor}}
 extern InaccessibleCopyBase ICBa;
 InaccessibleCopyBase ICBb(ICBa); // expected-error {{deleted copy constructor}}
 
 // -- any direct or virtual base class or non-static data member of a type with
 //    a destructor that is deleted or inaccessible
 struct NoAccessDtor {
 private:
-  ~NoAccessDtor();
+  ~NoAccessDtor(); // expected-note {{destructor is declared here}}
   friend struct HasAccessDtor;
 };
 
 struct HasNoAccessDtor {
   NoAccessDtor NAD; // expected-note{{copy constructor of 'HasNoAccessDtor' is implicitly deleted because field 'NAD' has an inaccessible destructor}}
   HasNoAccessDtor();
   ~HasNoAccessDtor();
 };

test/CXX/special/class.copy/p11.0x.move.cpp

 };
 InaccessibleMoveBase::InaccessibleMoveBase(InaccessibleMoveBase&&) = default; // expected-error{{would delete}}
 
 // -- any direct or virtual base class or non-static data member of a type with
 //    a destructor that is deleted or inaccessible
 struct NoAccessDtor {
   NoAccessDtor(NoAccessDtor&&); // expected-note{{copy constructor is implicitly deleted because 'NoAccessDtor' has a user-declared move constructor}}
 private:
-  ~NoAccessDtor();
+  ~NoAccessDtor(); // expected-note{{destructor is declared here}}
   friend struct HasAccessDtor;
 };
 
 struct HasNoAccessDtor {
   NoAccessDtor NAD; // expected-note {{deleted because field 'NAD' has an inaccessible destructor}}
   HasNoAccessDtor(HasNoAccessDtor&&);
 };
 HasNoAccessDtor::HasNoAccessDtor(HasNoAccessDtor&&) = default; // expected-error{{would delete}}

test/CXX/special/class.ctor/p5-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
 
 struct DefaultedDefCtor1 {};
 struct DefaultedDefCtor2 { DefaultedDefCtor2() = default; };
 struct DeletedDefCtor { DeletedDefCtor() = delete; DeletedDefCtor(int); }; // expected-note {{explicitly marked deleted here}}
 class PrivateDefCtor { PrivateDefCtor() = default; public: PrivateDefCtor(int); };
 struct DeletedDtor { ~DeletedDtor() = delete; }; // expected-note 4{{explicitly marked deleted here}}
-class PrivateDtor { ~PrivateDtor() = default; };
+class PrivateDtor { ~PrivateDtor() = default; }; // expected-note 2{{destructor is declared here}}
 class Friend {
   Friend() = default; ~Friend() = default;
   friend struct NotDeleted6c;
   friend struct NotDeleted7i;
   friend struct NotDeleted7j;
   friend struct NotDeleted7k;
 };
 struct UserProvidedDefCtor { UserProvidedDefCtor() {} };

test/CXX/special/class.dtor/p5-0x.cpp

 // RUN: %clang_cc1 -verify -std=c++11 %s
 
 struct NonTrivDtor {
   ~NonTrivDtor();
 };
 struct DeletedDtor {
   ~DeletedDtor() = delete; // expected-note 5 {{deleted here}}
 };
 class InaccessibleDtor {
-  ~InaccessibleDtor() = default;
+  ~InaccessibleDtor() = default; // expected-note 2 {{destructor is declared here}}
 };
 
 // A defaulted destructor for a class X is defined as deleted if:
 
 // -- X is a union-like class that has a variant member with a non-trivial
 // destructor.
 union A1 {
   A1();

test/SemaCXX/defaulted-private-dtor.cpp

 // RUN: %clang_cc1 -verify -std=c++11 %s -fcxx-exceptions
 
 class BadDtor {
   // A private, but nonetheless trivial, destructor.
-  ~BadDtor() = default; // expected-note 9{{here}}
+  ~BadDtor() = default; // expected-note 10{{here}}
   friend class K;
 };
 void f() {
   BadDtor *p = new BadDtor[3]; // expected-error {{private destructor}}
   delete [] p; // expected-error {{private destructor}}
   const BadDtor &dd2 = BadDtor(); // expected-error {{private destructor}}
   BadDtor dd; // expected-error {{private destructor}}
   throw dd; // expected-error {{private destructor}}