clang-tools-extra/clang-tidy/misc/NewDeleteOverloadsCheck.cpp

   1 //===--- NewDeleteOverloadsCheck.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 "NewDeleteOverloadsCheck.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/ASTMatchers/ASTMatchFinder.h"
  12
  13 using namespace clang::ast_matchers;
  14
  15 namespace clang::tidy::misc {
  16
  17 namespace {
  18
  19 AST_MATCHER(FunctionDecl, isPlacementOverload) {
  20   bool New;
  21   switch (Node.getOverloadedOperator()) {
  22   default:
  23     return false;
  24   case OO_New:
  25   case OO_Array_New:
  26     New = true;
  27     break;
  28   case OO_Delete:
  29   case OO_Array_Delete:
  30     New = false;
  31     break;
  32   }
  33
  34   // Variadic functions are always placement functions.
  35   if (Node.isVariadic())
  36     return true;
  37
  38   // Placement new is easy: it always has more than one parameter (the first
  39   // parameter is always the size). If it's an overload of delete or delete[]
  40   // that has only one parameter, it's never a placement delete.
  41   if (New)
  42     return Node.getNumParams() > 1;
  43   if (Node.getNumParams() == 1)
  44     return false;
  45
  46   // Placement delete is a little more challenging. They always have more than
  47   // one parameter with the first parameter being a pointer. However, the
  48   // second parameter can be a size_t for sized deallocation, and that is never
  49   // a placement delete operator.
  50   if (Node.getNumParams() <= 1 || Node.getNumParams() > 2)
  51     return true;
  52
  53   const auto *FPT = Node.getType()->castAs<FunctionProtoType>();
  54   ASTContext &Ctx = Node.getASTContext();
  55   if (Ctx.getLangOpts().SizedDeallocation &&
  56       Ctx.hasSameType(FPT->getParamType(1), Ctx.getSizeType()))
  57     return false;
  58
  59   return true;
  60 }
  61
  62 OverloadedOperatorKind getCorrespondingOverload(const FunctionDecl *FD) {
  63   switch (FD->getOverloadedOperator()) {
  64   default:
  65     break;
  66   case OO_New:
  67     return OO_Delete;
  68   case OO_Delete:
  69     return OO_New;
  70   case OO_Array_New:
  71     return OO_Array_Delete;
  72   case OO_Array_Delete:
  73     return OO_Array_New;
  74   }
  75   llvm_unreachable("Not an overloaded allocation operator");
  76 }
  77
  78 const char *getOperatorName(OverloadedOperatorKind K) {
  79   switch (K) {
  80   default:
  81     break;
  82   case OO_New:
  83     return "operator new";
  84   case OO_Delete:
  85     return "operator delete";
  86   case OO_Array_New:
  87     return "operator new[]";
  88   case OO_Array_Delete:
  89     return "operator delete[]";
  90   }
  91   llvm_unreachable("Not an overloaded allocation operator");
  92 }
  93
  94 bool areCorrespondingOverloads(const FunctionDecl *LHS,
  95                                const FunctionDecl *RHS) {
  96   return RHS->getOverloadedOperator() == getCorrespondingOverload(LHS);
  97 }
  98
  99 bool hasCorrespondingOverloadInBaseClass(const CXXMethodDecl *MD,
 100                                          const CXXRecordDecl *RD = nullptr) {
 101   if (RD) {
 102     // Check the methods in the given class and accessible to derived classes.
 103     for (const auto *BMD : RD->methods())
 104       if (BMD->isOverloadedOperator() && BMD->getAccess() != AS_private &&
 105           areCorrespondingOverloads(MD, BMD))
 106         return true;
 107   } else {
 108     // Get the parent class of the method; we do not need to care about checking
 109     // the methods in this class as the caller has already done that by looking
 110     // at the declaration contexts.
 111     RD = MD->getParent();
 112   }
 113
 114   for (const auto &BS : RD->bases()) {
 115     // We can't say much about a dependent base class, but to avoid false
 116     // positives assume it can have a corresponding overload.
 117     if (BS.getType()->isDependentType())
 118       return true;
 119     if (const auto *BaseRD = BS.getType()->getAsCXXRecordDecl())
 120       if (hasCorrespondingOverloadInBaseClass(MD, BaseRD))
 121         return true;
 122   }
 123
 124   return false;
 125 }
 126
 127 } // anonymous namespace
 128
 129 void NewDeleteOverloadsCheck::registerMatchers(MatchFinder *Finder) {
 130   // Match all operator new and operator delete overloads (including the array
 131   // forms). Do not match implicit operators, placement operators, or
 132   // deleted/private operators.
 133   //
 134   // Technically, trivially-defined operator delete seems like a reasonable
 135   // thing to also skip. e.g., void operator delete(void *) {}
 136   // However, I think it's more reasonable to warn in this case as the user
 137   // should really be writing that as a deleted function.
 138   Finder->addMatcher(
 139       functionDecl(unless(anyOf(isImplicit(), isPlacementOverload(),
 140                                 isDeleted(), cxxMethodDecl(isPrivate()))),
 141                    anyOf(hasOverloadedOperatorName("new"),
 142                          hasOverloadedOperatorName("new[]"),
 143                          hasOverloadedOperatorName("delete"),
 144                          hasOverloadedOperatorName("delete[]")))
 145           .bind("func"),
 146       this);
 147 }
 148
 149 void NewDeleteOverloadsCheck::check(const MatchFinder::MatchResult &Result) {
 150   // Add any matches we locate to the list of things to be checked at the
 151   // end of the translation unit.
 152   const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func");
 153   const CXXRecordDecl *RD = nullptr;
 154   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
 155     RD = MD->getParent();
 156   Overloads[RD].push_back(FD);
 157 }
 158
 159 void NewDeleteOverloadsCheck::onEndOfTranslationUnit() {
 160   // Walk over the list of declarations we've found to see if there is a
 161   // corresponding overload at the same declaration context or within a base
 162   // class. If there is not, add the element to the list of declarations to
 163   // diagnose.
 164   SmallVector<const FunctionDecl *, 4> Diagnose;
 165   for (const auto &RP : Overloads) {
 166     // We don't care about the CXXRecordDecl key in the map; we use it as a way
 167     // to shard the overloads by declaration context to reduce the algorithmic
 168     // complexity when searching for corresponding free store functions.
 169     for (const auto *Overload : RP.second) {
 170       const auto *Match =
 171           std::find_if(RP.second.begin(), RP.second.end(),
 172                        [&Overload](const FunctionDecl *FD) {
 173                          if (FD == Overload)
 174                            return false;
 175                          // If the declaration contexts don't match, we don't
 176                          // need to check any further.
 177                          if (FD->getDeclContext() != Overload->getDeclContext())
 178                            return false;
 179
 180                          // Since the declaration contexts match, see whether
 181                          // the current element is the corresponding operator.
 182                          if (!areCorrespondingOverloads(Overload, FD))
 183                            return false;
 184
 185                          return true;
 186                        });
 187
 188       if (Match == RP.second.end()) {
 189         // Check to see if there is a corresponding overload in a base class
 190         // context. If there isn't, or if the overload is not a class member
 191         // function, then we should diagnose.
 192         const auto *MD = dyn_cast<CXXMethodDecl>(Overload);
 193         if (!MD || !hasCorrespondingOverloadInBaseClass(MD))
 194           Diagnose.push_back(Overload);
 195       }
 196     }
 197   }
 198
 199   for (const auto *FD : Diagnose)
 200     diag(FD->getLocation(), "declaration of %0 has no matching declaration "
 201                             "of '%1' at the same scope")
 202         << FD << getOperatorName(getCorrespondingOverload(FD));
 203 }
 204
 205 } // namespace clang::tidy::misc