Add clang tool to rewrite scoped_array<T> to scoped_ptr<T[]>.

tools/clang/rewrite_scoped_array/RewriteScopedArray.cpp

Index: tools/clang/rewrite_scoped_array/RewriteScopedArray.cpp
diff --git a/tools/clang/rewrite_scoped_array/RewriteScopedArray.cpp b/tools/clang/rewrite_scoped_array/RewriteScopedArray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0feb3a77f68735ac2895796a812ee0176d7ded38
--- /dev/null
+++ b/tools/clang/rewrite_scoped_array/RewriteScopedArray.cpp
@@ -0,0 +1,110 @@
+// 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 rewrite all instances of scoped_array<T> to
+// scoped_ptr<T[]>. The former is being deprecated in favor of the latter, to
+// allow for an eventual transition from scoped_ptr to unique_ptr.
+
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Lex/Lexer.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;
+using clang::ast_matchers::hasDeclaration;
+using clang::ast_matchers::hasName;
+using clang::ast_matchers::id;
+using clang::ast_matchers::loc;
+using clang::ast_matchers::qualType;
+using clang::ast_matchers::recordDecl;
+using clang::tooling::CommonOptionsParser;
+using clang::tooling::Replacement;
+using clang::tooling::Replacements;
+using llvm::StringRef;
+
+namespace {
+
+class RewriterCallback : public MatchFinder::MatchCallback {
+ public:
+  RewriterCallback(Replacements* replacements) : replacements_(replacements) {}
+  virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
+
+ private:
+  Replacements* const replacements_;
+};
+
+class ScopedArrayRewriter {
+ public:
+  explicit ScopedArrayRewriter(Replacements* replacements)
+      : callback_(replacements) {}
+
+  void SetupMatchers(MatchFinder* match_finder);
+
+ private:
+  RewriterCallback callback_;
+};

[Nico, 2013/04/06 04:24:26]

Does this class add anything? Can't you dod the one call to addMatcher()
directly in main()?

[dcheng, 2013/04/06 04:33:37]

In theory, it makes this more testable in case I update the tool driver to be
written in C++. In practice, I guess it doesn't really matter and I'll just fold
this into main().

+
+void ScopedArrayRewriter::SetupMatchers(MatchFinder* match_finder) {
+  match_finder->addMatcher(
+      id("loc",
+         loc(qualType(hasDeclaration(recordDecl(hasName("::scoped_array")))))),
+      &callback_);
+}
+
+void RewriterCallback::run(const MatchFinder::MatchResult& result) {
+  const clang::TypeLoc type_location =
+      *result.Nodes.getNodeAs<clang::TypeLoc>("loc");
+  clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(
+      result.SourceManager->getSpellingLoc(type_location.getLocStart()),
+      result.SourceManager->getSpellingLoc(type_location.getLocEnd()));
+  // TODO(dcheng): Log an error?
+  if (!range.isValid())
+    return;
+  std::string replacement_text = clang::Lexer::getSourceText(
+      range, *result.SourceManager, result.Context->getLangOpts());
+  // TODO(dcheng): Log errors?
+  if (!StringRef(replacement_text).startswith("scoped_array<") ||

[Nico, 2013/04/06 04:24:26]

This will ignore code with spaces or newlines between "scoped_array" and "<".
(Probably doesn't matter.)

[dcheng, 2013/04/06 04:33:37]

Yeah. I'm assuming that's not going to a very common case.

+      !StringRef(replacement_text).endswith(">"))
+    return;
+  replacement_text.replace(strlen("scoped_"), strlen("array"), "ptr");
+  replacement_text.insert(replacement_text.size() - 1, "[]");

[Nico, 2013/04/06 04:24:26]

This might not work if the type comes from a typeof
(`scoped_array<typeof(sin(4))>`) or from a macro, but I guess it's good enough
in practice.

[dcheng, 2013/04/06 04:33:37]

What typically happens is it emits multiple replacements for the same location.
This results in various syntax errors when trying to build the result, so it's
generally not undetected.

In the future, I'd like to add a facility for detecting conflicting rewrites in
run_tool.py to make these even more obvious.

+  replacements_->insert(
+      Replacement(*result.SourceManager, range, replacement_text));
+}
+
+}  // namespace
+
+static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
+
+int main(int argc, const char* argv[]) {
+  CommonOptionsParser options(argc, argv);
+  clang::tooling::ClangTool tool(options.getCompilations(),
+                                 options.getSourcePathList());
+
+  Replacements replacements;
+  ScopedArrayRewriter rewriter(&replacements);
+  MatchFinder match_finder;
+  rewriter.SetupMatchers(&match_finder);
+
+  int result =
+      tool.run(clang::tooling::newFrontendActionFactory(&match_finder));
+  if (result != 0)
+    return result;
+
+  // Serialization format is documented in tools/clang/scripts/run_tool.py
+  llvm::outs() << "==== BEGIN EDITS ====\n";
+  for (const Replacement& r : replacements) {
+    llvm::outs() << "r:" << r.getFilePath() << ":" << r.getOffset() << ":"
+                 << r.getLength() << ":" << r.getReplacementText() << "\n";
+  }
+  llvm::outs() << "==== END EDITS ====\n";
+
+  return 0;
+}