Own/produce FrontendActionFactories by value, clang-tools-extra portion.

[klimek]

lg

clang-modernize/Core/Transform.h

74–76

Any reason to have 2 empty lines here?

clang-modernize/LoopConvert/LoopConvert.cpp

51 ↗

(On Diff #10892)

Why not still call createActionFactory? (or delete createActionFactory)?

clang-modernize/tool/ClangModernize.cpp

472

I think we'll not want to call it "new..." if it doesn't return a pointer. (I'd use "create" in that case).

[dblaikie]

• Reuse createActionFactory and remove extra blank line.

clang-modernize/Core/Transform.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_MODERNIZE_TRANSFORM_H
 #define CLANG_MODERNIZE_TRANSFORM_H
 
 #include "Core/IncludeExcludeInfo.h"
 #include "Core/Refactoring.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/LLVM.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Registry.h"
 #include "llvm/Support/Timer.h"
 #include <string>
 #include <vector>
 
 /// \brief Description of the riskiness of actions that can be taken by
 /// transforms.
struct TransformOptions {
 
   /// \brief Contains information on which files are safe to transform and
   /// which aren't.
   IncludeExcludeInfo ModifiableFiles;
 
   /// \brief Maximum allowed level of risk.
   RiskLevel MaxRiskLevel;
 };
 
+class ActionFactory;
+
 /// \brief Abstract base class for all C++11 migration transforms.
 ///
 /// Subclasses must call createActionFactory() to create a
 /// FrontendActionFactory to pass to ClangTool::run(). Subclasses are also
 /// responsible for calling setOverrides() before calling ClangTool::run().
 ///
 /// If timing is enabled (see TransformOptions), per-source performance timing
 /// is recorded and stored in a TimingVec for later access with timing_begin()
protected:
   /// created with.
   const TransformOptions &Options() { return GlobalOptions; }
 
   /// \brief Subclasses must call this function to create a
   /// FrontendActionFactory to pass to ClangTool.
   ///
   /// The factory returned by this function is responsible for calling back to
   /// Transform to call handleBeginSource() and handleEndSource().
-  clang::tooling::FrontendActionFactory *
-      createActionFactory(clang::ast_matchers::MatchFinder &Finder);
+  ActionFactory createActionFactory(clang::ast_matchers::MatchFinder &Finder);
 
 private:
   const std::string Name;
   const TransformOptions &GlobalOptions;
   TUReplacementsMap Replacements;
   std::string CurrentSource;
   TimingVec Timings;
   unsigned AcceptedChanges;
protected:
   /// available.
   ///
   /// Can be set by the sub-class in the constructor body.
   CompilerVersions Since;
 };
 
 typedef llvm::Registry<TransformFactory> TransformFactoryRegistry;
 
+/// \brief Custom FrontendActionFactory to produce FrontendActions that simply
+/// forward (Begin|End)SourceFileAction calls to a given Transform.
+class ActionFactory : public clang::tooling::FrontendActionFactory {
+public:
+  ActionFactory(clang::ast_matchers::MatchFinder &Finder, Transform &Owner)
+      : Finder(Finder), Owner(Owner) {}
+
+  virtual std::unique_ptr<clang::FrontendAction> create() const override {
+    return llvm::make_unique<FactoryAdaptor>(Finder, Owner);
+  }
+
+private:
+  class FactoryAdaptor : public clang::ASTFrontendAction {
+  public:
+    FactoryAdaptor(clang::ast_matchers::MatchFinder &Finder, Transform &Owner)
+        : Finder(Finder), Owner(Owner) {}
+
+    clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &,
+                                          llvm::StringRef) {
+      return Finder.newASTConsumer();
+    }
+
+    virtual bool BeginSourceFileAction(clang::CompilerInstance &CI,
+                                       llvm::StringRef Filename) override {
+      if (!clang::ASTFrontendAction::BeginSourceFileAction(CI, Filename))
+        return false;
+
+      return Owner.handleBeginSource(CI, Filename);
+    }
+
+    virtual void EndSourceFileAction() override {
+      Owner.handleEndSource();
+      return clang::ASTFrontendAction::EndSourceFileAction();
+    }
+
+  private:
+    clang::ast_matchers::MatchFinder &Finder;
+    Transform &Owner;
+  };
+
+  clang::ast_matchers::MatchFinder &Finder;
+  Transform &Owner;
+};
+
 #endif // CLANG_MODERNIZE_TRANSFORM_H

clang-modernize/Core/Transform.cpp

 //===-- Core/Transform.cpp - Transform Base Class Def'n -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief This file provides the definition for the base Transform class from
 /// which all transforms must subclass.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Core/Transform.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace clang;
 
 llvm::cl::OptionCategory TransformsOptionsCategory("Transforms' options");
 
 namespace {
 
 using namespace tooling;
 using namespace ast_matchers;
 
-/// \brief Custom FrontendActionFactory to produce FrontendActions that simply
-/// forward (Begin|End)SourceFileAction calls to a given Transform.
-class ActionFactory : public clang::tooling::FrontendActionFactory {
-public:
-  ActionFactory(MatchFinder &Finder, Transform &Owner)
-  : Finder(Finder), Owner(Owner) {}
-
-  virtual FrontendAction *create() override {
-    return new FactoryAdaptor(Finder, Owner);
-  }
-
-private:
-  class FactoryAdaptor : public ASTFrontendAction {
-  public:
-    FactoryAdaptor(MatchFinder &Finder, Transform &Owner)
-        : Finder(Finder), Owner(Owner) {}
-
-    ASTConsumer *CreateASTConsumer(CompilerInstance &, StringRef) {
-      return Finder.newASTConsumer();
-    }
-
-    virtual bool BeginSourceFileAction(CompilerInstance &CI,
-                                       StringRef Filename) override {
-      if (!ASTFrontendAction::BeginSourceFileAction(CI, Filename))
-        return false;
-
-      return Owner.handleBeginSource(CI, Filename);
-    }
-
-    virtual void EndSourceFileAction() override {
-      Owner.handleEndSource();
-      return ASTFrontendAction::EndSourceFileAction();
-    }
-
-  private:
-    MatchFinder &Finder;
-    Transform &Owner;
-  };
-
-  MatchFinder &Finder;
-  Transform &Owner;
-};
 } // namespace
 
 Transform::Transform(llvm::StringRef Name, const TransformOptions &Options)
     : Name(Name), GlobalOptions(Options) {
   Reset();
 }
 
 Transform::~Transform() {}
Transform::addReplacementForCurrentTU(const clang::tooling::Replacement &R) {
   TranslationUnitReplacements &TU = Replacements[CurrentSource];
   if (TU.MainSourceFile.empty())
     TU.MainSourceFile = CurrentSource;
   TU.Replacements.push_back(R);
 
   return true;
 }
 
-FrontendActionFactory *Transform::createActionFactory(MatchFinder &Finder) {
-  return new ActionFactory(Finder, /*Owner=*/ *this);
+ActionFactory Transform::createActionFactory(MatchFinder &Finder) {
+  return ActionFactory(Finder, /*Owner=*/ *this);
 }
 
 Version Version::getFromString(llvm::StringRef VersionStr) {
   llvm::StringRef MajorStr, MinorStr;
   Version V;
 
   std::tie(MajorStr, MinorStr) = VersionStr.split('.');
   if (!MinorStr.empty()) {

clang-modernize/UseNullptr/UseNullptr.cpp

if (!UserNullMacroNames.empty()) {
     llvm::StringRef S = UserNullMacroNames;
     S.split(MacroNames, ",");
   }
   MatchFinder Finder;
   NullptrFixer Fixer(AcceptedChanges, MacroNames, /*Owner=*/ *this);
 
   Finder.addMatcher(makeCastSequenceMatcher(), &Fixer);
 
-  if (int result = UseNullptrTool.run(createActionFactory(Finder))) {
+  if (int result = UseNullptrTool.run(ActionFactory(Finder, *this))) {
     llvm::errs() << "Error encountered during translation.\n";
     return result;
   }
 
   setAcceptedChanges(AcceptedChanges);
 
   return 0;
 }

clang-modernize/tool/ClangModernize.cpp

int main(int argc, const char **argv) {
 
   // Let the user know which temporary directory the replacements got written
   // to.
   if (SerializeOnly && !TempDestinationDir.empty())
     llvm::errs() << "Replacements serialized to: " << TempDestinationDir << "\n";
 
   if (FinalSyntaxCheck) {
     ClangTool SyntaxTool(*Compilations, SourcePaths);
-    if (SyntaxTool.run(newFrontendActionFactory<SyntaxOnlyAction>().get()) != 0)
+    if (SyntaxTool.run(newFrontendActionFactory<SyntaxOnlyAction>()) != 0)
       return 1;
   }
 
   // Report execution times.
   if (GlobalOptions.EnableTiming && !PerfData.empty()) {
     std::string DirectoryName = TimingDirectoryName;
     // Use default directory name.
     if (DirectoryName.empty())

clang-tidy/ClangTidy.cpp

ClangTidyStats runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyASTConsumerFactory *ConsumerFactory)
         : ConsumerFactory(ConsumerFactory) {}
-    FrontendAction *create() override { return new Action(ConsumerFactory); }
+    std::unique_ptr<FrontendAction> create() const override {
+      return llvm::make_unique<Action>(ConsumerFactory);
+    }
 
   private:
     class Action : public ASTFrontendAction {
     public:
       Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
       ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler,
                                      StringRef File) override {
         return Factory->CreateASTConsumer(Compiler, File);
       }
 
     private:
       ClangTidyASTConsumerFactory *Factory;
     };
 
     ClangTidyASTConsumerFactory *ConsumerFactory;
   };
 
-  Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context)));
+  Tool.run(ActionFactory(new ClangTidyASTConsumerFactory(Context)));
   *Errors = Context.getErrors();
   return Context.getStats();
 }
 
 void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix) {
   ErrorReporter Reporter(Fix);
   for (const ClangTidyError &Error : Errors) {
     Reporter.reportDiagnostic(

modularize/Modularize.cpp

 class ModularizeFrontendActionFactory : public FrontendActionFactory {
 public:
   ModularizeFrontendActionFactory(EntityMap &Entities,
                                   PreprocessorTracker &preprocessorTracker,
                                   int &HadErrors)
       : Entities(Entities), PPTracker(preprocessorTracker),
         HadErrors(HadErrors) {}
 
-  virtual CollectEntitiesAction *create() {
-    return new CollectEntitiesAction(Entities, PPTracker, HadErrors);
+  virtual std::unique_ptr<FrontendAction> create() const {
+    return llvm::make_unique<CollectEntitiesAction>(Entities, PPTracker,
+                                                    HadErrors);
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
   int &HadErrors;
 };
 
int main(int Argc, const char **Argv) {
   // Create the compilation database.
   SmallString<256> PathBuf;
   sys::fs::current_path(PathBuf);
   std::unique_ptr<CompilationDatabase> Compilations;
   Compilations.reset(
       new FixedCompilationDatabase(Twine(PathBuf), CC1Arguments));
 
   // Create preprocessor tracker, to watch for macro and conditional problems.
-  std::unique_ptr<PreprocessorTracker> PPTracker(PreprocessorTracker::create());
+  std::unique_ptr<PreprocessorTracker> PPTracker =
+      PreprocessorTracker::create();
 
   // Parse all of the headers, detecting duplicates.
   EntityMap Entities;
   ClangTool Tool(*Compilations, Headers);
   Tool.appendArgumentsAdjuster(new AddDependenciesAdjuster(Dependencies));
   int HadErrors = 0;
   HadErrors |= Tool.run(
-      new ModularizeFrontendActionFactory(Entities, *PPTracker, HadErrors));
+      ModularizeFrontendActionFactory(Entities, *PPTracker, HadErrors));
 
   // Create a place to save duplicate entity locations, separate bins per kind.
   typedef SmallVector<Location, 8> LocationArray;
   typedef SmallVector<LocationArray, Entry::EK_NumberOfKinds> EntryBinArray;
   EntryBinArray EntryBins;
   int KindIndex;
   for (KindIndex = 0; KindIndex < Entry::EK_NumberOfKinds; ++KindIndex) {
     LocationArray Array;
for (EntityMap::iterator E = Entities.begin(), EEnd = Entities.end();
     for (unsigned I = 0, N = E->second.size(); I != N; ++I) {
       EntryBins[E->second[I].Kind].push_back(E->second[I].Loc);
     }
     // Report any duplicate entity definition errors.
     int KindIndex = 0;
     for (EntryBinArray::iterator DI = EntryBins.begin(), DE = EntryBins.end();
          DI != DE; ++DI, ++KindIndex) {
       int ECount = DI->size();
-      // If only 1 occurrence of this entity, skip it, as we only report duplicates.
+      // If only 1 occurrence of this entity, skip it, as we only report
+      // duplicates.
       if (ECount <= 1)
         continue;
       LocationArray::iterator FI = DI->begin();
       StringRef kindName = Entry::getKindName((Entry::EntryKind)KindIndex);
       errs() << "error: " << kindName << " '" << E->first()
              << "' defined at multiple locations:\n";
       for (LocationArray::iterator FE = DI->end(); FI != FE; ++FI) {
         errs() << "    " << FI->File->getName() << ":" << FI->Line << ":"

modularize/PreprocessorTracker.h

public:
   // Returns true if any mismatches.
   virtual bool reportInconsistentMacros(llvm::raw_ostream &OS) = 0;
 
   // Report on inconsistent conditional directive instances.
   // Returns true if any mismatches.
   virtual bool reportInconsistentConditionals(llvm::raw_ostream &OS) = 0;
 
   // Create instance of PreprocessorTracker.
-  static PreprocessorTracker *create();
+  static std::unique_ptr<PreprocessorTracker> create();
 };
 
 } // end namespace Modularize
 
 #endif

modularize/PreprocessorTracker.cpp

 // order of the code encountered.
 //
 //===--------------------------------------------------------------------===//
 
 #include "clang/Lex/LexDiagnostic.h"
 #include "PreprocessorTracker.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/PPCallbacks.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/StringPool.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace Modularize {
 
 // Forwards.
 class PreprocessorTrackerImpl;

 };
 
 // PreprocessorTracker functions.
 
 // PreprocessorTracker desctructor.
 PreprocessorTracker::~PreprocessorTracker() {}
 
 // Create instance of PreprocessorTracker.
-PreprocessorTracker *PreprocessorTracker::create() {
-  return new PreprocessorTrackerImpl();
+std::unique_ptr<PreprocessorTracker> PreprocessorTracker::create() {
+  return llvm::make_unique<PreprocessorTrackerImpl>();
 }
 
 // Preprocessor callbacks for modularize.
 
 // Handle include directive.
 void PreprocessorCallbacks::InclusionDirective(
     clang::SourceLocation HashLoc, const clang::Token &IncludeTok,
     llvm::StringRef FileName, bool IsAngled,

module-map-checker/ModuleMapChecker.cpp

private:
   ModuleMapChecker &Checker;
 };
 
 class ModuleMapCheckerFrontendActionFactory : public FrontendActionFactory {
 public:
   ModuleMapCheckerFrontendActionFactory(ModuleMapChecker &Checker)
       : Checker(Checker) {}
 
-  virtual ModuleMapCheckerAction *create() {
-    return new ModuleMapCheckerAction(Checker);
+  virtual std::unique_ptr<FrontendAction> create() const {
+    return llvm::make_unique<ModuleMapCheckerAction>(Checker);
   }
 
 private:
   ModuleMapChecker &Checker;
 };
 
 // ModuleMapChecker class implementation.
 
ModuleMapChecker::collectUmbrellaHeaderHeaders(StringRef UmbrellaHeaderName) {
   std::unique_ptr<CompilationDatabase> Compilations;
   Compilations.reset(new FixedCompilationDatabase(Twine(PathBuf), CommandLine));
 
   std::vector<std::string> HeaderPath;
   HeaderPath.push_back(UmbrellaHeaderName);
 
   // Create the tool and run the compilation.
   ClangTool Tool(*Compilations, HeaderPath);
-  int HadErrors = Tool.run(new ModuleMapCheckerFrontendActionFactory(*this));
+  int HadErrors = Tool.run(ModuleMapCheckerFrontendActionFactory(*this));
 
   // If we had errors, exit early.
   return HadErrors ? false : true;
 }
 
 // Called from ModuleMapCheckerCallbacks to track a header included
 // from an umbrella header.
 void ModuleMapChecker::collectUmbrellaHeaderHeader(StringRef HeaderName) {

pp-trace/PPTrace.cpp

 };
 
 class PPTraceFrontendActionFactory : public FrontendActionFactory {
 public:
   PPTraceFrontendActionFactory(SmallSet<std::string, 4> &Ignore,
                                std::vector<CallbackCall> &CallbackCalls)
       : Ignore(Ignore), CallbackCalls(CallbackCalls) {}
 
-  virtual PPTraceAction *create() {
-    return new PPTraceAction(Ignore, CallbackCalls);
+  virtual std::unique_ptr<FrontendAction> create() const {
+    return llvm::make_unique<PPTraceAction>(Ignore, CallbackCalls);
   }
 
 private:
   SmallSet<std::string, 4> &Ignore;
   std::vector<CallbackCall> &CallbackCalls;
 };
 
 // Output the trace given its data structure and a stream.
int main(int Argc, const char **Argv) {
   Compilations.reset(
       new FixedCompilationDatabase(Twine(PathBuf), CC1Arguments));
 
   // Store the callback trace information here.
   std::vector<CallbackCall> CallbackCalls;
 
   // Create the tool and run the compilation.
   ClangTool Tool(*Compilations, SourcePaths);
-  int HadErrors =
-      Tool.run(new PPTraceFrontendActionFactory(Ignore, CallbackCalls));
+  int HadErrors = Tool.run(PPTraceFrontendActionFactory(Ignore, CallbackCalls));
 
   // If we had errors, exit early.
   if (HadErrors)
     return HadErrors;
 
   // Do the output.
   if (!OutputFileName.size()) {
     HadErrors = outputPPTrace(CallbackCalls, llvm::outs());

remove-cstr-calls/RemoveCStrCalls.cpp

Finder.addMatcher(
           // directly.
           hasArgument(
               0,
               id("call", memberCallExpr(
                   callee(id("member", memberExpr())),
                   callee(methodDecl(hasName(StringCStrMethod))),
                   on(id("arg", expr())))))),
       &Callback);
-  return Tool.runAndSave(newFrontendActionFactory(&Finder).get());
+  return Tool.runAndSave(newFrontendActionFactory(&Finder));
 }

tool-template/ToolTemplate.cpp

//  Still no compilation DB? - bail.
   RefactoringTool Tool(*Compilations, SourcePaths);
   ast_matchers::MatchFinder Finder;
   ToolTemplateCallback Callback(&Tool.getReplacements());
 
 // TODO: Put your matchers here.
 // Use Finder.addMatcher(...) to define the patterns in the AST that you
 // want to match against. You are not limited to just one matcher!
 
-  return Tool.run(newFrontendActionFactory(&Finder).get());
+  return Tool.run(newFrontendActionFactory(&Finder));
 }

unittests/clang-modernize/IncludeDirectivesTest.cpp

 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
 /// \brief A convenience method around \c tooling::runToolOnCodeWithArgs() that
 /// adds the current directory to the include search paths.
-static void applyActionOnCode(FrontendAction *ToolAction, StringRef Code) {
+static void applyActionOnCode(std::unique_ptr<FrontendAction> ToolAction,
+                              StringRef Code) {
   SmallString<128> CurrentDir;
   ASSERT_FALSE(llvm::sys::fs::current_path(CurrentDir));
 
   // Add the current directory to the header search paths so angled includes can
   // find them.
   std::vector<std::string> Args;
   Args.push_back("-I");
   Args.push_back(CurrentDir.str().str());
 
   // mapVirtualFile() needs absolute path for the input file as well.
   SmallString<128> InputFile(CurrentDir);
   sys::path::append(InputFile, "input.cc");
 
-  ASSERT_TRUE(
-      tooling::runToolOnCodeWithArgs(ToolAction, Code, Args, InputFile.str()));
+  ASSERT_TRUE(tooling::runToolOnCodeWithArgs(std::move(ToolAction), Code, Args,
+                                             InputFile.str()));
 }
 
 namespace {
 class TestAddIncludeAction : public PreprocessOnlyAction {
 public:
   TestAddIncludeAction(StringRef Include, tooling::Replacements &Replaces,
                        const char *HeaderToModify = nullptr)
       : Include(Include), Replaces(Replaces), HeaderToModify(HeaderToModify) {
private:
   // if non-null, add the include directives in this file instead of the main
   // file.
   const char *HeaderToModify;
 };
 
 std::string addIncludeInCode(StringRef Include, StringRef Code) {
   tooling::Replacements Replaces;
 
-  applyActionOnCode(new TestAddIncludeAction(Include, Replaces), Code);
+  applyActionOnCode(llvm::make_unique<TestAddIncludeAction>(Include, Replaces),
+                    Code);
 
   if (::testing::Test::HasFailure())
     return "<<unexpected error from applyActionOnCode()>>";
 
   return tooling::applyAllReplacements(Code, Replaces);
 }
 } // end anonymous namespace
 
std::string Result = addIncludeInCode("bar", "#include \"foo.h\"\n"
                                                "#include \"xmacro.def\"\n"
                                                "#undef X\n"
                                                "  K_NUM_KINDS\n"
                                                "};\n");
   EXPECT_EQ(Expected, Result);
 }
 
 namespace {
-TestAddIncludeAction *makeIndirectTestsAction(const char *HeaderToModify,
-                                              tooling::Replacements &Replaces) {
+std::unique_ptr<TestAddIncludeAction>
+makeIndirectTestsAction(const char *HeaderToModify,
   StringRef IncludeToAdd = "c.h";
-  TestAddIncludeAction *TestAction =
-      new TestAddIncludeAction(IncludeToAdd, Replaces, HeaderToModify);
+  auto TestAction = llvm::make_unique<TestAddIncludeAction>(
+      IncludeToAdd, Replaces, HeaderToModify);
   TestAction->mapVirtualHeader("c.h", "#pragma once\n");
   TestAction->mapVirtualHeader("a.h", "#pragma once\n"
                                       "#include <c.h>\n");
   TestAction->mapVirtualHeader("b.h", "#pragma once\n");
   return TestAction;
 }
 } // end anonymous namespace
 
 TEST(IncludeDirectivesTest, indirectIncludes) {
   // In TestAddIncludeAction 'foo.h' includes 'foo-inner.h'. Check that we
   // aren't including foo-inner.h again.
   EXPECT_EQ("#include <foo.h>\n",
             addIncludeInCode("foo-inner.h", "#include <foo.h>\n"));
 
   tooling::Replacements Replaces;
   StringRef Code = "#include <a.h>\n"
                    "#include <b.h>\n";
 
   // a.h already includes c.h
   {
-    FrontendAction *Action = makeIndirectTestsAction("a.h", Replaces);
-    ASSERT_NO_FATAL_FAILURE(applyActionOnCode(Action, Code));
+    auto Action = makeIndirectTestsAction("a.h", Replaces);
+    ASSERT_NO_FATAL_FAILURE(applyActionOnCode(std::move(Action), Code));
     EXPECT_EQ(unsigned(0), Replaces.size());
   }
 
   // c.h is included before b.h but b.h doesn't include c.h directly, so check
   // that it will be inserted.
   {
-    FrontendAction *Action = makeIndirectTestsAction("b.h", Replaces);
-    ASSERT_NO_FATAL_FAILURE(applyActionOnCode(Action, Code));
+    auto Action = makeIndirectTestsAction("b.h", Replaces);
+    ASSERT_NO_FATAL_FAILURE(applyActionOnCode(std::move(Action), Code));
     EXPECT_EQ("#include <c.h>\n\n\n",
               tooling::applyAllReplacements("\n", Replaces));
   }
 }
 
 /// \brief Convenience method to test header guards detection implementation.
 static std::string addIncludeInGuardedHeader(StringRef IncludeToAdd,
                                              StringRef GuardedHeaderCode) {
   const char *GuardedHeaderName = "guarded.h";
   tooling::Replacements Replaces;
-  TestAddIncludeAction *TestAction =
-      new TestAddIncludeAction(IncludeToAdd, Replaces, GuardedHeaderName);
+  auto TestAction = llvm::make_unique<TestAddIncludeAction>(
+      IncludeToAdd, Replaces, GuardedHeaderName);
   TestAction->mapVirtualHeader(GuardedHeaderName, GuardedHeaderCode);
 
-  applyActionOnCode(TestAction, "#include <guarded.h>\n");
+  applyActionOnCode(std::move(TestAction), "#include <guarded.h>\n");
   if (::testing::Test::HasFailure())
     return "<<unexpected error from applyActionOnCode()>>";
 
   return tooling::applyAllReplacements(GuardedHeaderCode, Replaces);
 }
 
 TEST(IncludeDirectivesTest, insertInsideIncludeGuard) {
   EXPECT_EQ("#ifndef GUARD_H\n"

unittests/clang-modernize/TransformTest.cpp

TEST(Transform, Timings) {
   // runs on.
   ConsumerFactory Factory;
 
   // We don't care about any of Transform's functionality except to get it to
   // record timings. For that, we need to forward handleBeginSource() and
   // handleEndSource() calls to it.
   CallbackForwarder Callbacks(T);
 
-  Tool.run(
-      clang::tooling::newFrontendActionFactory(&Factory, &Callbacks).get());
+  Tool.run(clang::tooling::newFrontendActionFactory(&Factory, &Callbacks));
 
   EXPECT_TRUE(Factory.Called);
   Transform::TimingVec::const_iterator I = T.timing_begin();
   EXPECT_GT(I->second.getProcessTime(), 0.0);
 
   // The success of the test shouldn't depend on the order of iteration through
   // timers.
   StringRef FirstFile = I->first;
Tool.mapVirtualFile(SourceFile,
                       "#include \"temp/b.h\"\n"
                       "int a;");
   Tool.mapVirtualFile(HeaderFile, "int b;");
   Tool.mapVirtualFile(HeaderBFile, "int c;");
 
   DummyTransform T("dummy", Options);
   MatchFinder Finder;
   Finder.addMatcher(varDecl().bind("decl"), new ModifiableCallback(T));
-  Tool.run(tooling::newFrontendActionFactory(&Finder).get());
+  Tool.run(tooling::newFrontendActionFactory(&Finder));
 }
 
 TEST(VersionTest, Interface) {
   Version V;
 
   ASSERT_TRUE(V.isNull());
   ASSERT_TRUE(Version(1) < Version(1, 1));
   ASSERT_TRUE(Version(1) < Version(2));

unittests/clang-tidy/ClangTidyTest.h

std::string runCheckOnCode(StringRef Code,
                            std::vector<ClangTidyError> *Errors = nullptr) {
   T Check;
   ClangTidyContext Context(
       new DefaultOptionsProvider(ClangTidyGlobalOptions(), ClangTidyOptions()));
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
   Check.setContext(&Context);
   std::vector<std::string> ArgCXX11(1, "-std=c++11");
 
-  if (!tooling::runToolOnCodeWithArgs(new TestPPAction(Check, &Context), Code,
-                                      ArgCXX11))
+  if (!tooling::runToolOnCodeWithArgs(
+          llvm::make_unique<TestPPAction>(Check, &Context), Code, ArgCXX11))
     return "";
   ast_matchers::MatchFinder Finder;
   Check.registerMatchers(&Finder);
-  std::unique_ptr<tooling::FrontendActionFactory> Factory(
-      tooling::newFrontendActionFactory(&Finder));
-  if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, ArgCXX11))
+  auto Factory = tooling::newFrontendActionFactory(&Finder);
+  if (!tooling::runToolOnCodeWithArgs(Factory.create(), Code, ArgCXX11))
     return "";
   DiagConsumer.finish();
   tooling::Replacements Fixes;
   for (const ClangTidyError &Error : Context.getErrors())
     Fixes.insert(Error.Fix.begin(), Error.Fix.end());
   if (Errors)
     *Errors = Context.getErrors();
   return tooling::applyAllReplacements(Code, Fixes);
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_TIDY_CLANG_TIDY_TEST_H