[clang-tidy] ObjC ARC objects should not trigger performance-unnecessary-value-param
[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   // This check is specific to C++ and doesn't apply to languages like
83   // Objective-C.
84   if (!getLangOpts().CPlusPlus)
85     return;
86   const auto ExpensiveValueParamDecl =
87       parmVarDecl(hasType(hasCanonicalType(allOf(
88                       unless(referenceType()), matchers::isExpensiveToCopy()))),
89                   decl().bind("param"));
90   Finder->addMatcher(
91       functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()),
92                    unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))),
93                    has(typeLoc(forEach(ExpensiveValueParamDecl))),
94                    unless(isInstantiated()), decl().bind("functionDecl")),
95       this);
96 }
97
98 void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
99   const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
100   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
101   const size_t Index = std::find(Function->parameters().begin(),
102                                  Function->parameters().end(), Param) -
103                        Function->parameters().begin();
104   bool IsConstQualified =
105       Param->getType().getCanonicalType().isConstQualified();
106
107   auto AllDeclRefExprs = utils::decl_ref_expr::allDeclRefExprs(
108       *Param, *Function, *Result.Context);
109   auto ConstDeclRefExprs = utils::decl_ref_expr::constReferenceDeclRefExprs(
110       *Param, *Function, *Result.Context);
111
112   // Do not trigger on non-const value parameters when they are not only used as
113   // const.
114   if (!isSubset(AllDeclRefExprs, ConstDeclRefExprs))
115     return;
116
117   // If the parameter is non-const, check if it has a move constructor and is
118   // only referenced once to copy-construct another object or whether it has a
119   // move assignment operator and is only referenced once when copy-assigned.
120   // In this case wrap DeclRefExpr with std::move() to avoid the unnecessary
121   // copy.
122   if (!IsConstQualified && AllDeclRefExprs.size() == 1) {
123     auto CanonicalType = Param->getType().getCanonicalType();
124     const auto &DeclRefExpr  = **AllDeclRefExprs.begin();
125
126     if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context) &&
127         ((utils::type_traits::hasNonTrivialMoveConstructor(CanonicalType) &&
128           utils::decl_ref_expr::isCopyConstructorArgument(
129               DeclRefExpr, *Function, *Result.Context)) ||
130          (utils::type_traits::hasNonTrivialMoveAssignment(CanonicalType) &&
131           utils::decl_ref_expr::isCopyAssignmentArgument(
132               DeclRefExpr, *Function, *Result.Context)))) {
133       handleMoveFix(*Param, DeclRefExpr, *Result.Context);
134       return;
135     }
136   }
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->getLocStart().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       Diag << utils::fixit::changeVarDeclToConst(CurrentParam);
168   }
169 }
170
171 void UnnecessaryValueParamCheck::registerPPCallbacks(
172     CompilerInstance &Compiler) {
173   Inserter.reset(new utils::IncludeInserter(
174       Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
175   Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
176 }
177
178 void UnnecessaryValueParamCheck::storeOptions(
179     ClangTidyOptions::OptionMap &Opts) {
180   Options.store(Opts, "IncludeStyle",
181                 utils::IncludeSorter::toString(IncludeStyle));
182 }
183
184 void UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
185                                                const DeclRefExpr &CopyArgument,
186                                                const ASTContext &Context) {
187   auto Diag = diag(CopyArgument.getLocStart(),
188                    "parameter %0 is passed by value and only copied once; "
189                    "consider moving it to avoid unnecessary copies")
190               << &Var;
191   // Do not propose fixes in macros since we cannot place them correctly.
192   if (CopyArgument.getLocStart().isMacroID())
193     return;
194   const auto &SM = Context.getSourceManager();
195   auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
196                                            Context.getLangOpts());
197   Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(")
198        << FixItHint::CreateInsertion(EndLoc, ")");
199   if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
200           SM.getFileID(CopyArgument.getLocStart()), "utility",
201           /*IsAngled=*/true))
202     Diag << *IncludeFixit;
203 }
204
205 } // namespace performance
206 } // namespace tidy
207 } // namespace clang