Tool to fix calls to scoped_ptr<T>(NULL) to use the default ctor instead

tools/clang/rewrite_scoped_ptr_ctor_null/RewriteScopedPtrCtorNull.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 "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;
 using clang::ast_matchers::argumentCountIs;
 using clang::ast_matchers::bindTemporaryExpr;
 using clang::ast_matchers::constructorDecl;
 using clang::ast_matchers::constructExpr;
-using clang::ast_matchers::defaultArgExpr;
 using clang::ast_matchers::expr;
 using clang::ast_matchers::forEach;
 using clang::ast_matchers::has;
 using clang::ast_matchers::hasArgument;
 using clang::ast_matchers::hasDeclaration;
-using clang::ast_matchers::hasName;
+using clang::ast_matchers::matchesName;
 using clang::ast_matchers::id;
 using clang::ast_matchers::methodDecl;
 using clang::ast_matchers::newExpr;
 using clang::ast_matchers::ofClass;
-using clang::ast_matchers::stringLiteral;
 using clang::ast_matchers::varDecl;
 using clang::tooling::CommonOptionsParser;
 using clang::tooling::Replacement;
 using clang::tooling::Replacements;
 
 namespace {
 
+bool IsNullConstant(const clang::Expr& expr, clang::ASTContext* context) {
+  return expr.isNullPointerConstant(*context,
+                                    clang::Expr::NPC_ValueDependentIsNotNull) !=
+         clang::Expr::NPCK_NotNull;
+}
+
 // Handles replacements for stack and heap-allocated instances, e.g.:
-// std::string a("");
-// std::string* b = new std::string("");
+// scoped_ptr<T> a(NULL);
+// scoped_ptr<T>* b = new scoped_ptr<T>(NULL);
+// ...though the latter should be pretty rare.
 class ConstructorCallback : public MatchFinder::MatchCallback {
  public:
   ConstructorCallback(Replacements* replacements)
       : replacements_(replacements) {}
 
   virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
 
  private:
   Replacements* const replacements_;
 };
 
-// Handles replacements for invocations of std::string("") in an initializer
+// Handles replacements for invocations of scoped_ptr<T>(NULL) in an initializer
 // list.
 class InitializerCallback : public MatchFinder::MatchCallback {
  public:
   InitializerCallback(Replacements* replacements)
       : replacements_(replacements) {}
 
   virtual void run(const MatchFinder::MatchResult& result) LLVM_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.
+// Handles replacements for invocations of scoped_ptr<T>(NULL) in a temporary
+// context, e.g. return scoped_ptr<T>(NULL).
 class TemporaryCallback : public MatchFinder::MatchCallback {
  public:
   TemporaryCallback(Replacements* replacements) : replacements_(replacements) {}
 
   virtual void run(const MatchFinder::MatchResult& result) LLVM_OVERRIDE;
 
  private:
   Replacements* const replacements_;
 };
 
 class EmptyStringConverter {
  public:
   explicit EmptyStringConverter(Replacements* replacements)
       : constructor_callback_(replacements),
         initializer_callback_(replacements),
         temporary_callback_(replacements) {}
 
   void SetupMatchers(MatchFinder* match_finder);
 
  private:
   ConstructorCallback constructor_callback_;
   InitializerCallback initializer_callback_;
   TemporaryCallback temporary_callback_;
 };
 
 void EmptyStringConverter::SetupMatchers(MatchFinder* match_finder) {
-  const clang::ast_matchers::StatementMatcher& constructor_call =
-      id("call",
-         constructExpr(
-             hasDeclaration(methodDecl(ofClass(hasName("std::basic_string")))),
-             argumentCountIs(2),
-             hasArgument(0, id("literal", stringLiteral())),
-             hasArgument(1, defaultArgExpr())));
+  const char kPattern[] = "^::(scoped_ptr|scoped_ptr_malloc)$";
+  const clang::ast_matchers::StatementMatcher& constructor_call = id(
+      "call",
+      constructExpr(hasDeclaration(methodDecl(ofClass(matchesName(kPattern)))),
+                    argumentCountIs(1),
+                    hasArgument(0, id("arg", expr()))));
 
-  // Note that expr(has()) in the matcher is significant; the Clang AST wraps
-  // calls to the std::string constructor with exprWithCleanups nodes. Without
-  // the expr(has()) matcher, the first and last rules would not match anything!
-  match_finder->addMatcher(varDecl(forEach(expr(has(constructor_call)))),
+  match_finder->addMatcher(varDecl(forEach(constructor_call)),
                            &constructor_callback_);
   match_finder->addMatcher(newExpr(has(constructor_call)),
                            &constructor_callback_);
   match_finder->addMatcher(bindTemporaryExpr(has(constructor_call)),
                            &temporary_callback_);
-  match_finder->addMatcher(
-      constructorDecl(forEach(expr(has(constructor_call)))),
-      &initializer_callback_);
+  match_finder->addMatcher(constructorDecl(forEach(constructor_call)),
+                           &initializer_callback_);
 }
 
 void ConstructorCallback::run(const MatchFinder::MatchResult& result) {
-  const clang::StringLiteral* literal =
-      result.Nodes.getNodeAs<clang::StringLiteral>("literal");
-  if (literal->getLength() > 0)
+  const clang::Expr* arg = result.Nodes.getNodeAs<clang::Expr>("arg");
+  if (!IsNullConstant(*arg, result.Context))
     return;
 
   const clang::CXXConstructExpr* call =
       result.Nodes.getNodeAs<clang::CXXConstructExpr>("call");
   clang::CharSourceRange range =
       clang::CharSourceRange::getTokenRange(call->getParenRange());
   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)
+  const clang::Expr* arg = result.Nodes.getNodeAs<clang::Expr>("arg");
+  if (!IsNullConstant(*arg, result.Context))
     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)
+  const clang::Expr* arg = result.Nodes.getNodeAs<clang::Expr>("arg");
+  if (!IsNullConstant(*arg, result.Context))
     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();
-  if (range.isValid()) {
-    replacements_->insert(Replacement(*result.SourceManager, literal, ""));
-  } else {
-    replacements_->insert(
-        Replacement(*result.SourceManager,
-                    call,
-                    literal->isWide() ? "std::wstring()" : "std::string()"));
-  }
+  // TODO(dcheng): File a bug with clang. There should be an easier way to do
+  // this replacement, but getTokenRange(call->getParenRange()) and the obvious
+  // (but incorrect) arg both don't work. The former is presumably just buggy,
+  // while the latter probably has to do with the fact that NULL is actually a
+  // macro which expands to a built-in.
+  clang::SourceRange range = arg->getSourceRange();
+  clang::SourceRange expansion_range(
+      result.SourceManager->getExpansionLoc(range.getBegin()),
+      result.SourceManager->getExpansionLoc(range.getEnd()));
+  replacements_->insert(
+      Replacement(*result.SourceManager,
+                  clang::CharSourceRange::getTokenRange(expansion_range),
+                  ""));
 }
 
 }  // 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;
   EmptyStringConverter converter(&replacements);
   MatchFinder match_finder;
   converter.SetupMatchers(&match_finder);
 
   int result =
       tool.run(clang::tooling::newFrontendActionFactory(&match_finder));
   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.
   llvm::outs() << "==== BEGIN EDITS ====\n";
   for (Replacements::const_iterator it = replacements.begin();
-       it != replacements.end(); ++it) {
+       it != replacements.end();
+       ++it) {
     llvm::outs() << "r:" << it->getFilePath() << ":" << it->getOffset() << ":"
                  << it->getLength() << ":" << it->getReplacementText() << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }