0dc47d5db93ddb74f7df85fe156f0f30c3fea6dd
[lldb.git] / clang-tools-extra / clang-tidy / performance / UnnecessaryValueParamCheck.cpp
1 //===--- UnnecessaryValueParamCheck.cpp - clang-tidy-----------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "UnnecessaryValueParamCheck.h"
11
12 #include "../utils/DeclRefExprUtils.h"
13 #include "../utils/FixItHintUtils.h"
14 #include "../utils/Matchers.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 template <typename S>
35 bool isSubset(const S &SubsetCandidate, const S &SupersetCandidate) {
36   for (const auto &E : SubsetCandidate)
37     if (SupersetCandidate.count(E) == 0)
38       return false;
39   return true;
40 }
41
42 bool isReferencedOutsideOfCallExpr(const FunctionDecl &Function,
43                                    ASTContext &Context) {
44   auto Matches = match(declRefExpr(to(functionDecl(equalsNode(&Function))),
45                                    unless(hasAncestor(callExpr()))),
46                        Context);
47   return !Matches.empty();
48 }
49
50 bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
51                          ASTContext &Context) {
52   auto Matches =
53       match(decl(forEachDescendant(declRefExpr(
54                 equalsNode(&DeclRef),
55                 unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(),
56                                               whileStmt(), doStmt()))))))),
57             Decl, Context);
58   return Matches.empty();
59 }
60
61 bool isExplicitTemplateSpecialization(const FunctionDecl &Function) {
62   if (const auto *SpecializationInfo = Function.getTemplateSpecializationInfo())
63     if (SpecializationInfo->getTemplateSpecializationKind() ==
64         TSK_ExplicitSpecialization)
65       return true;
66   if (const auto *Method = llvm::dyn_cast<CXXMethodDecl>(&Function))
67     if (Method->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization &&
68         Method->getMemberSpecializationInfo()->isExplicitSpecialization())
69       return true;
70   return false;
71 }
72
73 } // namespace
74
75 UnnecessaryValueParamCheck::UnnecessaryValueParamCheck(
76     StringRef Name, ClangTidyContext *Context)
77     : ClangTidyCheck(Name, Context),
78       IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
79           Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
80
81 void UnnecessaryValueParamCheck::registerMatchers(MatchFinder *Finder) {
82   const auto ExpensiveValueParamDecl =
83       parmVarDecl(hasType(hasCanonicalType(allOf(
84                       unless(referenceType()), matchers::isExpensiveToCopy()))),
85                   decl().bind("param"));
86   Finder->addMatcher(
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
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   const size_t Index = std::find(Function->parameters().begin(),
98                                  Function->parameters().end(), Param) -
99                        Function->parameters().begin();
100   bool IsConstQualified =
101       Param->getType().getCanonicalType().isConstQualified();
102
103   auto AllDeclRefExprs = utils::decl_ref_expr::allDeclRefExprs(
104       *Param, *Function, *Result.Context);
105   auto ConstDeclRefExprs = utils::decl_ref_expr::constReferenceDeclRefExprs(
106       *Param, *Function, *Result.Context);
107
108   // Do not trigger on non-const value parameters when they are not only used as
109   // const.
110   if (!isSubset(AllDeclRefExprs, ConstDeclRefExprs))
111     return;
112
113   // If the parameter is non-const, check if it has a move constructor and is
114   // only referenced once to copy-construct another object or whether it has a
115   // move assignment operator and is only referenced once when copy-assigned.
116   // In this case wrap DeclRefExpr with std::move() to avoid the unnecessary
117   // copy.
118   if (!IsConstQualified && AllDeclRefExprs.size() == 1) {
119     auto CanonicalType = Param->getType().getCanonicalType();
120     const auto &DeclRefExpr  = **AllDeclRefExprs.begin();
121
122     if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context) &&
123         ((utils::type_traits::hasNonTrivialMoveConstructor(CanonicalType) &&
124           utils::decl_ref_expr::isCopyConstructorArgument(
125               DeclRefExpr, *Function, *Result.Context)) ||
126          (utils::type_traits::hasNonTrivialMoveAssignment(CanonicalType) &&
127           utils::decl_ref_expr::isCopyAssignmentArgument(
128               DeclRefExpr, *Function, *Result.Context)))) {
129       handleMoveFix(*Param, DeclRefExpr, *Result.Context);
130       return;
131     }
132   }
133
134   auto Diag =
135       diag(Param->getLocation(),
136            IsConstQualified ? "the const qualified parameter %0 is "
137                               "copied for each invocation; consider "
138                               "making it a reference"
139                             : "the parameter %0 is copied for each "
140                               "invocation but only used as a const reference; "
141                               "consider making it a const reference")
142       << paramNameOrIndex(Param->getName(), Index);
143   // Do not propose fixes when:
144   // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
145   // 2. the function is virtual as it might break overrides
146   // 3. the function is referenced outside of a call expression within the
147   //    compilation unit as the signature change could introduce build errors.
148   // 4. the function is an explicit template specialization.
149   const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
150   if (Param->getLocStart().isMacroID() || (Method && Method->isVirtual()) ||
151       isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
152       isExplicitTemplateSpecialization(*Function))
153     return;
154   for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
155        FunctionDecl = FunctionDecl->getPreviousDecl()) {
156     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
157     Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
158                                                    *Result.Context);
159     // The parameter of each declaration needs to be checked individually as to
160     // whether it is const or not as constness can differ between definition and
161     // declaration.
162     if (!CurrentParam.getType().getCanonicalType().isConstQualified())
163       Diag << utils::fixit::changeVarDeclToConst(CurrentParam);
164   }
165 }
166
167 void UnnecessaryValueParamCheck::registerPPCallbacks(
168     CompilerInstance &Compiler) {
169   Inserter.reset(new utils::IncludeInserter(
170       Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
171   Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
172 }
173
174 void UnnecessaryValueParamCheck::storeOptions(
175     ClangTidyOptions::OptionMap &Opts) {
176   Options.store(Opts, "IncludeStyle",
177                 utils::IncludeSorter::toString(IncludeStyle));
178 }
179
180 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
181                                                const DeclRefExpr &CopyArgument,
182                                                const ASTContext &Context) {
183   auto Diag = diag(CopyArgument.getLocStart(),
184                    "parameter %0 is passed by value and only copied once; "
185                    "consider moving it to avoid unnecessary copies")
186               << &Var;
187   // Do not propose fixes in macros since we cannot place them correctly.
188   if (CopyArgument.getLocStart().isMacroID())
189     return;
190   const auto &SM = Context.getSourceManager();
191   auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
192                                            Context.getLangOpts());
193   Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(")
194        << FixItHint::CreateInsertion(EndLoc, ")");
195   if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
196           SM.getFileID(CopyArgument.getLocStart()), "utility",
197           /*IsAngled=*/true))
198     Diag << *IncludeFixit;
199 }
200
201 } // namespace performance
202 } // namespace tidy
203 } // namespace clang