clang-tools 20.0.0git
EmptyCatchCheck.cpp
Go to the documentation of this file.
1//===--- EmptyCatchCheck.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 "EmptyCatchCheck.h"
10#include "../utils/Matchers.h"
11#include "../utils/OptionsUtils.h"
12#include "clang/AST/ASTContext.h"
13#include "clang/ASTMatchers/ASTMatchFinder.h"
14#include "clang/Lex/Lexer.h"
15#include <algorithm>
16
17using namespace clang::ast_matchers;
18using ::clang::ast_matchers::internal::Matcher;
19
20namespace clang::tidy::bugprone {
21
22namespace {
23AST_MATCHER(CXXCatchStmt, isInMacro) {
24 return Node.getBeginLoc().isMacroID() || Node.getEndLoc().isMacroID() ||
25 Node.getCatchLoc().isMacroID();
26}
27
28AST_MATCHER_P(CXXCatchStmt, hasHandler, Matcher<Stmt>, InnerMatcher) {
29 Stmt *Handler = Node.getHandlerBlock();
30 if (!Handler)
31 return false;
32 return InnerMatcher.matches(*Handler, Finder, Builder);
33}
34
35AST_MATCHER_P(CXXCatchStmt, hasCaughtType, Matcher<QualType>, InnerMatcher) {
36 return InnerMatcher.matches(Node.getCaughtType(), Finder, Builder);
37}
38
39AST_MATCHER_P(CompoundStmt, hasAnyTextFromList, std::vector<llvm::StringRef>,
40 List) {
41 if (List.empty())
42 return false;
43
44 ASTContext &Context = Finder->getASTContext();
45 SourceManager &SM = Context.getSourceManager();
46 StringRef Text = Lexer::getSourceText(
47 CharSourceRange::getTokenRange(Node.getSourceRange()), SM,
48 Context.getLangOpts());
49 return llvm::any_of(List, [&](const StringRef &Str) {
50 return Text.contains_insensitive(Str);
51 });
52}
53
54} // namespace
55
57 : ClangTidyCheck(Name, Context),
58 IgnoreCatchWithKeywords(utils::options::parseStringList(
59 Options.get("IgnoreCatchWithKeywords", "@TODO;@FIXME"))),
60 AllowEmptyCatchForExceptions(utils::options::parseStringList(
61 Options.get("AllowEmptyCatchForExceptions", ""))) {}
62
64 Options.store(Opts, "IgnoreCatchWithKeywords",
65 utils::options::serializeStringList(IgnoreCatchWithKeywords));
67 Opts, "AllowEmptyCatchForExceptions",
68 utils::options::serializeStringList(AllowEmptyCatchForExceptions));
69}
70
72 const LangOptions &LangOpts) const {
73 return LangOpts.CPlusPlus;
74}
75
76std::optional<TraversalKind> EmptyCatchCheck::getCheckTraversalKind() const {
77 return TK_IgnoreUnlessSpelledInSource;
78}
79
80void EmptyCatchCheck::registerMatchers(MatchFinder *Finder) {
81 auto AllowedNamedExceptionDecl =
82 namedDecl(matchers::matchesAnyListedName(AllowEmptyCatchForExceptions));
83 auto AllowedNamedExceptionTypes =
84 qualType(anyOf(hasDeclaration(AllowedNamedExceptionDecl),
85 references(AllowedNamedExceptionDecl),
86 pointsTo(AllowedNamedExceptionDecl)));
87 auto IgnoredExceptionType =
88 qualType(anyOf(AllowedNamedExceptionTypes,
89 hasCanonicalType(AllowedNamedExceptionTypes)));
90
91 Finder->addMatcher(
92 cxxCatchStmt(unless(isExpansionInSystemHeader()), unless(isInMacro()),
93 unless(hasCaughtType(IgnoredExceptionType)),
94 hasHandler(compoundStmt(
95 statementCountIs(0),
96 unless(hasAnyTextFromList(IgnoreCatchWithKeywords)))))
97 .bind("catch"),
98 this);
99}
100
101void EmptyCatchCheck::check(const MatchFinder::MatchResult &Result) {
102 const auto *MatchedCatchStmt = Result.Nodes.getNodeAs<CXXCatchStmt>("catch");
103
104 diag(
105 MatchedCatchStmt->getCatchLoc(),
106 "empty catch statements hide issues; to handle exceptions appropriately, "
107 "consider re-throwing, handling, or avoiding catch altogether");
108}
109
110} // namespace clang::tidy::bugprone
llvm::SmallString< 256U > Name
CodeCompletionBuilder Builder
std::string Text
::clang::DynTypedNode Node
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Base class for all clang-tidy checks.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
EmptyCatchCheck(StringRef Name, ClangTidyContext *Context)
std::optional< TraversalKind > getCheckTraversalKind() const override
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
bool isLanguageVersionSupported(const LangOptions &LangOpts) const override
Override this to disable registering matchers and PP callbacks if an invalid language version is bein...
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
AST_MATCHER_P(FunctionDecl, parameterCountGE, unsigned, N)
Matches functions that have at least the specified amount of parameters.
AST_MATCHER(clang::VarDecl, hasConstantDeclaration)
inline ::clang::ast_matchers::internal::Matcher< NamedDecl > matchesAnyListedName(llvm::ArrayRef< StringRef > NameList)
std::string serializeStringList(ArrayRef< StringRef > Strings)
Serialize a sequence of names that can be parsed by parseStringList.
llvm::StringMap< ClangTidyValue > OptionMap