clang-tools-extra/clang-tidy/bugprone/UnusedReturnValueCheck.cpp

   1 //===--- UnusedReturnValueCheck.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 "UnusedReturnValueCheck.h"
  10 #include "../utils/Matchers.h"
  11 #include "../utils/OptionsUtils.h"
  12 #include "clang/AST/ASTContext.h"
  13 #include "clang/ASTMatchers/ASTMatchFinder.h"
  14
  15 using namespace clang::ast_matchers;
  16 using namespace clang::ast_matchers::internal;
  17
  18 namespace clang::tidy::bugprone {
  19
  20 namespace {
  21
  22 // Matches functions that are instantiated from a class template member function
  23 // matching InnerMatcher. Functions not instantiated from a class template
  24 // member function are matched directly with InnerMatcher.
  25 AST_MATCHER_P(FunctionDecl, isInstantiatedFrom, Matcher<FunctionDecl>,
  26               InnerMatcher) {
  27   FunctionDecl *InstantiatedFrom = Node.getInstantiatedFromMemberFunction();
  28   return InnerMatcher.matches(InstantiatedFrom ? *InstantiatedFrom : Node,
  29                               Finder, Builder);
  30 }
  31 } // namespace
  32
  33 UnusedReturnValueCheck::UnusedReturnValueCheck(llvm::StringRef Name,
  34                                                ClangTidyContext *Context)
  35     : ClangTidyCheck(Name, Context),
  36       CheckedFunctions(Options.get("CheckedFunctions",
  37                                    "::std::async;"
  38                                    "::std::launder;"
  39                                    "::std::remove;"
  40                                    "::std::remove_if;"
  41                                    "::std::unique;"
  42                                    "::std::unique_ptr::release;"
  43                                    "::std::basic_string::empty;"
  44                                    "::std::vector::empty;"
  45                                    "::std::back_inserter;"
  46                                    "::std::distance;"
  47                                    "::std::find;"
  48                                    "::std::find_if;"
  49                                    "::std::inserter;"
  50                                    "::std::lower_bound;"
  51                                    "::std::make_pair;"
  52                                    "::std::map::count;"
  53                                    "::std::map::find;"
  54                                    "::std::map::lower_bound;"
  55                                    "::std::multimap::equal_range;"
  56                                    "::std::multimap::upper_bound;"
  57                                    "::std::set::count;"
  58                                    "::std::set::find;"
  59                                    "::std::setfill;"
  60                                    "::std::setprecision;"
  61                                    "::std::setw;"
  62                                    "::std::upper_bound;"
  63                                    "::std::vector::at;"
  64                                    // C standard library
  65                                    "::bsearch;"
  66                                    "::ferror;"
  67                                    "::feof;"
  68                                    "::isalnum;"
  69                                    "::isalpha;"
  70                                    "::isblank;"
  71                                    "::iscntrl;"
  72                                    "::isdigit;"
  73                                    "::isgraph;"
  74                                    "::islower;"
  75                                    "::isprint;"
  76                                    "::ispunct;"
  77                                    "::isspace;"
  78                                    "::isupper;"
  79                                    "::iswalnum;"
  80                                    "::iswprint;"
  81                                    "::iswspace;"
  82                                    "::isxdigit;"
  83                                    "::memchr;"
  84                                    "::memcmp;"
  85                                    "::strcmp;"
  86                                    "::strcoll;"
  87                                    "::strncmp;"
  88                                    "::strpbrk;"
  89                                    "::strrchr;"
  90                                    "::strspn;"
  91                                    "::strstr;"
  92                                    "::wcscmp;"
  93                                    // POSIX
  94                                    "::access;"
  95                                    "::bind;"
  96                                    "::connect;"
  97                                    "::difftime;"
  98                                    "::dlsym;"
  99                                    "::fnmatch;"
 100                                    "::getaddrinfo;"
 101                                    "::getopt;"
 102                                    "::htonl;"
 103                                    "::htons;"
 104                                    "::iconv_open;"
 105                                    "::inet_addr;"
 106                                    "::isascii;"
 107                                    "::isatty;"
 108                                    "::mmap;"
 109                                    "::newlocale;"
 110                                    "::openat;"
 111                                    "::pathconf;"
 112                                    "::pthread_equal;"
 113                                    "::pthread_getspecific;"
 114                                    "::pthread_mutex_trylock;"
 115                                    "::readdir;"
 116                                    "::readlink;"
 117                                    "::recvmsg;"
 118                                    "::regexec;"
 119                                    "::scandir;"
 120                                    "::semget;"
 121                                    "::setjmp;"
 122                                    "::shm_open;"
 123                                    "::shmget;"
 124                                    "::sigismember;"
 125                                    "::strcasecmp;"
 126                                    "::strsignal;"
 127                                    "::ttyname")),
 128       CheckedReturnTypes(utils::options::parseStringList(
 129           Options.get("CheckedReturnTypes", "::std::error_code;"
 130                                             "::std::error_condition;"
 131                                             "::std::errc;"
 132                                             "::std::expected;"
 133                                             "::boost::system::error_code"))),
 134       AllowCastToVoid(Options.get("AllowCastToVoid", false)) {}
 135
 136 void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 137   Options.store(Opts, "CheckedFunctions", CheckedFunctions);
 138   Options.store(Opts, "CheckedReturnTypes",
 139                 utils::options::serializeStringList(CheckedReturnTypes));
 140   Options.store(Opts, "AllowCastToVoid", AllowCastToVoid);
 141 }
 142
 143 void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
 144   auto FunVec = utils::options::parseStringList(CheckedFunctions);
 145
 146   auto MatchedDirectCallExpr =
 147       expr(callExpr(callee(functionDecl(
 148                         // Don't match void overloads of checked functions.
 149                         unless(returns(voidType())),
 150                         anyOf(isInstantiatedFrom(hasAnyName(FunVec)),
 151                               returns(hasCanonicalType(hasDeclaration(
 152                                   namedDecl(matchers::matchesAnyListedName(
 153                                       CheckedReturnTypes)))))))))
 154                .bind("match"));
 155
 156   auto CheckCastToVoid =
 157       AllowCastToVoid ? castExpr(unless(hasCastKind(CK_ToVoid))) : castExpr();
 158   auto MatchedCallExpr = expr(
 159       anyOf(MatchedDirectCallExpr,
 160             explicitCastExpr(unless(cxxFunctionalCastExpr()), CheckCastToVoid,
 161                              hasSourceExpression(MatchedDirectCallExpr))));
 162
 163   auto UnusedInCompoundStmt =
 164       compoundStmt(forEach(MatchedCallExpr),
 165                    // The checker can't currently differentiate between the
 166                    // return statement and other statements inside GNU statement
 167                    // expressions, so disable the checker inside them to avoid
 168                    // false positives.
 169                    unless(hasParent(stmtExpr())));
 170   auto UnusedInIfStmt =
 171       ifStmt(eachOf(hasThen(MatchedCallExpr), hasElse(MatchedCallExpr)));
 172   auto UnusedInWhileStmt = whileStmt(hasBody(MatchedCallExpr));
 173   auto UnusedInDoStmt = doStmt(hasBody(MatchedCallExpr));
 174   auto UnusedInForStmt =
 175       forStmt(eachOf(hasLoopInit(MatchedCallExpr),
 176                      hasIncrement(MatchedCallExpr), hasBody(MatchedCallExpr)));
 177   auto UnusedInRangeForStmt = cxxForRangeStmt(hasBody(MatchedCallExpr));
 178   auto UnusedInCaseStmt = switchCase(forEach(MatchedCallExpr));
 179
 180   Finder->addMatcher(
 181       stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
 182                  UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
 183                  UnusedInCaseStmt)),
 184       this);
 185 }
 186
 187 void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
 188   if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
 189     diag(Matched->getBeginLoc(),
 190          "the value returned by this function should not be disregarded; "
 191          "neglecting it may lead to errors")
 192         << Matched->getSourceRange();
 193
 194     if (!AllowCastToVoid)
 195       return;
 196
 197     diag(Matched->getBeginLoc(),
 198          "cast the expression to void to silence this warning",
 199          DiagnosticIDs::Note);
 200   }
 201 }
 202
 203 } // namespace clang::tidy::bugprone