OLD | NEW |
(Empty) | |
| 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 } |
OLD | NEW |