1 //===--- ForRangeCopyCheck.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 "ForRangeCopyCheck.h" 10 #include "../utils/DeclRefExprUtils.h" 11 #include "../utils/FixItHintUtils.h" 12 #include "../utils/Matchers.h" 13 #include "../utils/OptionsUtils.h" 14 #include "../utils/TypeTraits.h" 15 #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h" 16 #include "clang/Basic/Diagnostic.h" 17 18 using namespace clang::ast_matchers; 19 20 namespace clang { 21 namespace tidy { 22 namespace performance { 23 24 ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context) 25 : ClangTidyCheck(Name, Context), 26 WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", false)), 27 AllowedTypes( 28 utils::options::parseStringList(Options.get("AllowedTypes", ""))) {} 29 30 void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { 31 Options.store(Opts, "WarnOnAllAutoCopies", WarnOnAllAutoCopies); 32 Options.store(Opts, "AllowedTypes", 33 utils::options::serializeStringList(AllowedTypes)); 34 } 35 36 void ForRangeCopyCheck::registerMatchers(MatchFinder *Finder) { 37 // Match loop variables that are not references or pointers or are already 38 // initialized through MaterializeTemporaryExpr which indicates a type 39 // conversion. 40 auto LoopVar = varDecl( 41 hasType(qualType( 42 unless(anyOf(hasCanonicalType(anyOf(referenceType(), pointerType())), 43 hasDeclaration(namedDecl( 44 matchers::matchesAnyListedName(AllowedTypes))))))), 45 unless(hasInitializer(expr(hasDescendant(materializeTemporaryExpr()))))); 46 Finder->addMatcher(cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar"))) 47 .bind("forRange"), 48 this); 49 } 50 51 void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) { 52 const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar"); 53 54 // Ignore code in macros since we can't place the fixes correctly. 55 if (Var->getBeginLoc().isMacroID()) 56 return; 57 if (handleConstValueCopy(*Var, *Result.Context)) 58 return; 59 const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange"); 60 handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context); 61 } 62 63 bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar, 64 ASTContext &Context) { 65 if (WarnOnAllAutoCopies) { 66 // For aggressive check just test that loop variable has auto type. 67 if (!isa<AutoType>(LoopVar.getType())) 68 return false; 69 } else if (!LoopVar.getType().isConstQualified()) { 70 return false; 71 } 72 llvm::Optional<bool> Expensive = 73 utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context); 74 if (!Expensive || !*Expensive) 75 return false; 76 auto Diagnostic = 77 diag(LoopVar.getLocation(), 78 "the loop variable's type is not a reference type; this creates a " 79 "copy in each iteration; consider making this a reference") 80 << utils::fixit::changeVarDeclToReference(LoopVar, Context); 81 if (!LoopVar.getType().isConstQualified()) { 82 if (llvm::Optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl( 83 LoopVar, Context, DeclSpec::TQ::TQ_const)) 84 Diagnostic << *Fix; 85 } 86 return true; 87 } 88 89 bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced( 90 const VarDecl &LoopVar, const CXXForRangeStmt &ForRange, 91 ASTContext &Context) { 92 llvm::Optional<bool> Expensive = 93 utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context); 94 if (LoopVar.getType().isConstQualified() || !Expensive || !*Expensive) 95 return false; 96 // We omit the case where the loop variable is not used in the loop body. E.g. 97 // 98 // for (auto _ : benchmark_state) { 99 // } 100 // 101 // Because the fix (changing to `const auto &`) will introduce an unused 102 // compiler warning which can't be suppressed. 103 // Since this case is very rare, it is safe to ignore it. 104 if (!ExprMutationAnalyzer(*ForRange.getBody(), Context).isMutated(&LoopVar) && 105 !utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(), 106 Context) 107 .empty()) { 108 auto Diag = diag( 109 LoopVar.getLocation(), 110 "loop variable is copied but only used as const reference; consider " 111 "making it a const reference"); 112 113 if (llvm::Optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl( 114 LoopVar, Context, DeclSpec::TQ::TQ_const)) 115 Diag << *Fix << utils::fixit::changeVarDeclToReference(LoopVar, Context); 116 117 return true; 118 } 119 return false; 120 } 121 122 } // namespace performance 123 } // namespace tidy 124 } // namespace clang 125