1 //===--- UnnecessaryValueParamCheck.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 "UnnecessaryValueParamCheck.h"
10
11 #include "../utils/DeclRefExprUtils.h"
12 #include "../utils/FixItHintUtils.h"
13 #include "../utils/Matchers.h"
14 #include "../utils/OptionsUtils.h"
15 #include "../utils/TypeTraits.h"
16 #include "clang/Frontend/CompilerInstance.h"
17 #include "clang/Lex/Lexer.h"
18 #include "clang/Lex/Preprocessor.h"
19
20 using namespace clang::ast_matchers;
21
22 namespace clang {
23 namespace tidy {
24 namespace performance {
25
26 namespace {
27
paramNameOrIndex(StringRef Name,size_t Index)28 std::string paramNameOrIndex(StringRef Name, size_t Index) {
29 return (Name.empty() ? llvm::Twine('#') + llvm::Twine(Index + 1)
30 : llvm::Twine('\'') + Name + llvm::Twine('\''))
31 .str();
32 }
33
isReferencedOutsideOfCallExpr(const FunctionDecl & Function,ASTContext & Context)34 bool isReferencedOutsideOfCallExpr(const FunctionDecl &Function,
35 ASTContext &Context) {
36 auto Matches = match(declRefExpr(to(functionDecl(equalsNode(&Function))),
37 unless(hasAncestor(callExpr()))),
38 Context);
39 return !Matches.empty();
40 }
41
hasLoopStmtAncestor(const DeclRefExpr & DeclRef,const Decl & Decl,ASTContext & Context)42 bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
43 ASTContext &Context) {
44 auto Matches = match(
45 traverse(ast_type_traits::TK_AsIs,
46 decl(forEachDescendant(declRefExpr(
47 equalsNode(&DeclRef),
48 unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(),
49 whileStmt(), doStmt())))))))),
50 Decl, Context);
51 return Matches.empty();
52 }
53
isExplicitTemplateSpecialization(const FunctionDecl & Function)54 bool isExplicitTemplateSpecialization(const FunctionDecl &Function) {
55 if (const auto *SpecializationInfo = Function.getTemplateSpecializationInfo())
56 if (SpecializationInfo->getTemplateSpecializationKind() ==
57 TSK_ExplicitSpecialization)
58 return true;
59 if (const auto *Method = llvm::dyn_cast<CXXMethodDecl>(&Function))
60 if (Method->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization &&
61 Method->getMemberSpecializationInfo()->isExplicitSpecialization())
62 return true;
63 return false;
64 }
65
66 } // namespace
67
UnnecessaryValueParamCheck(StringRef Name,ClangTidyContext * Context)68 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
69 StringRef Name, ClangTidyContext *Context)
70 : ClangTidyCheck(Name, Context),
71 Inserter(Options.getLocalOrGlobal("IncludeStyle",
72 utils::IncludeSorter::IS_LLVM)),
73 AllowedTypes(
74 utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
75
registerMatchers(MatchFinder * Finder)76 void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
77 const auto ExpensiveValueParamDecl = parmVarDecl(
78 hasType(qualType(
79 hasCanonicalType(matchers::isExpensiveToCopy()),
80 unless(anyOf(hasCanonicalType(referenceType()),
81 hasDeclaration(namedDecl(
82 matchers::matchesAnyListedName(AllowedTypes))))))),
83 decl().bind("param"));
84 Finder->addMatcher(
85 traverse(
86 ast_type_traits::TK_AsIs,
87 functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()),
88 unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))),
89 has(typeLoc(forEach(ExpensiveValueParamDecl))),
90 unless(isInstantiated()), decl().bind("functionDecl"))),
91 this);
92 }
93
check(const MatchFinder::MatchResult & Result)94 void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
95 const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
96 const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
97
98 TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
99
100 FunctionParmMutationAnalyzer &Analyzer =
101 MutationAnalyzers.try_emplace(Function, *Function, *Result.Context)
102 .first->second;
103 if (Analyzer.isMutated(Param))
104 return;
105
106 const bool IsConstQualified =
107 Param->getType().getCanonicalType().isConstQualified();
108
109 // If the parameter is non-const, check if it has a move constructor and is
110 // only referenced once to copy-construct another object or whether it has a
111 // move assignment operator and is only referenced once when copy-assigned.
112 // In this case wrap DeclRefExpr with std::move() to avoid the unnecessary
113 // copy.
114 if (!IsConstQualified) {
115 auto AllDeclRefExprs = utils::decl_ref_expr::allDeclRefExprs(
116 *Param, *Function, *Result.Context);
117 if (AllDeclRefExprs.size() == 1) {
118 auto CanonicalType = Param->getType().getCanonicalType();
119 const auto &DeclRefExpr = **AllDeclRefExprs.begin();
120
121 if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context) &&
122 ((utils::type_traits::hasNonTrivialMoveConstructor(CanonicalType) &&
123 utils::decl_ref_expr::isCopyConstructorArgument(
124 DeclRefExpr, *Function, *Result.Context)) ||
125 (utils::type_traits::hasNonTrivialMoveAssignment(CanonicalType) &&
126 utils::decl_ref_expr::isCopyAssignmentArgument(
127 DeclRefExpr, *Function, *Result.Context)))) {
128 handleMoveFix(*Param, DeclRefExpr, *Result.Context);
129 return;
130 }
131 }
132 }
133
134 const size_t Index = std::find(Function->parameters().begin(),
135 Function->parameters().end(), Param) -
136 Function->parameters().begin();
137
138 auto Diag =
139 diag(Param->getLocation(),
140 IsConstQualified ? "the const qualified parameter %0 is "
141 "copied for each invocation; consider "
142 "making it a reference"
143 : "the parameter %0 is copied for each "
144 "invocation but only used as a const reference; "
145 "consider making it a const reference")
146 << paramNameOrIndex(Param->getName(), Index);
147 // Do not propose fixes when:
148 // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
149 // 2. the function is virtual as it might break overrides
150 // 3. the function is referenced outside of a call expression within the
151 // compilation unit as the signature change could introduce build errors.
152 // 4. the function is an explicit template specialization.
153 const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
154 if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||
155 isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
156 isExplicitTemplateSpecialization(*Function))
157 return;
158 for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
159 FunctionDecl = FunctionDecl->getPreviousDecl()) {
160 const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
161 Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
162 *Result.Context);
163 // The parameter of each declaration needs to be checked individually as to
164 // whether it is const or not as constness can differ between definition and
165 // declaration.
166 if (!CurrentParam.getType().getCanonicalType().isConstQualified()) {
167 if (llvm::Optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl(
168 CurrentParam, *Result.Context, DeclSpec::TQ::TQ_const))
169 Diag << *Fix;
170 }
171 }
172 }
173
registerPPCallbacks(const SourceManager & SM,Preprocessor * PP,Preprocessor * ModuleExpanderPP)174 void UnnecessaryValueParamCheck::registerPPCallbacks(
175 const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
176 Inserter.registerPreprocessor(PP);
177 }
178
storeOptions(ClangTidyOptions::OptionMap & Opts)179 void UnnecessaryValueParamCheck::storeOptions(
180 ClangTidyOptions::OptionMap &Opts) {
181 Options.store(Opts, "IncludeStyle", Inserter.getStyle());
182 Options.store(Opts, "AllowedTypes",
183 utils::options::serializeStringList(AllowedTypes));
184 }
185
onEndOfTranslationUnit()186 void UnnecessaryValueParamCheck::onEndOfTranslationUnit() {
187 MutationAnalyzers.clear();
188 }
189
handleMoveFix(const ParmVarDecl & Var,const DeclRefExpr & CopyArgument,const ASTContext & Context)190 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
191 const DeclRefExpr &CopyArgument,
192 const ASTContext &Context) {
193 auto Diag = diag(CopyArgument.getBeginLoc(),
194 "parameter %0 is passed by value and only copied once; "
195 "consider moving it to avoid unnecessary copies")
196 << &Var;
197 // Do not propose fixes in macros since we cannot place them correctly.
198 if (CopyArgument.getBeginLoc().isMacroID())
199 return;
200 const auto &SM = Context.getSourceManager();
201 auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
202 Context.getLangOpts());
203 Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
204 << FixItHint::CreateInsertion(EndLoc, ")")
205 << Inserter.createIncludeInsertion(
206 SM.getFileID(CopyArgument.getBeginLoc()), "<utility>");
207 }
208
209 } // namespace performance
210 } // namespace tidy
211 } // namespace clang
212