clang-tools-extra/clang-tidy/cppcoreguidelines/VirtualClassDestructorCheck.cpp

   1 //===--- VirtualClassDestructorCheck.cpp - clang-tidy -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "VirtualClassDestructorCheck.h"
  10 #include "../utils/LexerUtils.h"
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/ASTMatchers/ASTMatchFinder.h"
  13 #include "clang/Lex/Lexer.h"
  14 #include <optional>
  15 #include <string>
  16
  17 using namespace clang::ast_matchers;
  18
  19 namespace clang::tidy::cppcoreguidelines {
  20
  21 AST_MATCHER(CXXRecordDecl, hasPublicVirtualOrProtectedNonVirtualDestructor) {
  22   // We need to call Node.getDestructor() instead of matching a
  23   // CXXDestructorDecl. Otherwise, tests will fail for class templates, since
  24   // the primary template (not the specialization) always gets a non-virtual
  25   // CXXDestructorDecl in the AST. https://bugs.llvm.org/show_bug.cgi?id=51912
  26   const CXXDestructorDecl *Destructor = Node.getDestructor();
  27   if (!Destructor)
  28     return false;
  29
  30   return (((Destructor->getAccess() == AccessSpecifier::AS_public) &&
  31            Destructor->isVirtual()) ||
  32           ((Destructor->getAccess() == AccessSpecifier::AS_protected) &&
  33            !Destructor->isVirtual()));
  34 }
  35
  36 void VirtualClassDestructorCheck::registerMatchers(MatchFinder *Finder) {
  37   ast_matchers::internal::Matcher<CXXRecordDecl> InheritsVirtualMethod =
  38       hasAnyBase(hasType(cxxRecordDecl(has(cxxMethodDecl(isVirtual())))));
  39
  40   Finder->addMatcher(
  41       cxxRecordDecl(
  42           anyOf(has(cxxMethodDecl(isVirtual())), InheritsVirtualMethod),
  43           unless(isFinal()),
  44           unless(hasPublicVirtualOrProtectedNonVirtualDestructor()))
  45           .bind("ProblematicClassOrStruct"),
  46       this);
  47 }
  48
  49 static std::optional<CharSourceRange>
  50 getVirtualKeywordRange(const CXXDestructorDecl &Destructor,
  51                        const SourceManager &SM, const LangOptions &LangOpts) {
  52   if (Destructor.getLocation().isMacroID())
  53     return std::nullopt;
  54
  55   SourceLocation VirtualBeginLoc = Destructor.getBeginLoc();
  56   SourceLocation VirtualBeginSpellingLoc =
  57       SM.getSpellingLoc(Destructor.getBeginLoc());
  58   SourceLocation VirtualEndLoc = VirtualBeginSpellingLoc.getLocWithOffset(
  59       Lexer::MeasureTokenLength(VirtualBeginSpellingLoc, SM, LangOpts));
  60
  61   /// Range ends with \c StartOfNextToken so that any whitespace after \c
  62   /// virtual is included.
  63   std::optional<Token> NextToken =
  64       Lexer::findNextToken(VirtualEndLoc, SM, LangOpts);
  65   if (!NextToken)
  66     return std::nullopt;
  67   SourceLocation StartOfNextToken = NextToken->getLocation();
  68
  69   return CharSourceRange::getCharRange(VirtualBeginLoc, StartOfNextToken);
  70 }
  71
  72 static const AccessSpecDecl *
  73 getPublicASDecl(const CXXRecordDecl &StructOrClass) {
  74   for (DeclContext::specific_decl_iterator<AccessSpecDecl>
  75            AS{StructOrClass.decls_begin()},
  76        ASEnd{StructOrClass.decls_end()};
  77        AS != ASEnd; ++AS) {
  78     AccessSpecDecl *ASDecl = *AS;
  79     if (ASDecl->getAccess() == AccessSpecifier::AS_public)
  80       return ASDecl;
  81   }
  82
  83   return nullptr;
  84 }
  85
  86 static FixItHint
  87 generateUserDeclaredDestructor(const CXXRecordDecl &StructOrClass,
  88                                const SourceManager &SourceManager) {
  89   std::string DestructorString;
  90   SourceLocation Loc;
  91   bool AppendLineBreak = false;
  92
  93   const AccessSpecDecl *AccessSpecDecl = getPublicASDecl(StructOrClass);
  94
  95   if (!AccessSpecDecl) {
  96     if (StructOrClass.isClass()) {
  97       Loc = StructOrClass.getEndLoc();
  98       DestructorString = "public:";
  99       AppendLineBreak = true;
 100     } else {
 101       Loc = StructOrClass.getBraceRange().getBegin().getLocWithOffset(1);
 102     }
 103   } else {
 104     Loc = AccessSpecDecl->getEndLoc().getLocWithOffset(1);
 105   }
 106
 107   DestructorString = (llvm::Twine(DestructorString) + "\nvirtual ~" +
 108                       StructOrClass.getName().str() + "() = default;" +
 109                       (AppendLineBreak ? "\n" : ""))
 110                          .str();
 111
 112   return FixItHint::CreateInsertion(Loc, DestructorString);
 113 }
 114
 115 static std::string getSourceText(const CXXDestructorDecl &Destructor) {
 116   std::string SourceText;
 117   llvm::raw_string_ostream DestructorStream(SourceText);
 118   Destructor.print(DestructorStream);
 119   return SourceText;
 120 }
 121
 122 static std::string eraseKeyword(std::string &DestructorString,
 123                                 const std::string &Keyword) {
 124   size_t KeywordIndex = DestructorString.find(Keyword);
 125   if (KeywordIndex != std::string::npos)
 126     DestructorString.erase(KeywordIndex, Keyword.length());
 127   return DestructorString;
 128 }
 129
 130 static FixItHint changePrivateDestructorVisibilityTo(
 131     const std::string &Visibility, const CXXDestructorDecl &Destructor,
 132     const SourceManager &SM, const LangOptions &LangOpts) {
 133   std::string DestructorString =
 134       (llvm::Twine() + Visibility + ":\n" +
 135        (Visibility == "public" && !Destructor.isVirtual() ? "virtual " : ""))
 136           .str();
 137
 138   std::string OriginalDestructor = getSourceText(Destructor);
 139   if (Visibility == "protected" && Destructor.isVirtualAsWritten())
 140     OriginalDestructor = eraseKeyword(OriginalDestructor, "virtual ");
 141
 142   DestructorString =
 143       (llvm::Twine(DestructorString) + OriginalDestructor +
 144        (Destructor.isExplicitlyDefaulted() ? ";\n" : "") + "private:")
 145           .str();
 146
 147   /// Semicolons ending an explicitly defaulted destructor have to be deleted.
 148   /// Otherwise, the left-over semicolon trails the \c private: access
 149   /// specifier.
 150   SourceLocation EndLocation;
 151   if (Destructor.isExplicitlyDefaulted())
 152     EndLocation =
 153         utils::lexer::findNextTerminator(Destructor.getEndLoc(), SM, LangOpts)
 154             .getLocWithOffset(1);
 155   else
 156     EndLocation = Destructor.getEndLoc().getLocWithOffset(1);
 157
 158   auto OriginalDestructorRange =
 159       CharSourceRange::getCharRange(Destructor.getBeginLoc(), EndLocation);
 160   return FixItHint::CreateReplacement(OriginalDestructorRange,
 161                                       DestructorString);
 162 }
 163
 164 void VirtualClassDestructorCheck::check(
 165     const MatchFinder::MatchResult &Result) {
 166
 167   const auto *MatchedClassOrStruct =
 168       Result.Nodes.getNodeAs<CXXRecordDecl>("ProblematicClassOrStruct");
 169
 170   const CXXDestructorDecl *Destructor = MatchedClassOrStruct->getDestructor();
 171   if (!Destructor)
 172     return;
 173
 174   if (Destructor->getAccess() == AccessSpecifier::AS_private) {
 175     diag(MatchedClassOrStruct->getLocation(),
 176          "destructor of %0 is private and prevents using the type")
 177         << MatchedClassOrStruct;
 178     diag(MatchedClassOrStruct->getLocation(),
 179          /*Description=*/"make it public and virtual", DiagnosticIDs::Note)
 180         << changePrivateDestructorVisibilityTo(
 181                "public", *Destructor, *Result.SourceManager, getLangOpts());
 182     diag(MatchedClassOrStruct->getLocation(),
 183          /*Description=*/"make it protected", DiagnosticIDs::Note)
 184         << changePrivateDestructorVisibilityTo(
 185                "protected", *Destructor, *Result.SourceManager, getLangOpts());
 186
 187     return;
 188   }
 189
 190   // Implicit destructors are public and non-virtual for classes and structs.
 191   bool ProtectedAndVirtual = false;
 192   FixItHint Fix;
 193
 194   if (MatchedClassOrStruct->hasUserDeclaredDestructor()) {
 195     if (Destructor->getAccess() == AccessSpecifier::AS_public) {
 196       Fix = FixItHint::CreateInsertion(Destructor->getLocation(), "virtual ");
 197     } else if (Destructor->getAccess() == AccessSpecifier::AS_protected) {
 198       ProtectedAndVirtual = true;
 199       if (const auto MaybeRange =
 200               getVirtualKeywordRange(*Destructor, *Result.SourceManager,
 201                                      Result.Context->getLangOpts()))
 202         Fix = FixItHint::CreateRemoval(*MaybeRange);
 203     }
 204   } else {
 205     Fix = generateUserDeclaredDestructor(*MatchedClassOrStruct,
 206                                          *Result.SourceManager);
 207   }
 208
 209   diag(MatchedClassOrStruct->getLocation(),
 210        "destructor of %0 is %select{public and non-virtual|protected and "
 211        "virtual}1")
 212       << MatchedClassOrStruct << ProtectedAndVirtual;
 213   diag(MatchedClassOrStruct->getLocation(),
 214        "make it %select{public and virtual|protected and non-virtual}0",
 215        DiagnosticIDs::Note)
 216       << ProtectedAndVirtual << Fix;
 217 }
 218
 219 } // namespace clang::tidy::cppcoreguidelines