UnusedReturnValueCheck.cpp

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "UnusedReturnValueCheck.h"
#include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/OperatorKinds.h"
 
using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal;
 
namespace clang::tidy::bugprone {
 
namespace {
 
// Matches functions that are instantiated from a class template member function
// matching InnerMatcher. Functions not instantiated from a class template
// member function are matched directly with InnerMatcher.
AST_MATCHER_P(FunctionDecl, isInstantiatedFrom, Matcher<FunctionDecl>,
              InnerMatcher) {
  FunctionDecl *InstantiatedFrom = Node.getInstantiatedFromMemberFunction();
  return InnerMatcher.matches(InstantiatedFrom ? *InstantiatedFrom : Node,
                              Finder, Builder);
}
 
constexpr std::initializer_list<OverloadedOperatorKind>
    AssignmentOverloadedOperatorKinds = {
        OO_Equal,      OO_PlusEqual,     OO_MinusEqual,          OO_StarEqual,
        OO_SlashEqual, OO_PercentEqual,  OO_CaretEqual,          OO_AmpEqual,
        OO_PipeEqual,  OO_LessLessEqual, OO_GreaterGreaterEqual, OO_PlusPlus,
        OO_MinusMinus};
 
AST_MATCHER(FunctionDecl, isAssignmentOverloadedOperator) {
  return llvm::is_contained(AssignmentOverloadedOperatorKinds,
                            Node.getOverloadedOperator());
}
} // namespace
 
UnusedReturnValueCheck::UnusedReturnValueCheck(llvm::StringRef Name,
                                               ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      CheckedFunctions(utils::options::parseStringList(
          Options.get("CheckedFunctions", "^::std::async$;"
                                          "^::std::launder$;"
                                          "^::std::remove$;"
                                          "^::std::remove_if$;"
                                          "^::std::unique$;"
                                          "^::std::unique_ptr::release$;"
                                          "^::std::basic_string::empty$;"
                                          "^::std::vector::empty$;"
                                          "^::std::back_inserter$;"
                                          "^::std::distance$;"
                                          "^::std::find$;"
                                          "^::std::find_if$;"
                                          "^::std::inserter$;"
                                          "^::std::lower_bound$;"
                                          "^::std::make_pair$;"
                                          "^::std::map::count$;"
                                          "^::std::map::find$;"
                                          "^::std::map::lower_bound$;"
                                          "^::std::multimap::equal_range$;"
                                          "^::std::multimap::upper_bound$;"
                                          "^::std::set::count$;"
                                          "^::std::set::find$;"
                                          "^::std::setfill$;"
                                          "^::std::setprecision$;"
                                          "^::std::setw$;"
                                          "^::std::upper_bound$;"
                                          "^::std::vector::at$;"
                                          // C standard library
                                          "^::bsearch$;"
                                          "^::ferror$;"
                                          "^::feof$;"
                                          "^::isalnum$;"
                                          "^::isalpha$;"
                                          "^::isblank$;"
                                          "^::iscntrl$;"
                                          "^::isdigit$;"
                                          "^::isgraph$;"
                                          "^::islower$;"
                                          "^::isprint$;"
                                          "^::ispunct$;"
                                          "^::isspace$;"
                                          "^::isupper$;"
                                          "^::iswalnum$;"
                                          "^::iswprint$;"
                                          "^::iswspace$;"
                                          "^::isxdigit$;"
                                          "^::memchr$;"
                                          "^::memcmp$;"
                                          "^::strcmp$;"
                                          "^::strcoll$;"
                                          "^::strncmp$;"
                                          "^::strpbrk$;"
                                          "^::strrchr$;"
                                          "^::strspn$;"
                                          "^::strstr$;"
                                          "^::wcscmp$;"
                                          // POSIX
                                          "^::access$;"
                                          "^::bind$;"
                                          "^::connect$;"
                                          "^::difftime$;"
                                          "^::dlsym$;"
                                          "^::fnmatch$;"
                                          "^::getaddrinfo$;"
                                          "^::getopt$;"
                                          "^::htonl$;"
                                          "^::htons$;"
                                          "^::iconv_open$;"
                                          "^::inet_addr$;"
                                          "^::isascii$;"
                                          "^::isatty$;"
                                          "^::mmap$;"
                                          "^::newlocale$;"
                                          "^::openat$;"
                                          "^::pathconf$;"
                                          "^::pthread_equal$;"
                                          "^::pthread_getspecific$;"
                                          "^::pthread_mutex_trylock$;"
                                          "^::readdir$;"
                                          "^::readlink$;"
                                          "^::recvmsg$;"
                                          "^::regexec$;"
                                          "^::scandir$;"
                                          "^::semget$;"
                                          "^::setjmp$;"
                                          "^::shm_open$;"
                                          "^::shmget$;"
                                          "^::sigismember$;"
                                          "^::strcasecmp$;"
                                          "^::strsignal$;"
                                          "^::ttyname$"))),
      CheckedReturnTypes(utils::options::parseStringList(
          Options.get("CheckedReturnTypes", "^::std::error_code$;"
                                            "^::std::error_condition$;"
                                            "^::std::errc$;"
                                            "^::std::expected$;"
                                            "^::boost::system::error_code$"))),
      AllowCastToVoid(Options.get("AllowCastToVoid", false)) {}
 
UnusedReturnValueCheck::UnusedReturnValueCheck(
    llvm::StringRef Name, ClangTidyContext *Context,
    std::vector<StringRef> CheckedFunctions)
    : UnusedReturnValueCheck(Name, Context, std::move(CheckedFunctions), {},
                             false) {}
 
UnusedReturnValueCheck::UnusedReturnValueCheck(
    llvm::StringRef Name, ClangTidyContext *Context,
    std::vector<StringRef> CheckedFunctions,
    std::vector<StringRef> CheckedReturnTypes, bool AllowCastToVoid)
    : ClangTidyCheck(Name, Context),
      CheckedFunctions(std::move(CheckedFunctions)),
      CheckedReturnTypes(std::move(CheckedReturnTypes)),
      AllowCastToVoid(AllowCastToVoid) {}
 
void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "CheckedFunctions",
                utils::options::serializeStringList(CheckedFunctions));
  Options.store(Opts, "CheckedReturnTypes",
                utils::options::serializeStringList(CheckedReturnTypes));
  Options.store(Opts, "AllowCastToVoid", AllowCastToVoid);
}
 
void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
  auto MatchedDirectCallExpr =
      expr(callExpr(callee(functionDecl(
                        // Don't match copy or move assignment operator.
                        unless(isAssignmentOverloadedOperator()),
                        // Don't match void overloads of checked functions.
                        unless(returns(voidType())),
                        anyOf(isInstantiatedFrom(matchers::matchesAnyListedName(
                                  CheckedFunctions)),
                              returns(hasCanonicalType(hasDeclaration(
                                  namedDecl(matchers::matchesAnyListedName(
                                      CheckedReturnTypes)))))))))
               .bind("match"));
 
  auto CheckCastToVoid =
      AllowCastToVoid ? castExpr(unless(hasCastKind(CK_ToVoid))) : castExpr();
  auto MatchedCallExpr = expr(
      anyOf(MatchedDirectCallExpr,
            explicitCastExpr(unless(cxxFunctionalCastExpr()), CheckCastToVoid,
                             hasSourceExpression(MatchedDirectCallExpr))));
 
  auto UnusedInCompoundStmt =
      compoundStmt(forEach(MatchedCallExpr),
                   // The checker can't currently differentiate between the
                   // return statement and other statements inside GNU statement
                   // expressions, so disable the checker inside them to avoid
                   // false positives.
                   unless(hasParent(stmtExpr())));
  auto UnusedInIfStmt =
      ifStmt(eachOf(hasThen(MatchedCallExpr), hasElse(MatchedCallExpr)));
  auto UnusedInWhileStmt = whileStmt(hasBody(MatchedCallExpr));
  auto UnusedInDoStmt = doStmt(hasBody(MatchedCallExpr));
  auto UnusedInForStmt =
      forStmt(eachOf(hasLoopInit(MatchedCallExpr),
                     hasIncrement(MatchedCallExpr), hasBody(MatchedCallExpr)));
  auto UnusedInRangeForStmt = cxxForRangeStmt(hasBody(MatchedCallExpr));
  auto UnusedInCaseStmt = switchCase(forEach(MatchedCallExpr));
 
  Finder->addMatcher(
      stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
                 UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
                 UnusedInCaseStmt)),
      this);
}
 
void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
  if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
    diag(Matched->getBeginLoc(),
         "the value returned by this function should not be disregarded; "
         "neglecting it may lead to errors")
        << Matched->getSourceRange();
 
    if (!AllowCastToVoid)
      return;
 
    diag(Matched->getBeginLoc(),
         "cast the expression to void to silence this warning",
         DiagnosticIDs::Note);
  }
}
 
} // namespace clang::tidy::bugprone