10 #include "../utils/Matchers.h" 11 #include "../utils/OptionsUtils.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/ASTMatchers/ASTMatchFinder.h" 24 ast_matchers::internal::BindableMatcher<Stmt>
25 handleFrom(
const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle,
26 const ast_matchers::internal::Matcher<Expr> &Arg) {
28 anyOf(cxxConstructExpr(hasDeclaration(cxxMethodDecl(ofClass(IsAHandle))),
30 cxxMemberCallExpr(hasType(cxxRecordDecl(IsAHandle)),
31 callee(memberExpr(member(cxxConversionDecl()))),
35 ast_matchers::internal::Matcher<Stmt> handleFromTemporaryValue(
36 const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle) {
40 const auto TemporaryTernary =
41 conditionalOperator(hasTrueExpression(cxxBindTemporaryExpr()),
42 hasFalseExpression(cxxBindTemporaryExpr()));
44 return handleFrom(IsAHandle, anyOf(cxxBindTemporaryExpr(), TemporaryTernary));
47 ast_matchers::internal::Matcher<RecordDecl> isASequence() {
48 return hasAnyName(
"::std::deque",
"::std::forward_list",
"::std::list",
52 ast_matchers::internal::Matcher<RecordDecl> isASet() {
53 return hasAnyName(
"::std::set",
"::std::multiset",
"::std::unordered_set",
54 "::std::unordered_multiset");
57 ast_matchers::internal::Matcher<RecordDecl> isAMap() {
58 return hasAnyName(
"::std::map",
"::std::multimap",
"::std::unordered_map",
59 "::std::unordered_multimap");
62 ast_matchers::internal::BindableMatcher<Stmt> makeContainerMatcher(
63 const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle) {
72 ignoringParenImpCasts(handleFromTemporaryValue(IsAHandle))),
76 callee(functionDecl(hasAnyName(
"assign",
"push_back",
"resize"))),
77 on(expr(hasType(hasUnqualifiedDesugaredType(
78 recordType(hasDeclaration(recordDecl(isASequence())))))))),
80 cxxMemberCallExpr(callee(functionDecl(hasName(
"insert"))),
81 on(expr(hasType(hasUnqualifiedDesugaredType(
82 recordType(hasDeclaration(recordDecl(
83 anyOf(isASequence(), isASet()))))))))),
85 cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(isAMap()))),
86 hasOverloadedOperatorName(
"[]"))));
91 DanglingHandleCheck::DanglingHandleCheck(StringRef
Name,
96 "std::basic_string_view;std::experimental::basic_string_view"))),
97 IsAHandle(cxxRecordDecl(hasAnyName(std::vector<StringRef>(
98 HandleClasses.begin(), HandleClasses.end())))
106 void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {
107 const auto ConvertedHandle = handleFromTemporaryValue(IsAHandle);
111 varDecl(hasType(hasUnqualifiedDesugaredType(
112 recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
114 exprWithCleanups(has(ignoringParenImpCasts(ConvertedHandle)))
121 hasType(hasUnqualifiedDesugaredType(
122 recordType(hasDeclaration(cxxRecordDecl(IsAHandle))))),
123 unless(parmVarDecl()),
124 hasInitializer(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
125 IsAHandle, ConvertedHandle))))
130 cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))),
131 hasOverloadedOperatorName(
"="),
132 hasArgument(1, ConvertedHandle))
137 Finder->addMatcher(makeContainerMatcher(IsAHandle).bind(
"bad_stmt"),
this);
140 void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
148 has(ignoringImplicit(handleFrom(
150 handleFrom(IsAHandle,
151 declRefExpr(to(varDecl(
153 hasAutomaticStorageDuration(),
155 anyOf(hasType(arrayType()),
156 hasType(hasUnqualifiedDesugaredType(
157 recordType(hasDeclaration(recordDecl(
158 unless(IsAHandle)))))))))))))),
160 unless(hasAncestor(lambdaExpr())))
166 returnStmt(has(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
167 IsAHandle, handleFromTemporaryValue(IsAHandle)))))))
173 registerMatchersForVariables(Finder);
174 registerMatchersForReturn(Finder);
178 auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>(
"handle");
179 diag(Result.Nodes.getNodeAs<Stmt>(
"bad_stmt")->getBeginLoc(),
180 "%0 outlives its value")
181 << Handle->getQualifiedNameAsString();
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
std::string serializeStringList(ArrayRef< std::string > Strings)
Serialize a sequence of names that can be parsed by parseStringList.
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
Base class for all clang-tidy checks.
std::vector< std::string > parseStringList(StringRef Option)
Parse a semicolon separated list of strings.
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.
static constexpr llvm::StringLiteral Name
std::map< std::string, std::string > OptionMap
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.