Fix bitrot in Chrome clang tool infrastructure.

tools/clang/empty_string/EmptyStringConverter.cpp

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This implements a Clang tool to convert all instances of std::string("") to
 // std::string(). The latter is more efficient (as std::string doesn't have to
 // take a copy of an empty string) and generates fewer instructions as well. It
 // should be run using the tools/clang/scripts/run_tool.py helper.
 
+#include <memory>
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 
 using clang::ast_matchers::MatchFinder;
@@ skipping 21 matching lines @@
 namespace {
 
 // Handles replacements for stack and heap-allocated instances, e.g.:
 // std::string a("");
 // std::string* b = new std::string("");
 class ConstructorCallback : public MatchFinder::MatchCallback {
  public:
   ConstructorCallback(Replacements* replacements)
       : replacements_(replacements) {}
 
-  virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
+  virtual void run(const MatchFinder::MatchResult& result) override;
 
  private:
   Replacements* const replacements_;
 };
 
 // Handles replacements for invocations of std::string("") in an initializer
 // list.
 class InitializerCallback : public MatchFinder::MatchCallback {
  public:
   InitializerCallback(Replacements* replacements)
       : replacements_(replacements) {}
 
-  virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
+  virtual void run(const MatchFinder::MatchResult& result) override;
 
  private:
   Replacements* const replacements_;
 };
 
 // Handles replacements for invocations of std::string("") in a temporary
 // context, e.g. FunctionThatTakesString(std::string("")). Note that this
 // handles implicits construction of std::string as well.
 class TemporaryCallback : public MatchFinder::MatchCallback {
  public:
   TemporaryCallback(Replacements* replacements) : replacements_(replacements) {}
 
-  virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
+  virtual void run(const MatchFinder::MatchResult& result) override;
 
  private:
   Replacements* const replacements_;
 };
 
 class EmptyStringConverter {
  public:
   explicit EmptyStringConverter(Replacements* replacements)
       : constructor_callback_(replacements),
         initializer_callback_(replacements),
@@ skipping 32 matching lines @@
 
 void ConstructorCallback::run(const MatchFinder::MatchResult& result) {
   const clang::StringLiteral* literal =
       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
   if (literal->getLength() > 0)
     return;
 
   const clang::CXXConstructExpr* call =
       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
   clang::CharSourceRange range =
-      clang::CharSourceRange::getTokenRange(call->getParenRange());
+      clang::CharSourceRange::getTokenRange(call->getParenOrBraceRange());
   replacements_->insert(Replacement(*result.SourceManager, range, ""));
 }
 
 void InitializerCallback::run(const MatchFinder::MatchResult& result) {
   const clang::StringLiteral* literal =
       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
   if (literal->getLength() > 0)
     return;
 
   const clang::CXXConstructExpr* call =
       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
   replacements_->insert(Replacement(*result.SourceManager, call, ""));
 }
 
 void TemporaryCallback::run(const MatchFinder::MatchResult& result) {
   const clang::StringLiteral* literal =
       result.Nodes.getNodeAs<clang::StringLiteral>("literal");
   if (literal->getLength() > 0)
     return;
 
   const clang::CXXConstructExpr* call =
       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
   // Differentiate between explicit and implicit calls to std::string's
   // constructor. An implicitly generated constructor won't have a valid
   // source range for the parenthesis. We do this because the matched expression
   // for |call| in the explicit case doesn't include the closing parenthesis.
-  clang::SourceRange range = call->getParenRange();
+  clang::SourceRange range = call->getParenOrBraceRange();
   if (range.isValid()) {
     replacements_->insert(Replacement(*result.SourceManager, literal, ""));
   } else {
     replacements_->insert(
         Replacement(*result.SourceManager,
                     call,
                     literal->isWide() ? "std::wstring()" : "std::string()"));
   }
 }
 
 }  // namespace
 
 static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 
 int main(int argc, const char* argv[]) {
-  CommonOptionsParser options(argc, argv);
+  llvm::cl::OptionCategory category("EmptyString Tool");
+  CommonOptionsParser options(argc, argv, category);
   clang::tooling::ClangTool tool(options.getCompilations(),
                                  options.getSourcePathList());
 
   Replacements replacements;
   EmptyStringConverter converter(&replacements);
   MatchFinder match_finder;
   converter.SetupMatchers(&match_finder);
 
-  int result =
-      tool.run(clang::tooling::newFrontendActionFactory(&match_finder));
+  std::unique_ptr<clang::tooling::FrontendActionFactory> frontend_factory =
+      clang::tooling::newFrontendActionFactory(&match_finder);

[Nico, 2014/08/06 18:15:56]

Does c++11 library stuff work in tools? Does the build system set the rpath
right, or does the tool runner need to set LD_LIBRARY_PATH to let the tool find
libstdc++ 4.8 on linux (when running on Precise)?

[dcheng, 2014/08/06 20:06:54]

The build system expects a "modern" C++ library to be installed and setup
correctly:

checking whether Clang will select a modern C++ standard library... no
configure: error:
We detected a missing feature in the standard C++ library that was known to be
missing in libstdc++4.6 and implemented in libstdc++4.7. There are numerous
C++11 problems with 4.6's library, and we don't support GCCs or libstdc++ older
than 4.7. You will need to update your system and ensure Clang uses the newer
standard library.

So I think it will just work as long as the dependencies are correctly set up.

+  int result = tool.run(frontend_factory.get());
   if (result != 0)
     return result;
 
   // Each replacement line should have the following format:
   // r:<file path>:<offset>:<length>:<replacement text>
   // Only the <replacement text> field can contain embedded ":" characters.
-  // TODO(dcheng): Use a more clever serialization.
+  // TODO(dcheng): Use a more clever serialization. Ideally we'd use the YAML
+  // serialization and then use clang-apply-replacements, but that would require
+  // copying and pasting a larger amount of boilerplate for all Chrome clang
+  // tools.
   llvm::outs() << "==== BEGIN EDITS ====\n";
-  for (Replacements::const_iterator it = replacements.begin();
-       it != replacements.end(); ++it) {
-    llvm::outs() << "r:" << it->getFilePath() << ":" << it->getOffset() << ":"
-                 << it->getLength() << ":" << it->getReplacementText() << "\n";
+  for (const auto& r : replacements) {
+    llvm::outs() << "r:" << r.getFilePath() << ":" << r.getOffset() << ":"
+                 << r.getLength() << ":" << r.getReplacementText() << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }