clang-tools 10.0.0

RedundantStringCStrCheck.cpp
Go to the documentation of this file.
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 tooling::fixit::getText(*Op->getSubExpr()->IgnoreParens(),
50 *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
64 } // end namespace
65
66 void RedundantStringCStrCheck::registerMatchers(
67 ast_matchers::MatchFinder *Finder) {
68 // Only register the matchers for C++; the functionality currently does not
69 // provide any benefit to other languages, despite being benign.
70 if (!getLangOpts().CPlusPlus)
71 return;
72
73 // Match expressions of type 'string' or 'string*'.
74 const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
75 hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
76 const auto StringExpr =
77 expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
78
79 // Match string constructor.
80 const auto StringConstructorExpr = expr(anyOf(
81 cxxConstructExpr(argumentCountIs(1),
82 hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
83 cxxConstructExpr(
84 argumentCountIs(2),
85 hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
86 // If present, the second argument is the alloc object which must not
87 // be present explicitly.
88 hasArgument(1, cxxDefaultArgExpr()))));
89
90 // Match a call to the string 'c_str()' method.
91 const auto StringCStrCallExpr =
92 cxxMemberCallExpr(on(StringExpr.bind("arg")),
93 callee(memberExpr().bind("member")),
94 callee(cxxMethodDecl(hasAnyName("c_str", "data"))))
95 .bind("call");
96
97 // Detect redundant 'c_str()' calls through a string constructor.
98 Finder->addMatcher(cxxConstructExpr(StringConstructorExpr,
99 hasArgument(0, StringCStrCallExpr)),
100 this);
101
102 // Detect: 's == str.c_str()' -> 's == str'
103 Finder->addMatcher(
104 cxxOperatorCallExpr(
105 anyOf(
106 hasOverloadedOperatorName("<"), hasOverloadedOperatorName(">"),
107 hasOverloadedOperatorName(">="), hasOverloadedOperatorName("<="),
108 hasOverloadedOperatorName("!="), hasOverloadedOperatorName("=="),
109 hasOverloadedOperatorName("+")),
110 anyOf(allOf(hasArgument(0, StringExpr),
111 hasArgument(1, StringCStrCallExpr)),
112 allOf(hasArgument(0, StringCStrCallExpr),
113 hasArgument(1, StringExpr)))),
114 this);
115
116 // Detect: 'dst += str.c_str()' -> 'dst += str'
117 // Detect: 's = str.c_str()' -> 's = str'
118 Finder->addMatcher(cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("="),
119 hasOverloadedOperatorName("+=")),
120 hasArgument(0, StringExpr),
121 hasArgument(1, StringCStrCallExpr)),
122 this);
123
124 // Detect: 'dst.append(str.c_str())' -> 'dst.append(str)'
125 Finder->addMatcher(
126 cxxMemberCallExpr(on(StringExpr), callee(decl(cxxMethodDecl(hasAnyName(
127 "append", "assign", "compare")))),
128 argumentCountIs(1), hasArgument(0, StringCStrCallExpr)),
129 this);
130
131 // Detect: 'dst.compare(p, n, str.c_str())' -> 'dst.compare(p, n, str)'
132 Finder->addMatcher(
133 cxxMemberCallExpr(on(StringExpr),
134 callee(decl(cxxMethodDecl(hasName("compare")))),
135 argumentCountIs(3), hasArgument(2, StringCStrCallExpr)),
136 this);
137
138 // Detect: 'dst.find(str.c_str())' -> 'dst.find(str)'
139 Finder->addMatcher(
140 cxxMemberCallExpr(on(StringExpr),
141 callee(decl(cxxMethodDecl(hasAnyName(
142 "find", "find_first_not_of", "find_first_of",
143 "find_last_not_of", "find_last_of", "rfind")))),
144 anyOf(argumentCountIs(1), argumentCountIs(2)),
145 hasArgument(0, StringCStrCallExpr)),
146 this);
147
148 // Detect: 'dst.insert(pos, str.c_str())' -> 'dst.insert(pos, str)'
149 Finder->addMatcher(
150 cxxMemberCallExpr(on(StringExpr),
151 callee(decl(cxxMethodDecl(hasName("insert")))),
152 argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
153 this);
154
155 // Detect redundant 'c_str()' calls through a StringRef constructor.
156 Finder->addMatcher(
157 cxxConstructExpr(
158 // Implicit constructors of these classes are overloaded
159 // wrt. string types and they internally make a StringRef
160 // referring to the argument. Passing a string directly to
161 // them is preferred to passing a char pointer.
162 hasDeclaration(cxxMethodDecl(hasAnyName(
163 "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
164 argumentCountIs(1),
165 // The only argument must have the form x.c_str() or p->c_str()
166 // where the method is string::c_str(). StringRef also has
167 // a constructor from string which is more efficient (avoids
168 // strlen), so we can construct StringRef from the string
169 // directly.
170 hasArgument(0, StringCStrCallExpr)),
171 this);
172 }
173
174 void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
175 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
176 const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
177 const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
178 bool Arrow = Member->isArrow();
179 // Replace the "call" node with the "arg" node, prefixed with '*'
180 // if the call was using '->' rather than '.'.
181 std::string ArgText =
182 Arrow ? formatDereference(Result, *Arg)
183 : tooling::fixit::getText(*Arg, *Result.Context).str();
184 if (ArgText.empty())
185 return;
186
187 diag(Call->getBeginLoc(), "redundant call to %0")
188 << Member->getMemberDecl()
189 << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
190 }
191
192 } // namespace readability
193 } // namespace tidy
194 } // namespace clang
clang::ast_matchers
Definition: AbseilMatcher.h:14
Text
std::string Text
Definition: HTMLGenerator.cpp:80
RedundantStringCStrCheck.h
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27