clang-tools  3.9.0
InefficientAlgorithmCheck.cpp
Go to the documentation of this file.
1 //===--- InefficientAlgorithmCheck.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 
11 #include "clang/AST/ASTContext.h"
12 #include "clang/ASTMatchers/ASTMatchFinder.h"
13 #include "clang/Lex/Lexer.h"
14 
15 using namespace clang::ast_matchers;
16 
17 namespace clang {
18 namespace tidy {
19 namespace misc {
20 
21 static bool areTypesCompatible(QualType Left, QualType Right) {
22  if (const auto *LeftRefType = Left->getAs<ReferenceType>())
23  Left = LeftRefType->getPointeeType();
24  if (const auto *RightRefType = Right->getAs<ReferenceType>())
25  Right = RightRefType->getPointeeType();
26  return Left->getCanonicalTypeUnqualified() ==
27  Right->getCanonicalTypeUnqualified();
28 }
29 
30 void InefficientAlgorithmCheck::registerMatchers(MatchFinder *Finder) {
31  // Only register the matchers for C++; the functionality currently does not
32  // provide any benefit to other languages, despite being benign.
33  if (!getLangOpts().CPlusPlus)
34  return;
35 
36  const auto Algorithms =
37  hasAnyName("::std::find", "::std::count", "::std::equal_range",
38  "::std::lower_bound", "::std::upper_bound");
39  const auto ContainerMatcher = classTemplateSpecializationDecl(hasAnyName(
40  "::std::set", "::std::map", "::std::multiset", "::std::multimap",
41  "::std::unordered_set", "::std::unordered_map",
42  "::std::unordered_multiset", "::std::unordered_multimap"));
43 
44  const auto Matcher =
45  callExpr(
46  callee(functionDecl(Algorithms)),
47  hasArgument(
48  0, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
49  callee(cxxMethodDecl(hasName("begin"))),
50  on(declRefExpr(
51  hasDeclaration(decl().bind("IneffContObj")),
52  anyOf(hasType(ContainerMatcher.bind("IneffCont")),
53  hasType(pointsTo(
54  ContainerMatcher.bind("IneffContPtr")))))
55  .bind("IneffContExpr"))))))),
56  hasArgument(
57  1, cxxConstructExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(
58  callee(cxxMethodDecl(hasName("end"))),
59  on(declRefExpr(
60  hasDeclaration(equalsBoundNode("IneffContObj"))))))))),
61  hasArgument(2, expr().bind("AlgParam")),
62  unless(isInTemplateInstantiation()))
63  .bind("IneffAlg");
64 
65  Finder->addMatcher(Matcher, this);
66 }
67 
68 void InefficientAlgorithmCheck::check(const MatchFinder::MatchResult &Result) {
69  const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("IneffAlg");
70  const auto *IneffCont =
71  Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("IneffCont");
72  bool PtrToContainer = false;
73  if (!IneffCont) {
74  IneffCont =
75  Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("IneffContPtr");
76  PtrToContainer = true;
77  }
78  const llvm::StringRef IneffContName = IneffCont->getName();
79  const bool Unordered =
80  IneffContName.find("unordered") != llvm::StringRef::npos;
81  const bool Maplike = IneffContName.find("map") != llvm::StringRef::npos;
82 
83  // Store if the key type of the container is compatible with the value
84  // that is searched for.
85  QualType ValueType = AlgCall->getArg(2)->getType();
86  QualType KeyType =
87  IneffCont->getTemplateArgs()[0].getAsType().getCanonicalType();
88  const bool CompatibleTypes = areTypesCompatible(KeyType, ValueType);
89 
90  // Check if the comparison type for the algorithm and the container matches.
91  if (AlgCall->getNumArgs() == 4 && !Unordered) {
92  const Expr *Arg = AlgCall->getArg(3);
93  const QualType AlgCmp =
94  Arg->getType().getUnqualifiedType().getCanonicalType();
95  const unsigned CmpPosition =
96  (IneffContName.find("map") == llvm::StringRef::npos) ? 1 : 2;
97  const QualType ContainerCmp = IneffCont->getTemplateArgs()[CmpPosition]
98  .getAsType()
99  .getUnqualifiedType()
100  .getCanonicalType();
101  if (AlgCmp != ContainerCmp) {
102  diag(Arg->getLocStart(),
103  "different comparers used in the algorithm and the container");
104  return;
105  }
106  }
107 
108  const auto *AlgDecl = AlgCall->getDirectCallee();
109  if (!AlgDecl)
110  return;
111 
112  if (Unordered && AlgDecl->getName().find("bound") != llvm::StringRef::npos)
113  return;
114 
115  const auto *AlgParam = Result.Nodes.getNodeAs<Expr>("AlgParam");
116  const auto *IneffContExpr = Result.Nodes.getNodeAs<Expr>("IneffContExpr");
117  FixItHint Hint;
118 
119  SourceManager &SM = *Result.SourceManager;
120  LangOptions LangOpts = Result.Context->getLangOpts();
121 
122  CharSourceRange CallRange =
123  CharSourceRange::getTokenRange(AlgCall->getSourceRange());
124 
125  // FIXME: Create a common utility to extract a file range that the given token
126  // sequence is exactly spelled at (without macro argument expansions etc.).
127  // We can't use Lexer::makeFileCharRange here, because for
128  //
129  // #define F(x) x
130  // x(a b c);
131  //
132  // it will return "x(a b c)", when given the range "a"-"c". It makes sense for
133  // removals, but not for replacements.
134  //
135  // This code is over-simplified, but works for many real cases.
136  if (SM.isMacroArgExpansion(CallRange.getBegin()) &&
137  SM.isMacroArgExpansion(CallRange.getEnd())) {
138  CallRange.setBegin(SM.getSpellingLoc(CallRange.getBegin()));
139  CallRange.setEnd(SM.getSpellingLoc(CallRange.getEnd()));
140  }
141 
142  if (!CallRange.getBegin().isMacroID() && !Maplike && CompatibleTypes) {
143  StringRef ContainerText = Lexer::getSourceText(
144  CharSourceRange::getTokenRange(IneffContExpr->getSourceRange()), SM,
145  LangOpts);
146  StringRef ParamText = Lexer::getSourceText(
147  CharSourceRange::getTokenRange(AlgParam->getSourceRange()), SM,
148  LangOpts);
149  std::string ReplacementText =
150  (llvm::Twine(ContainerText) + (PtrToContainer ? "->" : ".") +
151  AlgDecl->getName() + "(" + ParamText + ")")
152  .str();
153  Hint = FixItHint::CreateReplacement(CallRange, ReplacementText);
154  }
155 
156  diag(AlgCall->getLocStart(),
157  "this STL algorithm call should be replaced with a container method")
158  << Hint;
159 }
160 
161 } // namespace misc
162 } // namespace tidy
163 } // namespace clang
LangOptions LangOpts
Definition: ClangTidy.cpp:189
static bool areTypesCompatible(QualType Left, QualType Right)
std::unique_ptr< ast_matchers::MatchFinder > Finder
Definition: ClangTidy.cpp:210
SourceManager & SM
const NamedDecl * Result
Definition: USRFinder.cpp:137