| 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 |