clang-tools  4.0.0
RedundantSmartptrGetCheck.cpp
Go to the documentation of this file.
1 //===--- RedundantSmartptrGetCheck.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/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/Lex/Lexer.h"
13 
14 using namespace clang::ast_matchers;
15 
16 namespace clang {
17 namespace tidy {
18 namespace readability {
19 
20 namespace {
21 internal::Matcher<Expr> callToGet(const internal::Matcher<Decl> &OnClass) {
22  return cxxMemberCallExpr(
23  on(expr(anyOf(hasType(OnClass),
24  hasType(qualType(
25  pointsTo(decl(OnClass).bind("ptr_to_ptr"))))))
26  .bind("smart_pointer")),
27  unless(callee(memberExpr(hasObjectExpression(cxxThisExpr())))),
28  callee(cxxMethodDecl(
29  hasName("get"),
30  returns(qualType(pointsTo(type().bind("getType")))))))
31  .bind("redundant_get");
32 }
33 
34 void registerMatchersForGetArrowStart(MatchFinder *Finder,
35  MatchFinder::MatchCallback *Callback) {
36  const auto QuacksLikeASmartptr = recordDecl(
37  recordDecl().bind("duck_typing"),
38  has(cxxMethodDecl(hasName("operator->"),
39  returns(qualType(pointsTo(type().bind("op->Type")))))),
40  has(cxxMethodDecl(hasName("operator*"), returns(qualType(references(
41  type().bind("op*Type")))))));
42 
43  // Catch 'ptr.get()->Foo()'
44  Finder->addMatcher(memberExpr(expr().bind("memberExpr"), isArrow(),
45  hasObjectExpression(ignoringImpCasts(
46  callToGet(QuacksLikeASmartptr)))),
47  Callback);
48 
49  // Catch '*ptr.get()' or '*ptr->get()'
50  Finder->addMatcher(
51  unaryOperator(hasOperatorName("*"),
52  hasUnaryOperand(callToGet(QuacksLikeASmartptr))),
53  Callback);
54 }
55 
56 void registerMatchersForGetEquals(MatchFinder *Finder,
57  MatchFinder::MatchCallback *Callback) {
58  // This one is harder to do with duck typing.
59  // The operator==/!= that we are looking for might be member or non-member,
60  // might be on global namespace or found by ADL, might be a template, etc.
61  // For now, lets keep a list of known standard types.
62 
63  const auto IsAKnownSmartptr =
64  recordDecl(hasAnyName("::std::unique_ptr", "::std::shared_ptr"));
65 
66  // Matches against nullptr.
67  Finder->addMatcher(
68  binaryOperator(anyOf(hasOperatorName("=="), hasOperatorName("!=")),
69  hasEitherOperand(ignoringImpCasts(
70  anyOf(cxxNullPtrLiteralExpr(), gnuNullExpr(),
71  integerLiteral(equals(0))))),
72  hasEitherOperand(callToGet(IsAKnownSmartptr))),
73  Callback);
74 
75  // Matches against if(ptr.get())
76  Finder->addMatcher(
77  ifStmt(hasCondition(ignoringImpCasts(callToGet(IsAKnownSmartptr)))),
78  Callback);
79 
80  // FIXME: Match and fix if (l.get() == r.get()).
81 }
82 
83 } // namespace
84 
85 void RedundantSmartptrGetCheck::registerMatchers(MatchFinder *Finder) {
86  // Only register the matchers for C++; the functionality currently does not
87  // provide any benefit to other languages, despite being benign.
88  if (!getLangOpts().CPlusPlus)
89  return;
90 
91  registerMatchersForGetArrowStart(Finder, this);
92  registerMatchersForGetEquals(Finder, this);
93 }
94 
95 namespace {
96 bool allReturnTypesMatch(const MatchFinder::MatchResult &Result) {
97  if (Result.Nodes.getNodeAs<Decl>("duck_typing") == nullptr)
98  return true;
99  // Verify that the types match.
100  // We can't do this on the matcher because the type nodes can be different,
101  // even though they represent the same type. This difference comes from how
102  // the type is referenced (eg. through a typedef, a type trait, etc).
103  const Type *OpArrowType =
104  Result.Nodes.getNodeAs<Type>("op->Type")->getUnqualifiedDesugaredType();
105  const Type *OpStarType =
106  Result.Nodes.getNodeAs<Type>("op*Type")->getUnqualifiedDesugaredType();
107  const Type *GetType =
108  Result.Nodes.getNodeAs<Type>("getType")->getUnqualifiedDesugaredType();
109  return OpArrowType == OpStarType && OpArrowType == GetType;
110 }
111 } // namespace
112 
113 void RedundantSmartptrGetCheck::check(const MatchFinder::MatchResult &Result) {
114  if (!allReturnTypesMatch(Result))
115  return;
116 
117  bool IsPtrToPtr = Result.Nodes.getNodeAs<Decl>("ptr_to_ptr") != nullptr;
118  bool IsMemberExpr = Result.Nodes.getNodeAs<Expr>("memberExpr") != nullptr;
119  const auto *GetCall = Result.Nodes.getNodeAs<Expr>("redundant_get");
120  const auto *Smartptr = Result.Nodes.getNodeAs<Expr>("smart_pointer");
121 
122  if (IsPtrToPtr && IsMemberExpr) {
123  // Ignore this case (eg. Foo->get()->DoSomething());
124  return;
125  }
126 
127  StringRef SmartptrText = Lexer::getSourceText(
128  CharSourceRange::getTokenRange(Smartptr->getSourceRange()),
129  *Result.SourceManager, getLangOpts());
130  // Replace foo->get() with *foo, and foo.get() with foo.
131  std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str();
132  diag(GetCall->getLocStart(), "redundant get() call on smart pointer")
133  << FixItHint::CreateReplacement(GetCall->getSourceRange(), Replacement);
134 }
135 
136 } // namespace readability
137 } // namespace tidy
138 } // namespace clang
std::unique_ptr< ast_matchers::MatchFinder > Finder
Definition: ClangTidy.cpp:262
const NamedDecl * Result
Definition: USRFinder.cpp:162