| 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 |
|
| 9 |
#include "UniqueptrResetReleaseCheck.h" |
| 10 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 11 |
#include "clang/Lex/Lexer.h" |
| 12 |
|
| 13 |
using namespace clang::ast_matchers; |
| 14 |
|
| 15 |
namespace clang::tidy::misc { |
| 16 |
|
| 17 |
UniqueptrResetReleaseCheck::UniqueptrResetReleaseCheck( |
| 18 |
StringRef Name, ClangTidyContext *Context) |
| 19 |
: ClangTidyCheck(Name, Context), |
| 20 |
Inserter(Options.getLocalOrGlobal("IncludeStyle", |
| 21 |
utils::IncludeSorter::IS_LLVM), |
| 22 |
areDiagsSelfContained()) {} |
| 23 |
|
| 24 |
void UniqueptrResetReleaseCheck::storeOptions( |
| 25 |
ClangTidyOptions::OptionMap &Opts) { |
| 26 |
Options.store(Opts, "IncludeStyle", Inserter.getStyle()); |
| 27 |
} |
| 28 |
|
| 29 |
void UniqueptrResetReleaseCheck::registerPPCallbacks( |
| 30 |
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { |
| 31 |
Inserter.registerPreprocessor(PP); |
| 32 |
} |
| 33 |
|
| 34 |
void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) { |
| 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 |
|
| 56 |
namespace { |
| 57 |
const 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 |
|
| 69 |
bool 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 |
|
| 108 |
void 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 |