|
150
|
1 //===- RedundantStringCStrCheck.cpp - Check for redundant c_str calls -----===//
|
|
|
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 // This file implements a check for redundant calls of c_str() on strings.
|
|
|
10 //
|
|
|
11 //===----------------------------------------------------------------------===//
|
|
|
12
|
|
|
13 #include "RedundantStringCStrCheck.h"
|
|
|
14 #include "clang/Lex/Lexer.h"
|
|
|
15 #include "clang/Tooling/FixIt.h"
|
|
|
16
|
|
|
17 using namespace clang::ast_matchers;
|
|
|
18
|
|
|
19 namespace clang {
|
|
|
20 namespace tidy {
|
|
|
21 namespace readability {
|
|
|
22
|
|
|
23 namespace {
|
|
|
24
|
|
|
25 // Return true if expr needs to be put in parens when it is an argument of a
|
|
|
26 // prefix unary operator, e.g. when it is a binary or ternary operator
|
|
|
27 // syntactically.
|
|
|
28 bool needParensAfterUnaryOperator(const Expr &ExprNode) {
|
|
|
29 if (isa<clang::BinaryOperator>(&ExprNode) ||
|
|
|
30 isa<clang::ConditionalOperator>(&ExprNode)) {
|
|
|
31 return true;
|
|
|
32 }
|
|
|
33 if (const auto *Op = dyn_cast<CXXOperatorCallExpr>(&ExprNode)) {
|
|
|
34 return Op->getNumArgs() == 2 && Op->getOperator() != OO_PlusPlus &&
|
|
|
35 Op->getOperator() != OO_MinusMinus && Op->getOperator() != OO_Call &&
|
|
|
36 Op->getOperator() != OO_Subscript;
|
|
|
37 }
|
|
|
38 return false;
|
|
|
39 }
|
|
|
40
|
|
|
41 // Format a pointer to an expression: prefix with '*' but simplify
|
|
|
42 // when it already begins with '&'. Return empty string on failure.
|
|
|
43 std::string
|
|
|
44 formatDereference(const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
45 const Expr &ExprNode) {
|
|
|
46 if (const auto *Op = dyn_cast<clang::UnaryOperator>(&ExprNode)) {
|
|
|
47 if (Op->getOpcode() == UO_AddrOf) {
|
|
|
48 // Strip leading '&'.
|
|
|
49 return std::string(tooling::fixit::getText(
|
|
|
50 *Op->getSubExpr()->IgnoreParens(), *Result.Context));
|
|
|
51 }
|
|
|
52 }
|
|
|
53 StringRef Text = tooling::fixit::getText(ExprNode, *Result.Context);
|
|
|
54
|
|
|
55 if (Text.empty())
|
|
|
56 return std::string();
|
|
|
57 // Add leading '*'.
|
|
|
58 if (needParensAfterUnaryOperator(ExprNode)) {
|
|
|
59 return (llvm::Twine("*(") + Text + ")").str();
|
|
|
60 }
|
|
|
61 return (llvm::Twine("*") + Text).str();
|
|
|
62 }
|
|
|
63
|
|
173
|
64 AST_MATCHER(MaterializeTemporaryExpr, isBoundToLValue) {
|
|
|
65 return Node.isBoundToLvalueReference();
|
|
|
66 }
|
|
|
67
|
|
150
|
68 } // end namespace
|
|
|
69
|
|
|
70 void RedundantStringCStrCheck::registerMatchers(
|
|
|
71 ast_matchers::MatchFinder *Finder) {
|
|
|
72 // Match expressions of type 'string' or 'string*'.
|
|
|
73 const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
|
|
|
74 hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
|
|
|
75 const auto StringExpr =
|
|
|
76 expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
|
|
|
77
|
|
|
78 // Match string constructor.
|
|
|
79 const auto StringConstructorExpr = expr(anyOf(
|
|
|
80 cxxConstructExpr(argumentCountIs(1),
|
|
|
81 hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
|
|
|
82 cxxConstructExpr(
|
|
|
83 argumentCountIs(2),
|
|
|
84 hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
|
|
|
85 // If present, the second argument is the alloc object which must not
|
|
|
86 // be present explicitly.
|
|
|
87 hasArgument(1, cxxDefaultArgExpr()))));
|
|
|
88
|
|
|
89 // Match a call to the string 'c_str()' method.
|
|
|
90 const auto StringCStrCallExpr =
|
|
|
91 cxxMemberCallExpr(on(StringExpr.bind("arg")),
|
|
|
92 callee(memberExpr().bind("member")),
|
|
|
93 callee(cxxMethodDecl(hasAnyName("c_str", "data"))))
|
|
|
94 .bind("call");
|
|
221
|
95 const auto HasRValueTempParent =
|
|
|
96 hasParent(materializeTemporaryExpr(unless(isBoundToLValue())));
|
|
150
|
97 // Detect redundant 'c_str()' calls through a string constructor.
|
|
173
|
98 // If CxxConstructExpr is the part of some CallExpr we need to
|
|
|
99 // check that matched ParamDecl of the ancestor CallExpr is not rvalue.
|
|
|
100 Finder->addMatcher(
|
|
221
|
101 traverse(
|
|
|
102 TK_AsIs,
|
|
|
103 cxxConstructExpr(
|
|
|
104 StringConstructorExpr, hasArgument(0, StringCStrCallExpr),
|
|
|
105 unless(anyOf(HasRValueTempParent, hasParent(cxxBindTemporaryExpr(
|
|
|
106 HasRValueTempParent)))))),
|
|
173
|
107 this);
|
|
150
|
108
|
|
|
109 // Detect: 's == str.c_str()' -> 's == str'
|
|
|
110 Finder->addMatcher(
|
|
|
111 cxxOperatorCallExpr(
|
|
173
|
112 hasAnyOverloadedOperatorName("<", ">", ">=", "<=", "!=", "==", "+"),
|
|
150
|
113 anyOf(allOf(hasArgument(0, StringExpr),
|
|
|
114 hasArgument(1, StringCStrCallExpr)),
|
|
|
115 allOf(hasArgument(0, StringCStrCallExpr),
|
|
|
116 hasArgument(1, StringExpr)))),
|
|
|
117 this);
|
|
|
118
|
|
|
119 // Detect: 'dst += str.c_str()' -> 'dst += str'
|
|
|
120 // Detect: 's = str.c_str()' -> 's = str'
|
|
173
|
121 Finder->addMatcher(
|
|
|
122 cxxOperatorCallExpr(hasAnyOverloadedOperatorName("=", "+="),
|
|
|
123 hasArgument(0, StringExpr),
|
|
|
124 hasArgument(1, StringCStrCallExpr)),
|
|
|
125 this);
|
|
150
|
126
|
|
|
127 // Detect: 'dst.append(str.c_str())' -> 'dst.append(str)'
|
|
|
128 Finder->addMatcher(
|
|
|
129 cxxMemberCallExpr(on(StringExpr), callee(decl(cxxMethodDecl(hasAnyName(
|
|
|
130 "append", "assign", "compare")))),
|
|
|
131 argumentCountIs(1), hasArgument(0, StringCStrCallExpr)),
|
|
|
132 this);
|
|
|
133
|
|
|
134 // Detect: 'dst.compare(p, n, str.c_str())' -> 'dst.compare(p, n, str)'
|
|
|
135 Finder->addMatcher(
|
|
|
136 cxxMemberCallExpr(on(StringExpr),
|
|
|
137 callee(decl(cxxMethodDecl(hasName("compare")))),
|
|
|
138 argumentCountIs(3), hasArgument(2, StringCStrCallExpr)),
|
|
|
139 this);
|
|
|
140
|
|
|
141 // Detect: 'dst.find(str.c_str())' -> 'dst.find(str)'
|
|
|
142 Finder->addMatcher(
|
|
|
143 cxxMemberCallExpr(on(StringExpr),
|
|
|
144 callee(decl(cxxMethodDecl(hasAnyName(
|
|
|
145 "find", "find_first_not_of", "find_first_of",
|
|
|
146 "find_last_not_of", "find_last_of", "rfind")))),
|
|
|
147 anyOf(argumentCountIs(1), argumentCountIs(2)),
|
|
|
148 hasArgument(0, StringCStrCallExpr)),
|
|
|
149 this);
|
|
|
150
|
|
|
151 // Detect: 'dst.insert(pos, str.c_str())' -> 'dst.insert(pos, str)'
|
|
|
152 Finder->addMatcher(
|
|
|
153 cxxMemberCallExpr(on(StringExpr),
|
|
|
154 callee(decl(cxxMethodDecl(hasName("insert")))),
|
|
|
155 argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
|
|
|
156 this);
|
|
|
157
|
|
|
158 // Detect redundant 'c_str()' calls through a StringRef constructor.
|
|
|
159 Finder->addMatcher(
|
|
173
|
160 traverse(
|
|
221
|
161 TK_AsIs,
|
|
173
|
162 cxxConstructExpr(
|
|
|
163 // Implicit constructors of these classes are overloaded
|
|
|
164 // wrt. string types and they internally make a StringRef
|
|
|
165 // referring to the argument. Passing a string directly to
|
|
|
166 // them is preferred to passing a char pointer.
|
|
|
167 hasDeclaration(cxxMethodDecl(hasAnyName(
|
|
|
168 "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
|
|
|
169 argumentCountIs(1),
|
|
|
170 // The only argument must have the form x.c_str() or p->c_str()
|
|
|
171 // where the method is string::c_str(). StringRef also has
|
|
|
172 // a constructor from string which is more efficient (avoids
|
|
|
173 // strlen), so we can construct StringRef from the string
|
|
|
174 // directly.
|
|
|
175 hasArgument(0, StringCStrCallExpr))),
|
|
150
|
176 this);
|
|
|
177 }
|
|
|
178
|
|
|
179 void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
|
|
|
180 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
|
|
|
181 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
|
|
|
182 const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
|
|
|
183 bool Arrow = Member->isArrow();
|
|
|
184 // Replace the "call" node with the "arg" node, prefixed with '*'
|
|
|
185 // if the call was using '->' rather than '.'.
|
|
|
186 std::string ArgText =
|
|
|
187 Arrow ? formatDereference(Result, *Arg)
|
|
|
188 : tooling::fixit::getText(*Arg, *Result.Context).str();
|
|
|
189 if (ArgText.empty())
|
|
|
190 return;
|
|
|
191
|
|
|
192 diag(Call->getBeginLoc(), "redundant call to %0")
|
|
|
193 << Member->getMemberDecl()
|
|
|
194 << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
|
|
|
195 }
|
|
|
196
|
|
|
197 } // namespace readability
|
|
|
198 } // namespace tidy
|
|
|
199 } // namespace clang
|
