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 
64 // Trying to get CallExpr in which CxxConstructExpr is called.
65 static const clang::CallExpr *
66 tryGetCallExprAncestorForCxxConstructExpr(const Expr *TheExpr,
67                                           ASTContext &Context) {
68   // We skip nodes such as CXXBindTemporaryExpr, MaterializeTemporaryExpr.
69   for (ast_type_traits::DynTypedNode DynParent : Context.getParents(*TheExpr)) {
70     if (const auto *Parent = DynParent.get<Expr>()) {
71       if (const auto *TheCallExpr = dyn_cast<CallExpr>(Parent))
72         return TheCallExpr;
73 
74       if (const clang::CallExpr *TheCallExpr =
75               tryGetCallExprAncestorForCxxConstructExpr(Parent, Context))
76         return TheCallExpr;
77     }
78   }
79 
80   return nullptr;
81 }
82 
83 // Check that ParamDecl of CallExprDecl has rvalue type.
84 static bool checkParamDeclOfAncestorCallExprHasRValueRefType(
85     const Expr *TheCxxConstructExpr, ASTContext &Context) {
86   if (const clang::CallExpr *TheCallExpr =
87           tryGetCallExprAncestorForCxxConstructExpr(TheCxxConstructExpr,
88                                                     Context)) {
89     for (unsigned i = 0; i < TheCallExpr->getNumArgs(); ++i) {
90       const Expr *Arg = TheCallExpr->getArg(i);
91       if (Arg->getSourceRange() == TheCxxConstructExpr->getSourceRange()) {
92         if (const auto *TheCallExprFuncProto =
93                 TheCallExpr->getCallee()
94                     ->getType()
95                     ->getPointeeType()
96                     ->getAs<FunctionProtoType>()) {
97           if (TheCallExprFuncProto->getParamType(i)->isRValueReferenceType())
98             return true;
99         }
100       }
101     }
102   }
103 
104   return false;
105 }
106 
107 AST_MATCHER(CXXConstructExpr,
108             matchedParamDeclOfAncestorCallExprHasRValueRefType) {
109   return checkParamDeclOfAncestorCallExprHasRValueRefType(
110       &Node, Finder->getASTContext());
111 }
112 
113 } // end namespace
114 
115 void RedundantStringCStrCheck::registerMatchers(
116     ast_matchers::MatchFinder *Finder) {
117   // Match expressions of type 'string' or 'string*'.
118   const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
119       hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
120   const auto StringExpr =
121       expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
122 
123   // Match string constructor.
124   const auto StringConstructorExpr = expr(anyOf(
125       cxxConstructExpr(argumentCountIs(1),
126                        hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
127       cxxConstructExpr(
128           argumentCountIs(2),
129           hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
130           // If present, the second argument is the alloc object which must not
131           // be present explicitly.
132           hasArgument(1, cxxDefaultArgExpr()))));
133 
134   // Match a call to the string 'c_str()' method.
135   const auto StringCStrCallExpr =
136       cxxMemberCallExpr(on(StringExpr.bind("arg")),
137                         callee(memberExpr().bind("member")),
138                         callee(cxxMethodDecl(hasAnyName("c_str", "data"))))
139           .bind("call");
140 
141   // Detect redundant 'c_str()' calls through a string constructor.
142   // If CxxConstructExpr is the part of some CallExpr we need to
143   // check that matched ParamDecl of the ancestor CallExpr is not rvalue.
144   Finder->addMatcher(
145       cxxConstructExpr(
146           StringConstructorExpr, hasArgument(0, StringCStrCallExpr),
147           unless(matchedParamDeclOfAncestorCallExprHasRValueRefType())),
148       this);
149 
150   // Detect: 's == str.c_str()'  ->  's == str'
151   Finder->addMatcher(
152       cxxOperatorCallExpr(
153           hasAnyOverloadedOperatorName("<", ">", ">=", "<=", "!=", "==", "+"),
154           anyOf(allOf(hasArgument(0, StringExpr),
155                       hasArgument(1, StringCStrCallExpr)),
156                 allOf(hasArgument(0, StringCStrCallExpr),
157                       hasArgument(1, StringExpr)))),
158       this);
159 
160   // Detect: 'dst += str.c_str()'  ->  'dst += str'
161   // Detect: 's = str.c_str()'  ->  's = str'
162   Finder->addMatcher(
163       cxxOperatorCallExpr(hasAnyOverloadedOperatorName("=", "+="),
164                           hasArgument(0, StringExpr),
165                           hasArgument(1, StringCStrCallExpr)),
166       this);
167 
168   // Detect: 'dst.append(str.c_str())'  ->  'dst.append(str)'
169   Finder->addMatcher(
170       cxxMemberCallExpr(on(StringExpr), callee(decl(cxxMethodDecl(hasAnyName(
171                                             "append", "assign", "compare")))),
172                         argumentCountIs(1), hasArgument(0, StringCStrCallExpr)),
173       this);
174 
175   // Detect: 'dst.compare(p, n, str.c_str())'  ->  'dst.compare(p, n, str)'
176   Finder->addMatcher(
177       cxxMemberCallExpr(on(StringExpr),
178                         callee(decl(cxxMethodDecl(hasName("compare")))),
179                         argumentCountIs(3), hasArgument(2, StringCStrCallExpr)),
180       this);
181 
182   // Detect: 'dst.find(str.c_str())'  ->  'dst.find(str)'
183   Finder->addMatcher(
184       cxxMemberCallExpr(on(StringExpr),
185                         callee(decl(cxxMethodDecl(hasAnyName(
186                             "find", "find_first_not_of", "find_first_of",
187                             "find_last_not_of", "find_last_of", "rfind")))),
188                         anyOf(argumentCountIs(1), argumentCountIs(2)),
189                         hasArgument(0, StringCStrCallExpr)),
190       this);
191 
192   // Detect: 'dst.insert(pos, str.c_str())'  ->  'dst.insert(pos, str)'
193   Finder->addMatcher(
194       cxxMemberCallExpr(on(StringExpr),
195                         callee(decl(cxxMethodDecl(hasName("insert")))),
196                         argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
197       this);
198 
199   // Detect redundant 'c_str()' calls through a StringRef constructor.
200   Finder->addMatcher(
201       cxxConstructExpr(
202           // Implicit constructors of these classes are overloaded
203           // wrt. string types and they internally make a StringRef
204           // referring to the argument.  Passing a string directly to
205           // them is preferred to passing a char pointer.
206           hasDeclaration(cxxMethodDecl(hasAnyName(
207               "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
208           argumentCountIs(1),
209           // The only argument must have the form x.c_str() or p->c_str()
210           // where the method is string::c_str().  StringRef also has
211           // a constructor from string which is more efficient (avoids
212           // strlen), so we can construct StringRef from the string
213           // directly.
214           hasArgument(0, StringCStrCallExpr)),
215       this);
216 }
217 
218 void RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
219   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
220   const auto *Arg = Result.Nodes.getNodeAs<Expr>("arg");
221   const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
222   bool Arrow = Member->isArrow();
223   // Replace the "call" node with the "arg" node, prefixed with '*'
224   // if the call was using '->' rather than '.'.
225   std::string ArgText =
226       Arrow ? formatDereference(Result, *Arg)
227             : tooling::fixit::getText(*Arg, *Result.Context).str();
228   if (ArgText.empty())
229     return;
230 
231   diag(Call->getBeginLoc(), "redundant call to %0")
232       << Member->getMemberDecl()
233       << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
234 }
235 
236 } // namespace readability
237 } // namespace tidy
238 } // namespace clang
239