clang-tools 20.0.0git
UniqueptrResetReleaseCheck.cpp
Go to the documentation of this file.
1//===--- UniqueptrResetReleaseCheck.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
10#include "clang/ASTMatchers/ASTMatchFinder.h"
11#include "clang/Lex/Lexer.h"
12
13using namespace clang::ast_matchers;
14
15namespace clang::tidy::misc {
16
18 StringRef Name, ClangTidyContext *Context)
19 : ClangTidyCheck(Name, Context),
20 Inserter(Options.getLocalOrGlobal("IncludeStyle",
21 utils::IncludeSorter::IS_LLVM),
22 areDiagsSelfContained()) {}
23
26 Options.store(Opts, "IncludeStyle", Inserter.getStyle());
27}
28
30 const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
31 Inserter.registerPreprocessor(PP);
32}
33
35 Finder->addMatcher(
36 cxxMemberCallExpr(
37 callee(memberExpr(
38 member(cxxMethodDecl(
39 hasName("reset"),
40 ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
41 decl().bind("left_class"))))))
42 .bind("reset_member")),
43 hasArgument(
44 0, ignoringParenImpCasts(cxxMemberCallExpr(
45 on(expr().bind("right")),
46 callee(memberExpr(member(cxxMethodDecl(
47 hasName("release"),
48 ofClass(cxxRecordDecl(
49 hasName("::std::unique_ptr"),
50 decl().bind("right_class"))))))
51 .bind("release_member"))))))
52 .bind("reset_call"),
53 this);
54}
55
56namespace {
57const Type *getDeleterForUniquePtr(const MatchFinder::MatchResult &Result,
58 StringRef ID) {
59 const auto *Class =
60 Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>(ID);
61 if (!Class)
62 return nullptr;
63 auto DeleterArgument = Class->getTemplateArgs()[1];
64 if (DeleterArgument.getKind() != TemplateArgument::Type)
65 return nullptr;
66 return DeleterArgument.getAsType().getTypePtr();
67}
68
69bool areDeletersCompatible(const MatchFinder::MatchResult &Result) {
70 const Type *LeftDeleterType = getDeleterForUniquePtr(Result, "left_class");
71 const Type *RightDeleterType = getDeleterForUniquePtr(Result, "right_class");
72
73 if (LeftDeleterType->getUnqualifiedDesugaredType() ==
74 RightDeleterType->getUnqualifiedDesugaredType()) {
75 // Same type. We assume they are compatible.
76 // This check handles the case where the deleters are function pointers.
77 return true;
78 }
79
80 const CXXRecordDecl *LeftDeleter = LeftDeleterType->getAsCXXRecordDecl();
81 const CXXRecordDecl *RightDeleter = RightDeleterType->getAsCXXRecordDecl();
82 if (!LeftDeleter || !RightDeleter)
83 return false;
84
85 if (LeftDeleter->getCanonicalDecl() == RightDeleter->getCanonicalDecl()) {
86 // Same class. We assume they are compatible.
87 return true;
88 }
89
90 const auto *LeftAsTemplate =
91 dyn_cast<ClassTemplateSpecializationDecl>(LeftDeleter);
92 const auto *RightAsTemplate =
93 dyn_cast<ClassTemplateSpecializationDecl>(RightDeleter);
94 if (LeftAsTemplate && RightAsTemplate &&
95 LeftAsTemplate->getSpecializedTemplate() ==
96 RightAsTemplate->getSpecializedTemplate()) {
97 // They are different instantiations of the same template. We assume they
98 // are compatible.
99 // This handles things like std::default_delete<Base> vs.
100 // std::default_delete<Derived>.
101 return true;
102 }
103 return false;
104}
105
106} // namespace
107
108void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) {
109 if (!areDeletersCompatible(Result))
110 return;
111
112 const auto *ResetMember = Result.Nodes.getNodeAs<MemberExpr>("reset_member");
113 const auto *ReleaseMember =
114 Result.Nodes.getNodeAs<MemberExpr>("release_member");
115 const auto *Right = Result.Nodes.getNodeAs<Expr>("right");
116 const auto *ResetCall =
117 Result.Nodes.getNodeAs<CXXMemberCallExpr>("reset_call");
118
119 StringRef AssignmentText = " = ";
120 StringRef TrailingText = "";
121 bool NeedsUtilityInclude = false;
122 if (ReleaseMember->isArrow()) {
123 AssignmentText = " = std::move(*";
124 TrailingText = ")";
125 NeedsUtilityInclude = true;
126 } else if (!Right->isPRValue()) {
127 AssignmentText = " = std::move(";
128 TrailingText = ")";
129 NeedsUtilityInclude = true;
130 }
131
132 auto D = diag(ResetMember->getExprLoc(),
133 "prefer 'unique_ptr<>' assignment over 'release' and 'reset'");
134 if (ResetMember->isArrow())
135 D << FixItHint::CreateInsertion(ResetMember->getBeginLoc(), "*");
136 D << FixItHint::CreateReplacement(
137 CharSourceRange::getCharRange(ResetMember->getOperatorLoc(),
138 Right->getBeginLoc()),
139 AssignmentText)
140 << FixItHint::CreateReplacement(
141 CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(),
142 ResetCall->getEndLoc()),
143 TrailingText);
144 if (NeedsUtilityInclude)
145 D << Inserter.createIncludeInsertion(
146 Result.SourceManager->getFileID(ResetMember->getBeginLoc()),
147 "<utility>");
148}
149} // namespace clang::tidy::misc
llvm::SmallString< 256U > Name
NodeType Type
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.
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) override
Override this to register PPCallbacks in the preprocessor.
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
UniqueptrResetReleaseCheck(StringRef Name, ClangTidyContext *Context)
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
void registerPreprocessor(Preprocessor *PP)
Registers this with the Preprocessor PP, must be called before this class is used.
std::optional< FixItHint > createIncludeInsertion(FileID FileID, llvm::StringRef Header)
Creates a Header inclusion directive fixit in the File FileID.
IncludeSorter::IncludeStyle getStyle() const
llvm::StringMap< ClangTidyValue > OptionMap