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