clang-tools  16.0.0git
UnnecessaryValueParamCheck.cpp
Go to the documentation of this file.
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 
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 
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 
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 
42 bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
43  ASTContext &Context) {
44  auto Matches = match(
45  traverse(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 
54 } // namespace
55 
56 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
57  StringRef Name, ClangTidyContext *Context)
58  : ClangTidyCheck(Name, Context),
59  Inserter(Options.getLocalOrGlobal("IncludeStyle",
60  utils::IncludeSorter::IS_LLVM),
61  areDiagsSelfContained()),
62  AllowedTypes(
63  utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
64 
66  const auto ExpensiveValueParamDecl = parmVarDecl(
67  hasType(qualType(
68  hasCanonicalType(matchers::isExpensiveToCopy()),
69  unless(anyOf(hasCanonicalType(referenceType()),
70  hasDeclaration(namedDecl(
71  matchers::matchesAnyListedName(AllowedTypes))))))),
72  decl().bind("param"));
73  Finder->addMatcher(
74  traverse(
75  TK_AsIs,
76  functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()),
77  unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))),
78  has(typeLoc(forEach(ExpensiveValueParamDecl))),
79  unless(isInstantiated()), decl().bind("functionDecl"))),
80  this);
81 }
82 
83 void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
84  const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
85  const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
86 
87  TraversalKindScope RAII(*Result.Context, TK_AsIs);
88 
89  FunctionParmMutationAnalyzer &Analyzer =
90  MutationAnalyzers.try_emplace(Function, *Function, *Result.Context)
91  .first->second;
92  if (Analyzer.isMutated(Param))
93  return;
94 
95  const bool IsConstQualified =
96  Param->getType().getCanonicalType().isConstQualified();
97 
98  // If the parameter is non-const, check if it has a move constructor and is
99  // only referenced once to copy-construct another object or whether it has a
100  // move assignment operator and is only referenced once when copy-assigned.
101  // In this case wrap DeclRefExpr with std::move() to avoid the unnecessary
102  // copy.
103  if (!IsConstQualified) {
104  auto AllDeclRefExprs = utils::decl_ref_expr::allDeclRefExprs(
105  *Param, *Function, *Result.Context);
106  if (AllDeclRefExprs.size() == 1) {
107  auto CanonicalType = Param->getType().getCanonicalType();
108  const auto &DeclRefExpr = **AllDeclRefExprs.begin();
109 
110  if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context) &&
113  DeclRefExpr, *Function, *Result.Context)) ||
116  DeclRefExpr, *Function, *Result.Context)))) {
117  handleMoveFix(*Param, DeclRefExpr, *Result.Context);
118  return;
119  }
120  }
121  }
122 
123  const size_t Index = llvm::find(Function->parameters(), Param) -
124  Function->parameters().begin();
125 
126  auto Diag =
127  diag(Param->getLocation(),
128  "the %select{|const qualified }0parameter %1 is copied for each "
129  "invocation%select{ but only used as a const reference|}0; consider "
130  "making it a %select{const |}0reference")
131  << IsConstQualified << paramNameOrIndex(Param->getName(), Index);
132  // Do not propose fixes when:
133  // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
134  // 2. the function is virtual as it might break overrides
135  // 3. the function is referenced outside of a call expression within the
136  // compilation unit as the signature change could introduce build errors.
137  // 4. the function is a primary template or an explicit template
138  // specialization.
139  const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
140  if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||
141  isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
142  (Function->getTemplatedKind() != FunctionDecl::TK_NonTemplate))
143  return;
144  for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
145  FunctionDecl = FunctionDecl->getPreviousDecl()) {
146  const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
147  Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
148  *Result.Context);
149  // The parameter of each declaration needs to be checked individually as to
150  // whether it is const or not as constness can differ between definition and
151  // declaration.
152  if (!CurrentParam.getType().getCanonicalType().isConstQualified()) {
153  if (llvm::Optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl(
154  CurrentParam, *Result.Context, DeclSpec::TQ::TQ_const))
155  Diag << *Fix;
156  }
157  }
158 }
159 
161  const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
162  Inserter.registerPreprocessor(PP);
163 }
164 
167  Options.store(Opts, "IncludeStyle", Inserter.getStyle());
168  Options.store(Opts, "AllowedTypes",
170 }
171 
173  MutationAnalyzers.clear();
174 }
175 
176 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
177  const DeclRefExpr &CopyArgument,
178  const ASTContext &Context) {
179  auto Diag = diag(CopyArgument.getBeginLoc(),
180  "parameter %0 is passed by value and only copied once; "
181  "consider moving it to avoid unnecessary copies")
182  << &Var;
183  // Do not propose fixes in macros since we cannot place them correctly.
184  if (CopyArgument.getBeginLoc().isMacroID())
185  return;
186  const auto &SM = Context.getSourceManager();
187  auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
188  Context.getLangOpts());
189  Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
190  << FixItHint::CreateInsertion(EndLoc, ")")
191  << Inserter.createIncludeInsertion(
192  SM.getFileID(CopyArgument.getBeginLoc()), "<utility>");
193 }
194 
195 } // namespace performance
196 } // namespace tidy
197 } // namespace clang
clang::tidy::utils::decl_ref_expr::allDeclRefExprs
SmallPtrSet< const DeclRefExpr *, 16 > allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context)
Returns set of all DeclRefExprs to VarDecl within Stmt.
Definition: DeclRefExprUtils.cpp:101
clang::tidy::ClangTidyOptions::OptionMap
llvm::StringMap< ClangTidyValue > OptionMap
Definition: ClangTidyOptions.h:115
clang::tidy::utils::fixit::addQualifierToVarDecl
Optional< FixItHint > addQualifierToVarDecl(const VarDecl &Var, const ASTContext &Context, DeclSpec::TQ Qualifier, QualifierTarget QualTarget, QualifierPolicy QualPolicy)
Creates fix to qualify VarDecl with the specified Qualifier.
Definition: FixItHintUtils.cpp:184
clang::tidy::performance::UnnecessaryValueParamCheck::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Definition: UnnecessaryValueParamCheck.cpp:65
clang::tidy::utils::IncludeInserter::registerPreprocessor
void registerPreprocessor(Preprocessor *PP)
Registers this with the Preprocessor PP, must be called before this class is used.
Definition: IncludeInserter.cpp:43
clang::tidy::ClangTidyCheck
Base class for all clang-tidy checks.
Definition: ClangTidyCheck.h:53
clang::tidy::utils::type_traits::isExpensiveToCopy
llvm::Optional< bool > isExpensiveToCopy(QualType Type, const ASTContext &Context)
Returns true if Type is expensive to copy.
Definition: TypeTraits.cpp:41
clang::tidy::performance::UnnecessaryValueParamCheck::storeOptions
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
Definition: UnnecessaryValueParamCheck.cpp:165
clang::tidy::utils::fixit::changeVarDeclToReference
FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context)
Creates fix to make VarDecl a reference by adding &.
Definition: FixItHintUtils.cpp:19
Fix
static cl::opt< bool > Fix("fix", cl::desc(R"( Apply suggested fixes. Without -fix-errors clang-tidy will bail out if any compilation errors were found. )"), cl::init(false), cl::cat(ClangTidyCategory))
clang::ast_matchers
Definition: AbseilMatcher.h:14
clang::clangd::match
std::vector< std::string > match(const SymbolIndex &I, const FuzzyFindRequest &Req, bool *Incomplete)
Definition: TestIndex.cpp:133
clang::tidy::performance::UnnecessaryValueParamCheck::registerPPCallbacks
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) override
Override this to register PPCallbacks in the preprocessor.
Definition: UnnecessaryValueParamCheck.cpp:160
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:100
clang::tidy::ClangTidyCheck::Options
OptionsView Options
Definition: ClangTidyCheck.h:415
clang::tidy::ClangTidyContext
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
Definition: ClangTidyDiagnosticConsumer.h:67
clang::tidy::utils::type_traits::hasNonTrivialMoveConstructor
bool hasNonTrivialMoveConstructor(QualType Type)
Returns true if Type has a non-trivial move constructor.
Definition: TypeTraits.cpp:152
clang::tidy::utils::decl_ref_expr::isCopyAssignmentArgument
bool isCopyAssignmentArgument(const DeclRefExpr &DeclRef, const Decl &Decl, ASTContext &Context)
Returns true if DeclRefExpr is the argument of a copy-assignment operator CallExpr within Decl.
Definition: DeclRefExprUtils.cpp:135
clang::tidy::ClangTidyCheck::diag
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Definition: ClangTidyCheck.cpp:25
Name
Token Name
Definition: MacroToEnumCheck.cpp:89
clang::tidy::performance::UnnecessaryValueParamCheck::onEndOfTranslationUnit
void onEndOfTranslationUnit() override
Definition: UnnecessaryValueParamCheck.cpp:172
clang::tidy::bugprone::PP
static Preprocessor * PP
Definition: BadSignalToKillThreadCheck.cpp:29
Index
const SymbolIndex * Index
Definition: Dexp.cpp:98
clang::tidy::utils::decl_ref_expr::isCopyConstructorArgument
bool isCopyConstructorArgument(const DeclRefExpr &DeclRef, const Decl &Decl, ASTContext &Context)
Returns true if DeclRefExpr is the argument of a copy-constructor call expression within Decl.
Definition: DeclRefExprUtils.cpp:121
UnnecessaryValueParamCheck.h
DeclRef
const DeclRefExpr * DeclRef
Definition: UseAfterMoveCheck.cpp:51
clang::tidy::matchers::matchesAnyListedName
inline ::clang::ast_matchers::internal::Matcher< NamedDecl > matchesAnyListedName(llvm::ArrayRef< StringRef > NameList)
Definition: clang-tidy/utils/Matchers.h:119
clang::tidy::utils::IncludeInserter::getStyle
IncludeSorter::IncludeStyle getStyle() const
Definition: IncludeInserter.h:85
clang::tidy::utils::options::serializeStringList
std::string serializeStringList(ArrayRef< StringRef > Strings)
Serialize a sequence of names that can be parsed by parseStringList.
Definition: OptionsUtils.cpp:62
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::utils::options::parseStringList
std::vector< StringRef > parseStringList(StringRef Option)
Parse a semicolon separated list of strings.
Definition: OptionsUtils.cpp:19
clang::tidy::utils::IncludeInserter::createIncludeInsertion
llvm::Optional< FixItHint > createIncludeInsertion(FileID FileID, llvm::StringRef Header)
Creates a Header inclusion directive fixit in the File FileID.
Definition: IncludeInserter.cpp:71
clang::tidy::ClangTidyCheck::OptionsView::store
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.
Definition: ClangTidyCheck.cpp:129
clang::tidy::utils::type_traits::hasNonTrivialMoveAssignment
bool hasNonTrivialMoveAssignment(QualType Type)
Return true if Type has a non-trivial move assignment operator.
Definition: TypeTraits.cpp:158
clang::tidy::performance::UnnecessaryValueParamCheck::check
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
Definition: UnnecessaryValueParamCheck.cpp:83