clang-tools 3.8.0

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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