clang-tools  14.0.0git
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 
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 AST_MATCHER(MaterializeTemporaryExpr, isBoundToLValue) {
65  return Node.isBoundToLvalueReference();
66 }
67 
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");
95  const auto HasRValueTempParent =
96  hasParent(materializeTemporaryExpr(unless(isBoundToLValue())));
97  // Detect redundant 'c_str()' calls through a string constructor.
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(
101  traverse(
102  TK_AsIs,
103  cxxConstructExpr(
104  StringConstructorExpr, hasArgument(0, StringCStrCallExpr),
105  unless(anyOf(HasRValueTempParent, hasParent(cxxBindTemporaryExpr(
106  HasRValueTempParent)))))),
107  this);
108 
109  // Detect: 's == str.c_str()' -> 's == str'
110  Finder->addMatcher(
111  cxxOperatorCallExpr(
112  hasAnyOverloadedOperatorName("<", ">", ">=", "<=", "!=", "==", "+"),
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'
121  Finder->addMatcher(
122  cxxOperatorCallExpr(hasAnyOverloadedOperatorName("=", "+="),
123  hasArgument(0, StringExpr),
124  hasArgument(1, StringCStrCallExpr)),
125  this);
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(
160  traverse(
161  TK_AsIs,
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))),
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
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::tidy::modernize::getText
static StringRef getText(const Token &Tok, const SourceManager &Sources)
Definition: UseOverrideCheck.cpp:78
clang::ast_matchers
Definition: AbseilMatcher.h:14
RedundantStringCStrCheck.h
clang::ast_matchers::AST_MATCHER
AST_MATCHER(Expr, isMacroID)
Definition: PreferIsaOrDynCastInConditionalsCheck.cpp:19
clang::clangd::check
bool check(llvm::StringRef File, llvm::function_ref< bool(const Position &)> ShouldCheckLine, const ThreadsafeFS &TFS, const ClangdLSPServer::Options &Opts, bool EnableCodeCompletion)
Definition: Check.cpp:258
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27