tools/clang/empty_string/EmptyStringConverter.cpp

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // This implements a Clang tool to convert all instances of std::string("") to
   6 // std::string(). The latter is more efficient (as std::string doesn't have to
   7 // take a copy of an empty string) and generates fewer instructions as well. It
   8 // should be run using the tools/clang/scripts/run_tool.py helper.
   9
  10 #include <memory>
  11 #include "clang/ASTMatchers/ASTMatchers.h"
  12 #include "clang/ASTMatchers/ASTMatchFinder.h"
  13 #include "clang/Basic/SourceManager.h"
  14 #include "clang/Frontend/FrontendActions.h"
  15 #include "clang/Tooling/CommonOptionsParser.h"
  16 #include "clang/Tooling/Refactoring.h"
  17 #include "clang/Tooling/Tooling.h"
  18 #include "llvm/Support/CommandLine.h"
  19
  20 using clang::ast_matchers::MatchFinder;
  21 using clang::ast_matchers::argumentCountIs;
  22 using clang::ast_matchers::bindTemporaryExpr;
  23 using clang::ast_matchers::constructorDecl;
  24 using clang::ast_matchers::constructExpr;
  25 using clang::ast_matchers::defaultArgExpr;
  26 using clang::ast_matchers::expr;
  27 using clang::ast_matchers::forEach;
  28 using clang::ast_matchers::has;
  29 using clang::ast_matchers::hasArgument;
  30 using clang::ast_matchers::hasDeclaration;
  31 using clang::ast_matchers::hasName;
  32 using clang::ast_matchers::id;
  33 using clang::ast_matchers::methodDecl;
  34 using clang::ast_matchers::newExpr;
  35 using clang::ast_matchers::ofClass;
  36 using clang::ast_matchers::stringLiteral;
  37 using clang::ast_matchers::varDecl;
  38 using clang::tooling::CommonOptionsParser;
  39 using clang::tooling::Replacement;
  40 using clang::tooling::Replacements;
  41
  42 namespace {
  43
  44 // Handles replacements for stack and heap-allocated instances, e.g.:
  45 // std::string a("");
  46 // std::string* b = new std::string("");
  47 class ConstructorCallback : public MatchFinder::MatchCallback {
  48  public:
  49   ConstructorCallback(Replacements* replacements)
  50       : replacements_(replacements) {}
  51
  52   virtual void run(const MatchFinder::MatchResult& result) override;
  53
  54  private:
  55   Replacements* const replacements_;
  56 };
  57
  58 // Handles replacements for invocations of std::string("") in an initializer
  59 // list.
  60 class InitializerCallback : public MatchFinder::MatchCallback {
  61  public:
  62   InitializerCallback(Replacements* replacements)
  63       : replacements_(replacements) {}
  64
  65   virtual void run(const MatchFinder::MatchResult& result) override;
  66
  67  private:
  68   Replacements* const replacements_;
  69 };
  70
  71 // Handles replacements for invocations of std::string("") in a temporary
  72 // context, e.g. FunctionThatTakesString(std::string("")). Note that this
  73 // handles implicits construction of std::string as well.
  74 class TemporaryCallback : public MatchFinder::MatchCallback {
  75  public:
  76   TemporaryCallback(Replacements* replacements) : replacements_(replacements) {}
  77
  78   virtual void run(const MatchFinder::MatchResult& result) override;
  79
  80  private:
  81   Replacements* const replacements_;
  82 };
  83
  84 class EmptyStringConverter {
  85  public:
  86   explicit EmptyStringConverter(Replacements* replacements)
  87       : constructor_callback_(replacements),
  88         initializer_callback_(replacements),
  89         temporary_callback_(replacements) {}
  90
  91   void SetupMatchers(MatchFinder* match_finder);
  92
  93  private:
  94   ConstructorCallback constructor_callback_;
  95   InitializerCallback initializer_callback_;
  96   TemporaryCallback temporary_callback_;
  97 };
  98
  99 void EmptyStringConverter::SetupMatchers(MatchFinder* match_finder) {
 100   const clang::ast_matchers::StatementMatcher& constructor_call =
 101       id("call",
 102          constructExpr(
 103              hasDeclaration(methodDecl(ofClass(hasName("std::basic_string")))),
 104              argumentCountIs(2),
 105              hasArgument(0, id("literal", stringLiteral())),
 106              hasArgument(1, defaultArgExpr())));
 107
 108   // Note that expr(has()) in the matcher is significant; the Clang AST wraps
 109   // calls to the std::string constructor with exprWithCleanups nodes. Without
 110   // the expr(has()) matcher, the first and last rules would not match anything!
 111   match_finder->addMatcher(varDecl(forEach(expr(has(constructor_call)))),
 112                            &constructor_callback_);
 113   match_finder->addMatcher(newExpr(has(constructor_call)),
 114                            &constructor_callback_);
 115   match_finder->addMatcher(bindTemporaryExpr(has(constructor_call)),
 116                            &temporary_callback_);
 117   match_finder->addMatcher(
 118       constructorDecl(forEach(expr(has(constructor_call)))),
 119       &initializer_callback_);
 120 }
 121
 122 void ConstructorCallback::run(const MatchFinder::MatchResult& result) {
 123   const clang::StringLiteral* literal =
 124       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
 125   if (literal->getLength() > 0)
 126     return;
 127
 128   const clang::CXXConstructExpr* call =
 129       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
 130   clang::CharSourceRange range =
 131       clang::CharSourceRange::getTokenRange(call->getParenOrBraceRange());
 132   replacements_->insert(Replacement(*result.SourceManager, range, ""));
 133 }
 134
 135 void InitializerCallback::run(const MatchFinder::MatchResult& result) {
 136   const clang::StringLiteral* literal =
 137       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
 138   if (literal->getLength() > 0)
 139     return;
 140
 141   const clang::CXXConstructExpr* call =
 142       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
 143   replacements_->insert(Replacement(*result.SourceManager, call, ""));
 144 }
 145
 146 void TemporaryCallback::run(const MatchFinder::MatchResult& result) {
 147   const clang::StringLiteral* literal =
 148       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
 149   if (literal->getLength() > 0)
 150     return;
 151
 152   const clang::CXXConstructExpr* call =
 153       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
 154   // Differentiate between explicit and implicit calls to std::string's
 155   // constructor. An implicitly generated constructor won't have a valid
 156   // source range for the parenthesis. We do this because the matched expression
 157   // for |call| in the explicit case doesn't include the closing parenthesis.
 158   clang::SourceRange range = call->getParenOrBraceRange();
 159   if (range.isValid()) {
 160     replacements_->insert(Replacement(*result.SourceManager, literal, ""));
 161   } else {
 162     replacements_->insert(
 163         Replacement(*result.SourceManager,
 164                     call,
 165                     literal->isWide() ? "std::wstring()" : "std::string()"));
 166   }
 167 }
 168
 169 }  // namespace
 170
 171 static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 172
 173 int main(int argc, const char* argv[]) {
 174   llvm::cl::OptionCategory category("EmptyString Tool");
 175   CommonOptionsParser options(argc, argv, category);
 176   clang::tooling::ClangTool tool(options.getCompilations(),
 177                                  options.getSourcePathList());
 178
 179   Replacements replacements;
 180   EmptyStringConverter converter(&replacements);
 181   MatchFinder match_finder;
 182   converter.SetupMatchers(&match_finder);
 183
 184   std::unique_ptr<clang::tooling::FrontendActionFactory> frontend_factory =
 185       clang::tooling::newFrontendActionFactory(&match_finder);
 186   int result = tool.run(frontend_factory.get());
 187   if (result != 0)
 188     return result;
 189
 190   // Each replacement line should have the following format:
 191   // r:<file path>:<offset>:<length>:<replacement text>
 192   // Only the <replacement text> field can contain embedded ":" characters.
 193   // TODO(dcheng): Use a more clever serialization. Ideally we'd use the YAML
 194   // serialization and then use clang-apply-replacements, but that would require
 195   // copying and pasting a larger amount of boilerplate for all Chrome clang
 196   // tools.
 197   llvm::outs() << "==== BEGIN EDITS ====\n";
 198   for (const auto& r : replacements) {
 199     llvm::outs() << "r:" << r.getFilePath() << ":" << r.getOffset() << ":"
 200                  << r.getLength() << ":" << r.getReplacementText() << "\n";
 201   }
 202   llvm::outs() << "==== END EDITS ====\n";
 203
 204   return 0;
 205 }