Debian Codegraph @

llvm-project/clang-tools-extra/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

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