Own/produce FrontendActionFactories by value, rather than new'd/unique_ptr ownership.

[dblaikie]

Summary

Based on a discussion on cfe-dev, simplify (and make more explicit, in places) the ownership semantics of FrontendActions and FrontendActionFactories using value semantics and std::unique_ptr in places.

[klimek]

include/clang/Tooling/Tooling.h

320

I thought LLVM style was to not explicitly check against NULL? Also, nullptr?

340

I'd change the name of things that do not return a new pointer to "create...".

tools/clang-check/ClangCheck.cpp

223

I actually dislike that change somewhat (it introduces more structural duplication).

[dblaikie]

• Propagate nullptr/NULL check improvements from the copied code after nullptr cleanups by (presumably) Craig.

[dblaikie]

include/clang/Tooling/Tooling.h

320

This was just copy/paste from the original implementation before NULL had been cleaned up (presumably by Craig Topper) here. I've updated for this and a couple of other places that had been changed since I moved the code.

340

Sure thing - I can do that renaming. I'll leave that until we've hammered out the rest (but I'll be sure to include it in the same commit). Should just be mechanical.

tools/clang-check/ClangCheck.cpp

223

Yep, I called this out as the only place that was "interesting" in the original thread, but perhaps it got lost in all the words:

"The one caller that
did:

unique_ptr<factory> p;
if (x)

p = newFactory();

else if (y)

p = newFactory(a);

else

p = newFactory(b);

Tool.run(p);

and the change was to roll the "Tool.run" call up into the call site,
which wasn't overly burdensome."

It could be refactored in a few other ways (like wrapping up a "run" function:

auto run = [&](const FrontendActionFactory& F) { Tool.run(F); };
if (x)

run(newFactory());

else if (y)

run(newFactory(a));

else

run(newFactory(b));

Which doesn't really seem worthwhile to me.

The next alternative would be to copy/move the factory into a dynamic allocation with a type erased destruction, which might look something like:

template<typename T>
std::shared_ptr<T> newClone(T &&t) {

return std::make_shared<T>(std::forward<T>(t));

}

...

// Use shared_ptr for type erased destruction
std::shared_ptr<FrontendActionFactory> F;
if (x)

F = newClone(newFactory());

else if (y)

F = newClone(newFactory(a));

else

F = newClone(newFactory(b));

Tool.run(*F);

Which also seems excessive to me.

(well, sorry, all those examples are assuming the dtor becomes non-virtual - in this patch they're still virtual, so unique_ptr could be used instead of shared_ptr, but "newClone" would still be needed to move from static to a dynamic allocation)

[dblaikie]

After reviewing (& making some improvements in r215215 and r215214) some memory leak fixes made in r213851 I think it's rather valuable to change Tool::run to take a reference to a FrontendActionFactory, rather than a pointer. (indeed the memory leaks related to that API that were fixed in r213851 are also fixed by my patch above)

And while I don't mind churning the APIs multiple times (switching to references, then, potentially, switching to the factory functions returning by value) & doing all the legwork internally & externally - it might be nice to settle on it.

I can also split out the other part involving the SingleFrontendActionFactory (and fixing FrontendActionFactory::create to be explicit about returning ownership) that we discussed/were confused by for a while, etc...

tools/clang-check/ClangCheck.cpp

223

Another option would be to expose the types that these factory functions return and then just have the code specify the template arguments explicitly in this one case (old code provided in comments for comparison):

std::shared_ptr<FrontendActionFactory> F; // or std::unique_ptr if the dtors remain virtual
if (x)
  // F = newFrontendActionFactory<clang::ento::AnalysisAction>();
  F = std::make_shared<SimpleFrontendActionFactory<clang::ento::AnalysisAction>>();
else if (y)
  // F = newFrontendActionFactory<FixItAction>();
  F = std::make_shared<SimpleFrontendActionFactory<FixItAction>>();
else
  // F = newFrontendActionFactory(&CheckFactory);
  F = std::make_shared<FrontendActionFactoryAdapter<clang_check::ClangCheckActionFactory>>();
Tool.run(*F);

[klimek]

This has now been resolved differently, right? Can we abandon the revision?

[dblaikie]

In D4313#12, @klimek wrote:

This has now been resolved differently, right? Can we abandon the revision?

Not exactly - r207396 made the newFrontendActionFactory change to return unique_ptr, but the original memory leak could still easily be written because it takes a raw pointer (this both complicates callers (having them either use "newFrontendActionFactory(...).get()" or take the address of a local to pass) and risks someone passing a raw 'new' to the function)).

The follow-on refactor to have newFrontendActionFactory return by value (& then, potentially, remove its virtual dtor) is just to simplify the call sites even further. Rather than replacing "run(newFrontendActionFactory(...).get())" with "run(*newFrontendActionFactory(...))" (which might make people twitch a bit, wondering whether that leaks or not) it could just be "run(newFrontendActionFactory(...))" which seems less surprising.

I figure if I'm going to have to touch every caller anyway, it wasn't really extra churn to change newFrontendActionFactory to be value-based.

And there's still the matter of runToolOnCode taking ownership via raw pointer (which then feeds into that confusion we had over ToolInvocation needing to take ownership and SingleFrontendActionFactory taking/returning ownership of that FrontendActionFactory). But that's fairly separable.

include/clang/Tooling/Refactoring.h

public:
   /// \brief Returns the set of replacements to which replacements should
   /// be added during the run of the tool.
   Replacements &getReplacements();
 
   /// \brief Call run(), apply all generated replacements, and immediately save
   /// the results to disk.
   ///
   /// \returns 0 upon success. Non-zero upon failure.
-  int runAndSave(FrontendActionFactory *ActionFactory);
+  int runAndSave(const FrontendActionFactory &ActionFactory);
 
   /// \brief Apply all stored replacements to the given Rewriter.
   ///
   /// Replacement applications happen independently of the success of other
   /// applications.
   ///
   /// \returns true if all replacements apply. false otherwise.
   bool applyAllReplacements(Rewriter &Rewrite);

include/clang/Tooling/Tooling.h

 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Driver/Util.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/STLExtras.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
 
 namespace driver {
 class Compilation;

 /// FrontendActionFactory instead.
 class ToolAction {
 public:
   virtual ~ToolAction();
 
   /// \brief Perform an action for an invocation.
   virtual bool runInvocation(clang::CompilerInvocation *Invocation,
                              FileManager *Files,
-                             DiagnosticConsumer *DiagConsumer) = 0;
+                             DiagnosticConsumer *DiagConsumer) const = 0;
 };
 
 /// \brief Interface to generate clang::FrontendActions.
 ///
 /// Having a factory interface allows, for example, a new FrontendAction to be
 /// created for each translation unit processed by ClangTool.  This class is
 /// also a ToolAction which uses the FrontendActions created by create() to
 /// process each translation unit.
 class FrontendActionFactory : public ToolAction {
 public:
   virtual ~FrontendActionFactory();
 
   /// \brief Invokes the compiler with a FrontendAction created by create().
   bool runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files,
-                     DiagnosticConsumer *DiagConsumer) override;
+                     DiagnosticConsumer *DiagConsumer) const override;
 
   /// \brief Returns a new clang::FrontendAction.
   ///
   /// The caller takes ownership of the returned action.
-  virtual clang::FrontendAction *create() = 0;
+  virtual std::unique_ptr<clang::FrontendAction> create() const = 0;
 };
 
-/// \brief Returns a new FrontendActionFactory for a given type.
-///
-/// T must derive from clang::FrontendAction.
-///
-/// Example:
-/// FrontendActionFactory *Factory =
-///   newFrontendActionFactory<clang::SyntaxOnlyAction>();
-template <typename T>
-std::unique_ptr<FrontendActionFactory> newFrontendActionFactory();
-
 /// \brief Callbacks called before and after each source file processed by a
-/// FrontendAction created by the FrontedActionFactory returned by \c
-/// newFrontendActionFactory.
+/// FrontendAction created by the FrontedActionFactoryAdapter.
 class SourceFileCallbacks {
 public:
   virtual ~SourceFileCallbacks() {}
 
   /// \brief Called before a source file is processed by a FrontEndAction.
   /// \see clang::FrontendAction::BeginSourceFileAction
   virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) {
     return true;
   }
 
   /// \brief Called after a source file is processed by a FrontendAction.
   /// \see clang::FrontendAction::EndSourceFileAction
   virtual void handleEndSource() {}
 };
 
-/// \brief Returns a new FrontendActionFactory for any type that provides an
-/// implementation of newASTConsumer().
-///
-/// FactoryT must implement: ASTConsumer *newASTConsumer().
-///
-/// Example:
-/// struct ProvidesASTConsumers {
-///   clang::ASTConsumer *newASTConsumer();
-/// } Factory;
-/// std::unique_ptr<FrontendActionFactory> FactoryAdapter(
-///   newFrontendActionFactory(&Factory));
-template <typename FactoryT>
-inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
-    FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks = nullptr);
-
 /// \brief Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag.
 ///
 /// \param ToolAction The action to run over the code.
 /// \param Code C++ code.
 /// \param FileName The file name which 'Code' will be mapped as.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
-                   const Twine &FileName = "input.cc");
+bool runToolOnCode(std::unique_ptr<clang::FrontendAction> ToolAction,
+                   const Twine &Code, const Twine &FileName = "input.cc");
 
 /// \brief Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag and
 ///        with additional other flags.
 ///
 /// \param ToolAction The action to run over the code.
 /// \param Code C++ code.
 /// \param Args Additional flags to pass on.
 /// \param FileName The file name which 'Code' will be mapped as.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code,
+bool runToolOnCodeWithArgs(std::unique_ptr<clang::FrontendAction> ToolAction,
+                           const Twine &Code,
                            const std::vector<std::string> &Args,
                            const Twine &FileName = "input.cc");
 
 /// \brief Builds an AST for 'Code'.
 ///
 /// \param Code C++ code.
 /// \param FileName The file name which 'Code' will be mapped as.
 ///
public:
   ///
   /// \param CommandLine The command line arguments to clang. Note that clang
   /// uses its binary name (CommandLine[0]) to locate its builtin headers.
   /// Callers have to ensure that they are installed in a compatible location
   /// (see clang driver implementation) or mapped in via mapVirtualFile.
   /// \param FAction The action to be executed. Class takes ownership.
   /// \param Files The FileManager used for the execution. Class does not take
   /// ownership.
-  ToolInvocation(std::vector<std::string> CommandLine, FrontendAction *FAction,
-                 FileManager *Files);
+   ToolInvocation(std::vector<std::string> CommandLine,
+                  std::unique_ptr<FrontendAction> FAction, FileManager *Files);
 
   /// \brief Create a tool invocation.
   ///
   /// \param CommandLine The command line arguments to clang.
   /// \param Action The action to be executed.
   /// \param Files The FileManager used for the execution.
-  ToolInvocation(std::vector<std::string> CommandLine, ToolAction *Action,
-                 FileManager *Files);
+   ToolInvocation(std::vector<std::string> CommandLine,
+                  const ToolAction *Action, FileManager *Files);
 
   ~ToolInvocation();
 
   /// \brief Set a \c DiagnosticConsumer to use during parsing.
   void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer);
 
   /// \brief Map a virtual file to be used while running the tool.
   ///
   /// \param FilePath The path at which the content will be mapped.
   /// \param Content A null terminated buffer of the file's content.
   void mapVirtualFile(StringRef FilePath, StringRef Content);
 
   /// \brief Run the clang invocation.
   ///
   /// \returns True if there were no errors during execution.
   bool run();
 
  private:
   void addFileMappingsTo(SourceManager &SourceManager);
 
   bool runInvocation(const char *BinaryName,
                      clang::driver::Compilation *Compilation,
-                     clang::CompilerInvocation *Invocation);
+                     clang::CompilerInvocation *Invocation) const;
 
   std::vector<std::string> CommandLine;
-  ToolAction *Action;
+  const ToolAction *Action;
   bool OwnsAction;
   FileManager *Files;
   // Maps <file name> -> <file content>.
   llvm::StringMap<StringRef> MappedFileContents;
   DiagnosticConsumer *DiagConsumer;
 };
 
 /// \brief Utility to run a FrontendAction over a set of files.
public:
   void appendArgumentsAdjuster(ArgumentsAdjuster *Adjuster);
 
   /// \brief Clear the command line arguments adjuster chain.
   void clearArgumentsAdjusters();
 
   /// Runs an action over all files specified in the command line.
   ///
   /// \param Action Tool action.
-  int run(ToolAction *Action);
+  int run(const ToolAction &Action);
 
   /// \brief Create an AST for each file specified in the command line and
   /// append them to ASTs.
   int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
 
   /// \brief Returns the file manager used in the tool.
   ///
   /// The file manager is shared between all translation units.
   FileManager &getFiles() { return *Files; }
 
  private:
   // We store compile commands as pair (file name, compile command).
   std::vector< std::pair<std::string, CompileCommand> > CompileCommands;
 
   llvm::IntrusiveRefCntPtr<FileManager> Files;
   // Contains a list of pairs (<file name>, <file content>).
   std::vector< std::pair<StringRef, StringRef> > MappedFileContents;
 
   SmallVector<ArgumentsAdjuster *, 2> ArgsAdjusters;
 
   DiagnosticConsumer *DiagConsumer;
 };
 
+namespace internal {
 template <typename T>
-std::unique_ptr<FrontendActionFactory> newFrontendActionFactory() {
-  class SimpleFrontendActionFactory : public FrontendActionFactory {
-  public:
-    clang::FrontendAction *create() override { return new T; }
-  };
-
-  return std::unique_ptr<FrontendActionFactory>(
-      new SimpleFrontendActionFactory);
+struct SimpleFrontendActionFactory : FrontendActionFactory {
+  std::unique_ptr<clang::FrontendAction> create() const override {
+    return llvm::make_unique<T>();
   }
+};
 
 template <typename FactoryT>
-inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
-    FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks) {
-  class FrontendActionFactoryAdapter : public FrontendActionFactory {
-  public:
-    explicit FrontendActionFactoryAdapter(FactoryT *ConsumerFactory,
-                                          SourceFileCallbacks *Callbacks)
       : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
 
-    clang::FrontendAction *create() override {
-      return new ConsumerFactoryAdaptor(ConsumerFactory, Callbacks);
-    }
+  std::unique_ptr<clang::FrontendAction> create() const override {
+    return llvm::make_unique<ConsumerFactoryAdaptor>(ConsumerFactory,
+                                                     Callbacks);
 
-  private:
-    class ConsumerFactoryAdaptor : public clang::ASTFrontendAction {
-    public:
-      ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
-                             SourceFileCallbacks *Callbacks)
         : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
 
-      clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &,
-                                            StringRef) override {
-        return ConsumerFactory->newASTConsumer();
-      }
 
-    protected:
-      bool BeginSourceFileAction(CompilerInstance &CI,
-                                 StringRef Filename) override {
-        if (!clang::ASTFrontendAction::BeginSourceFileAction(CI, Filename))
-          return false;
-        if (Callbacks)
-          return Callbacks->handleBeginSource(CI, Filename);
-        return true;
-      }
-      void EndSourceFileAction() override {
-        if (Callbacks)
-          Callbacks->handleEndSource();
-        clang::ASTFrontendAction::EndSourceFileAction();
-      }
 
-    private:
-      FactoryT *ConsumerFactory;
-      SourceFileCallbacks *Callbacks;
-    };
-    FactoryT *ConsumerFactory;
-    SourceFileCallbacks *Callbacks;
-  };
+}
 
-  return std::unique_ptr<FrontendActionFactory>(
-      new FrontendActionFactoryAdapter(ConsumerFactory, Callbacks));
+template <typename T>
+internal::SimpleFrontendActionFactory<T> newFrontendActionFactory() {
+  return internal::SimpleFrontendActionFactory<T>();
+}
+
+template <typename FactoryT>
+internal::FrontendActionFactoryAdapter<FactoryT>
+newFrontendActionFactory(FactoryT *ConsumerFactory,
+                         SourceFileCallbacks *Callbacks = nullptr) {
+  return internal::FrontendActionFactoryAdapter<FactoryT>(ConsumerFactory,
+                                                          Callbacks);
 }
 
 /// \brief Returns the absolute path of \c File, by prepending it with
 /// the current directory if \c File is not absolute.
 ///
 /// Otherwise returns \c File.
 /// If 'File' starts with "./", the returned path will not contain the "./".
 /// Otherwise, the returned path will contain the literal path-concatenation of

lib/Tooling/Refactoring.cpp

 
 
 RefactoringTool::RefactoringTool(const CompilationDatabase &Compilations,
                                  ArrayRef<std::string> SourcePaths)
   : ClangTool(Compilations, SourcePaths) {}
 
 Replacements &RefactoringTool::getReplacements() { return Replace; }
 
-int RefactoringTool::runAndSave(FrontendActionFactory *ActionFactory) {
+int RefactoringTool::runAndSave(const FrontendActionFactory &ActionFactory) {
   if (int Result = run(ActionFactory)) {
     return Result;
   }
 
   LangOptions DefaultLangOptions;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), &*DiagOpts);
   DiagnosticsEngine Diagnostics(

lib/Tooling/Tooling.cpp

clang::CompilerInvocation::CreateFromArgs(
       *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
       *Diagnostics);
   Invocation->getFrontendOpts().DisableFree = false;
   Invocation->getCodeGenOpts().DisableFree = false;
   Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
   return Invocation;
 }
 
-bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
-                   const Twine &FileName) {
-  return runToolOnCodeWithArgs(
-      ToolAction, Code, std::vector<std::string>(), FileName);
+bool runToolOnCode(std::unique_ptr<clang::FrontendAction> ToolAction,
+                   const Twine &Code, const Twine &FileName) {
+  return runToolOnCodeWithArgs(std::move(ToolAction), Code,
+                               std::vector<std::string>(), FileName);
 }
 
 static std::vector<std::string>
 getSyntaxOnlyToolArgs(const std::vector<std::string> &ExtraArgs,
                       StringRef FileName) {
   std::vector<std::string> Args;
   Args.push_back("clang-tool");
   Args.push_back("-fsyntax-only");
   Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
   Args.push_back(FileName.str());
   return Args;
 }
 
-bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code,
+bool runToolOnCodeWithArgs(std::unique_ptr<clang::FrontendAction> ToolAction,
+                           const Twine &Code,
                            const std::vector<std::string> &Args,
                            const Twine &FileName) {
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions()));
-  ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), ToolAction,
-                            Files.getPtr());
+  ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef),
+                            std::move(ToolAction), Files.getPtr());
 
   SmallString<1024> CodeStorage;
   Invocation.mapVirtualFile(FileNameRef,
                             Code.toNullTerminatedStringRef(CodeStorage));
   return Invocation.run();
 }
 
 std::string getAbsolutePath(StringRef File) {
std::string getAbsolutePath(StringRef File) {
   (void)EC;
   llvm::sys::path::native(AbsolutePath);
   return AbsolutePath.str();
 }
 
 namespace {
 
 class SingleFrontendActionFactory : public FrontendActionFactory {
-  FrontendAction *Action;
+  mutable std::unique_ptr<FrontendAction> Action;
 
 public:
-  SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {}
+  SingleFrontendActionFactory(std::unique_ptr<FrontendAction> Action)
+      : Action(std::move(Action)) {}
 
-  FrontendAction *create() override { return Action; }
+  std::unique_ptr<FrontendAction> create() const override {
+    return std::move(Action);
+  }
 };
 
 }
 
 ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine,
-                               ToolAction *Action, FileManager *Files)
+                               const ToolAction *Action, FileManager *Files)
     : CommandLine(std::move(CommandLine)),
       Action(Action),
       OwnsAction(false),
       Files(Files),
       DiagConsumer(nullptr) {}
 
 ToolInvocation::ToolInvocation(std::vector<std::string> CommandLine,
-                               FrontendAction *FAction, FileManager *Files)
+                               std::unique_ptr<FrontendAction> FAction,
+                               FileManager *Files)
     : CommandLine(std::move(CommandLine)),
-      Action(new SingleFrontendActionFactory(FAction)),
+      Action(new SingleFrontendActionFactory(std::move(FAction))),
       OwnsAction(true),
       Files(Files),
       DiagConsumer(nullptr) {}
 
 ToolInvocation::~ToolInvocation() {
   if (OwnsAction)
     delete Action;
 }
bool ToolInvocation::run() {
   for (const auto &It : MappedFileContents) {
     // Inject the code as the given file name into the preprocessor options.
     auto *Input = llvm::MemoryBuffer::getMemBuffer(It.getValue());
     Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(), Input);
   }
   return runInvocation(BinaryName, Compilation.get(), Invocation.release());
 }
 
-bool ToolInvocation::runInvocation(
-    const char *BinaryName,
+bool
+ToolInvocation::runInvocation(const char *BinaryName,
                               clang::driver::Compilation *Compilation,
-    clang::CompilerInvocation *Invocation) {
+                              clang::CompilerInvocation *Invocation) const {
   // Show the invocation, with -v.
   if (Invocation->getHeaderSearchOpts().Verbose) {
     llvm::errs() << "clang Invocation:\n";
     Compilation->getJobs().Print(llvm::errs(), "\n", true);
     llvm::errs() << "\n";
   }
 
   return Action->runInvocation(Invocation, Files, DiagConsumer);
 }
 
-bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation,
-                                          FileManager *Files,
-                                          DiagnosticConsumer *DiagConsumer) {
+bool
+FrontendActionFactory::runInvocation(CompilerInvocation *Invocation,
+                                     DiagnosticConsumer *DiagConsumer) const {
   // Create a compiler instance to handle the actual work.
   clang::CompilerInstance Compiler;
   Compiler.setInvocation(Invocation);
   Compiler.setFileManager(Files);
 
   // The FrontendAction can have lifetime requirements for Compiler or its
   // members, and we need to ensure it's deleted earlier than Compiler. So we
   // pass it to an std::unique_ptr declared after the Compiler variable.

 }
 
 void ClangTool::clearArgumentsAdjusters() {
   for (unsigned I = 0, E = ArgsAdjusters.size(); I != E; ++I)
     delete ArgsAdjusters[I];
   ArgsAdjusters.clear();
 }
 
-int ClangTool::run(ToolAction *Action) {
+int ClangTool::run(const ToolAction &Action) {
   // Exists solely for the purpose of lookup of the resource path.
   // This just needs to be some symbol in the binary.
   static int StaticSymbol;
   // The driver detects the builtin header path based on the path of the
   // executable.
   // FIXME: On linux, GetMainExecutable is independent of the value of the
   // first argument, thus allowing ClangTool and runToolOnCode to just
   // pass in made-up names here. Make sure this works on other platforms.
for (ArgumentsAdjuster *Adjuster : ArgsAdjusters)
       CommandLine = Adjuster->Adjust(CommandLine);
     assert(!CommandLine.empty());
     CommandLine[0] = MainExecutable;
     // FIXME: We need a callback mechanism for the tool writer to output a
     // customized message for each file.
     DEBUG({
       llvm::dbgs() << "Processing: " << Command.first << ".\n";
     });
-    ToolInvocation Invocation(std::move(CommandLine), Action, Files.getPtr());
+    ToolInvocation Invocation(std::move(CommandLine), &Action, Files.getPtr());
     Invocation.setDiagnosticConsumer(DiagConsumer);
     for (const auto &MappedFile : MappedFileContents) {
       Invocation.mapVirtualFile(MappedFile.first, MappedFile.second);
     }
     if (!Invocation.run()) {
       // FIXME: Diagnostics should be used instead.
       llvm::errs() << "Error while processing " << Command.first << ".\n";
       ProcessingFailed = true;
     }
   }
   return ProcessingFailed ? 1 : 0;
 }
 
 namespace {
 
 class ASTBuilderAction : public ToolAction {
   std::vector<std::unique_ptr<ASTUnit>> &ASTs;
 
 public:
   ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
 
   bool runInvocation(CompilerInvocation *Invocation, FileManager *Files,
-                     DiagnosticConsumer *DiagConsumer) override {
+                     DiagnosticConsumer *DiagConsumer) const override {
     // FIXME: This should use the provided FileManager.
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
         Invocation, CompilerInstance::createDiagnostics(
                         &Invocation->getDiagnosticOpts(), DiagConsumer,
                         /*ShouldOwnClient=*/false));
     if (!AST)
       return false;
 
     ASTs.push_back(std::move(AST));
     return true;
   }
 };
 
 }
 
 int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) {
   ASTBuilderAction Action(ASTs);
-  return run(&Action);
+  return run(Action);
 }
 
 std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code,
                                           const Twine &FileName) {
   return buildASTFromCodeWithArgs(Code, std::vector<std::string>(), FileName);
 }
 
 std::unique_ptr<ASTUnit>

tools/clang-check/ClangCheck.cpp

int main(int argc, const char **argv) {
   }
 
   // Running the analyzer requires --analyze. Other modes can work with the
   // -fsyntax-only option.
   Tool.appendArgumentsAdjuster(new InsertAdjuster(
         Analyze ? "--analyze" : "-fsyntax-only", InsertAdjuster::BEGIN));
 
   clang_check::ClangCheckActionFactory CheckFactory;
-  std::unique_ptr<FrontendActionFactory> FrontendFactory;
-
   // Choose the correct factory based on the selected mode.
   if (Analyze)
-    FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>();
-  else if (Fixit)
-    FrontendFactory = newFrontendActionFactory<FixItAction>();
-  else
-    FrontendFactory = newFrontendActionFactory(&CheckFactory);
-
-  return Tool.run(FrontendFactory.get());
+    return Tool.run(newFrontendActionFactory<clang::ento::AnalysisAction>());
+  if (Fixit)
+    return Tool.run(newFrontendActionFactory<FixItAction>());
+  return Tool.run(newFrontendActionFactory(&CheckFactory));
 }

unittests/AST/ASTContextParentMapTest.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace ast_matchers {
 
-using clang::tooling::newFrontendActionFactory;
 using clang::tooling::runToolOnCodeWithArgs;
 using clang::tooling::FrontendActionFactory;
 
 TEST(GetParents, ReturnsParentForDecl) {
   MatchVerifier<Decl> Verifier;
   EXPECT_TRUE(Verifier.match("class C { void f(); };",
                              methodDecl(hasParent(recordDecl(hasName("C"))))));
 }

unittests/AST/DeclPrinterTest.cpp

::testing::AssertionResult PrintedDeclMatches(
                                   StringRef Code,
                                   const std::vector<std::string> &Args,
                                   const DeclarationMatcher &NodeMatch,
                                   StringRef ExpectedPrinted,
                                   StringRef FileName) {
   PrintMatch Printer;
   MatchFinder Finder;
   Finder.addMatcher(NodeMatch, &Printer);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
 
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
+  if (!runToolOnCodeWithArgs(Factory.create(), Code, Args, FileName))
     return testing::AssertionFailure()
       << "Parsing error in \"" << Code.str() << "\"";
 
   if (Printer.getNumFoundDecls() == 0)
     return testing::AssertionFailure()
         << "Matcher didn't find any declarations";
 
   if (Printer.getNumFoundDecls() > 1)

unittests/AST/DeclTest.cpp

 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::tooling;
 
 TEST(Decl, CleansUpAPValues) {
   MatchFinder Finder;
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
 
   // This is a regression test for a memory leak in APValues for structs that
   // allocate memory. This test only fails if run under valgrind with full leak
   // checking enabled.
   std::vector<std::string> Args(1, "-std=c++11");
   Args.push_back("-fno-ms-extensions");
   ASSERT_TRUE(runToolOnCodeWithArgs(
-      Factory->create(),
+      Factory.create(),
       "struct X { int a; }; constexpr X x = { 42 };"
       "union Y { constexpr Y(int a) : a(a) {} int a; }; constexpr Y y = { 42 };"
       "constexpr int z[2] = { 42, 43 };"
       "constexpr int __attribute__((vector_size(16))) v1 = {};"
       "\n#ifdef __SIZEOF_INT128__\n"
       "constexpr __uint128_t large_int = 0xffffffffffffffff;"
       "constexpr __uint128_t small_int = 1;"
       "\n#endif\n"
       "constexpr double d1 = 42.42;"
       "constexpr long double d2 = 42.42;"
       "constexpr _Complex long double c1 = 42.0i;"
       "constexpr _Complex long double c2 = 42.0;"
       "template<int N> struct A : A<N-1> {};"
       "template<> struct A<0> { int n; }; A<50> a;"
       "constexpr int &r = a.n;"
       "constexpr int A<50>::*p = &A<50>::n;"
       "void f() { foo: bar: constexpr int k = __builtin_constant_p(0) ?"
       "                         (char*)&&foo - (char*)&&bar : 0; }",
       Args));
 
   // FIXME: Once this test starts breaking we can test APValue::needsCleanup
   // for ComplexInt.
   ASSERT_FALSE(runToolOnCodeWithArgs(
-      Factory->create(),
-      "constexpr _Complex __uint128_t c = 0xffffffffffffffff;",
-      Args));
+      Factory.create(),
+      "constexpr _Complex __uint128_t c = 0xffffffffffffffff;", Args));
 }

unittests/AST/EvaluateAsRValueTest.cpp

TEST(EvaluateAsRValue, FailsGracefullyForUnknownTypes) {
   // This is a regression test; the AST library used to trigger assertion
   // failures because it assumed that the type of initializers was always
   // known (which is true only after template instantiation).
   std::string ModesToTest[] = {"-std=c++03", "-std=c++11", "-std=c++1y"};
   for (std::string const &Mode : ModesToTest) {
     std::vector<std::string> Args(1, Mode);
     Args.push_back("-fno-delayed-template-parsing");
     ASSERT_TRUE(runToolOnCodeWithArgs(
-      new EvaluateConstantInitializersAction(),
+        llvm::make_unique<EvaluateConstantInitializersAction>(),
         "template <typename T>"
         "struct vector {"
         "  explicit vector(int size);"
         "};"
         "template <typename R>"
         "struct S {"
         "  vector<R> intervals() const {"
         "    vector<R> Dependent(2);"
         "    return Dependent;"
         "  }"
         "};"
         "void doSomething() {"
         "  int Constant = 2 + 2;"
         "  (void) Constant;"
         "}",
         Args));
   }
 }

unittests/AST/MatchVerifier.h

 /// \brief Runs a matcher over some code, and returns the result of the
 /// verifier for the matched node.
 template <typename NodeType> template <typename MatcherType>
 testing::AssertionResult MatchVerifier<NodeType>::match(
     const std::string &Code, const MatcherType &AMatcher,
     std::vector<std::string>& Args, Language L) {
   MatchFinder Finder;
   Finder.addMatcher(AMatcher.bind(""), this);
-  std::unique_ptr<tooling::FrontendActionFactory> Factory(
-      tooling::newFrontendActionFactory(&Finder));
+  auto Factory = tooling::newFrontendActionFactory(&Finder);
 
   StringRef FileName;
   switch (L) {
   case Lang_C:
     Args.push_back("-std=c99");
     FileName = "input.c";
     break;
   case Lang_C89:
case Lang_CXX11:
     FileName = "input.cc";
     break;
   case Lang_OpenCL:
     FileName = "input.cl";
   }
 
   // Default to failure in case callback is never called
   setFailure("Could not find match");
-  if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
+  if (!tooling::runToolOnCodeWithArgs(Factory.create(), Code, Args, FileName))
     return testing::AssertionFailure() << "Parsing error";
   if (!Verified)
     return testing::AssertionFailure() << VerifyResult;
   return testing::AssertionSuccess();
 }
 
 template <typename NodeType>
 void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {

unittests/AST/NamedDeclPrinterTest.cpp

 ::testing::AssertionResult
 PrintedNamedDeclMatches(StringRef Code, const std::vector<std::string> &Args,
                         bool SuppressUnwrittenScope,
                         const DeclarationMatcher &NodeMatch,
                         StringRef ExpectedPrinted, StringRef FileName) {
   PrintMatch Printer(SuppressUnwrittenScope);
   MatchFinder Finder;
   Finder.addMatcher(NodeMatch, &Printer);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
 
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
+  if (!runToolOnCodeWithArgs(Factory.create(), Code, Args, FileName))
     return testing::AssertionFailure()
         << "Parsing error in \"" << Code.str() << "\"";
 
   if (Printer.getNumFoundDecls() == 0)
     return testing::AssertionFailure()
         << "Matcher didn't find any named declarations";
 
   if (Printer.getNumFoundDecls() > 1)

unittests/AST/StmtPrinterTest.cpp

 template <typename T>
 ::testing::AssertionResult
 PrintedStmtMatches(StringRef Code, const std::vector<std::string> &Args,
                    const T &NodeMatch, StringRef ExpectedPrinted) {
 
   PrintMatch Printer;
   MatchFinder Finder;
   Finder.addMatcher(NodeMatch, &Printer);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
 
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args))
+  if (!runToolOnCodeWithArgs(Factory.create(), Code, Args))
     return testing::AssertionFailure()
       << "Parsing error in \"" << Code.str() << "\"";
 
   if (Printer.getNumFoundStmts() == 0)
     return testing::AssertionFailure()
         << "Matcher didn't find any statements";
 
   if (Printer.getNumFoundStmts() > 1)

unittests/ASTMatchers/ASTMatchersTest.h

testing::AssertionResult matchesConditionally(const std::string &Code,
                                               llvm::StringRef CompileArg) {
   bool Found = false, DynamicFound = false;
   MatchFinder Finder;
   VerifyMatch VerifyFound(nullptr, &Found);
   Finder.addMatcher(AMatcher, &VerifyFound);
   VerifyMatch VerifyDynamicFound(nullptr, &DynamicFound);
   if (!Finder.addDynamicMatcher(AMatcher, &VerifyDynamicFound))
     return testing::AssertionFailure() << "Could not add dynamic matcher";
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
   // Some tests use typeof, which is a gnu extension.
   std::vector<std::string> Args(1, CompileArg);
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args)) {
+  if (!runToolOnCodeWithArgs(Factory.create(), Code, Args)) {
     return testing::AssertionFailure() << "Parsing error in \"" << Code << "\"";
   }
   if (Found != DynamicFound) {
     return testing::AssertionFailure() << "Dynamic match result ("
                                        << DynamicFound
                                        << ") does not match static result ("
                                        << Found << ")";
   }

 matchAndVerifyResultConditionally(const std::string &Code, const T &AMatcher,
                                   BoundNodesCallback *FindResultVerifier,
                                   bool ExpectResult) {
   std::unique_ptr<BoundNodesCallback> ScopedVerifier(FindResultVerifier);
   bool VerifiedResult = false;
   MatchFinder Finder;
   VerifyMatch VerifyVerifiedResult(FindResultVerifier, &VerifiedResult);
   Finder.addMatcher(AMatcher, &VerifyVerifiedResult);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
+  auto Factory = newFrontendActionFactory(&Finder);
   // Some tests use typeof, which is a gnu extension.
   std::vector<std::string> Args(1, "-std=gnu++98");
-  if (!runToolOnCodeWithArgs(Factory->create(), Code, Args)) {
+  if (!runToolOnCodeWithArgs(Factory.create(), Code, Args)) {
     return testing::AssertionFailure() << "Parsing error in \"" << Code << "\"";
   }
   if (!VerifiedResult && ExpectResult) {
     return testing::AssertionFailure()
       << "Could not verify result in \"" << Code << "\"";
   } else if (VerifiedResult && !ExpectResult) {
     return testing::AssertionFailure()
       << "Verified unexpected result in \"" << Code << "\"";

unittests/ASTMatchers/ASTMatchersTest.cpp

public:
   }
   bool Called;
 };
 
 TEST(MatchFinder, InterceptsStartOfTranslationUnit) {
   MatchFinder Finder;
   VerifyStartOfTranslationUnit VerifyCallback;
   Finder.addMatcher(decl(), &VerifyCallback);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
-  ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
+  auto Factory = newFrontendActionFactory(&Finder);
+  ASSERT_TRUE(tooling::runToolOnCode(Factory.create(), "int x;"));
   EXPECT_TRUE(VerifyCallback.Called);
 
   VerifyCallback.Called = false;
   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
   ASSERT_TRUE(AST.get());
   Finder.matchAST(AST->getASTContext());
   EXPECT_TRUE(VerifyCallback.Called);
 }
public:
   }
   bool Called;
 };
 
 TEST(MatchFinder, InterceptsEndOfTranslationUnit) {
   MatchFinder Finder;
   VerifyEndOfTranslationUnit VerifyCallback;
   Finder.addMatcher(decl(), &VerifyCallback);
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Finder));
-  ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
+  auto Factory = newFrontendActionFactory(&Finder);
+  ASSERT_TRUE(tooling::runToolOnCode(Factory.create(), "int x;"));
   EXPECT_TRUE(VerifyCallback.Called);
 
   VerifyCallback.Called = false;
   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
   ASSERT_TRUE(AST.get());
   Finder.matchAST(AST->getASTContext());
   EXPECT_TRUE(VerifyCallback.Called);
 }

unittests/Sema/ExternalSemaSourceTest.cpp

public:
 
   void PushWatcher(NamespaceDiagnosticWatcher *Watcher) {
     Watchers.push_back(Watcher);
   }
 };
 
 // Make sure that the NamespaceDiagnosticWatcher is not miscounting.
 TEST(ExternalSemaSource, SanityCheck) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   NamespaceDiagnosticWatcher Watcher("AAB", "BBB");
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_EQ(0, Watcher.SeenCount);
 }
 
 // Check that when we add a NamespaceTypeProvider, we use that suggestion
 // instead of the usual suggestion we would use above.
 TEST(ExternalSemaSource, ExternalTypoCorrectionPrioritized) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider Provider("AAB", "BBB");
   NamespaceDiagnosticWatcher Watcher("AAB", "BBB");
   Installer->PushSource(&Provider);
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_LE(0, Provider.CallCount);
   ASSERT_EQ(1, Watcher.SeenCount);
 }
 
 // Check that we use the first successful TypoCorrection returned from an
 // ExternalSemaSource.
 TEST(ExternalSemaSource, ExternalTypoCorrectionOrdering) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider First("XXX", "BBB");
   NamespaceTypoProvider Second("AAB", "CCC");
   NamespaceTypoProvider Third("AAB", "DDD");
   NamespaceDiagnosticWatcher Watcher("AAB", "CCC");
   Installer->PushSource(&First);
   Installer->PushSource(&Second);
   Installer->PushSource(&Third);
   Installer->PushWatcher(&Watcher);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "namespace AAA { } using namespace AAB;", Args));
+      std::move(Installer), "namespace AAA { } using namespace AAB;", Args));
   ASSERT_LE(1, First.CallCount);
   ASSERT_LE(1, Second.CallCount);
   ASSERT_EQ(0, Third.CallCount);
   ASSERT_EQ(1, Watcher.SeenCount);
 }
 
 // We should only try MaybeDiagnoseMissingCompleteType if we can't otherwise
 // solve the problem.
 TEST(ExternalSemaSource, TryOtherTacticsBeforeDiagnosing) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   CompleteTypeDiagnoser Diagnoser(false);
   Installer->PushSource(&Diagnoser);
   std::vector<std::string> Args(1, "-std=c++11");
   // This code hits the class template specialization/class member of a class
   // template specialization checks in Sema::RequireCompleteTypeImpl.
   ASSERT_TRUE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(),
+      std::move(Installer),
       "template <typename T> struct S { class C { }; }; S<char>::C SCInst;",
       Args));
   ASSERT_EQ(0, Diagnoser.CallCount);
 }
 
 // The first ExternalSemaSource where MaybeDiagnoseMissingCompleteType returns
 // true should be the last one called.
 TEST(ExternalSemaSource, FirstDiagnoserTaken) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = llvm::make_unique<ExternalSemaSourceInstaller>();
   CompleteTypeDiagnoser First(false);
   CompleteTypeDiagnoser Second(true);
   CompleteTypeDiagnoser Third(true);
   Installer->PushSource(&First);
   Installer->PushSource(&Second);
   Installer->PushSource(&Third);
   std::vector<std::string> Args(1, "-std=c++11");
   ASSERT_FALSE(clang::tooling::runToolOnCodeWithArgs(
-      Installer.release(), "class Incomplete; Incomplete IncompleteInstance;",
+      std::move(Installer), "class Incomplete; Incomplete IncompleteInstance;",
       Args));
   ASSERT_EQ(1, First.CallCount);
   ASSERT_EQ(1, Second.CallCount);
   ASSERT_EQ(0, Third.CallCount);
 }
 
 } // anonymous namespace

unittests/Tooling/CommentHandlerTest.cpp

virtual bool HandleComment(Preprocessor &PP, SourceRange Loc) {
 
     Comments.push_back(Comment(C, CLine, CCol));
     return false;
   }
 
   CommentVerifier GetVerifier();
 
 protected:
-  virtual ASTFrontendAction* CreateTestAction() {
-    return new CommentHandlerAction(this);
+  virtual std::unique_ptr<ASTFrontendAction> CreateTestAction() {
+    return llvm::make_unique<CommentHandlerAction>(this);
   }
 
 private:
   Preprocessor *PP;
   CommentList Comments;
   bool Verified;
 
   class CommentHandlerAction : public base::TestAction {

unittests/Tooling/RefactoringCallbacksTest.cpp

 
 template <typename T>
 void expectRewritten(const std::string &Code,
                      const std::string &Expected,
                      const T &AMatcher,
                      RefactoringCallback &Callback) {
   MatchFinder Finder;
   Finder.addMatcher(AMatcher, &Callback);
-  std::unique_ptr<tooling::FrontendActionFactory> Factory(
-      tooling::newFrontendActionFactory(&Finder));
-  ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
+  auto Factory = tooling::newFrontendActionFactory(&Finder);
+  ASSERT_TRUE(tooling::runToolOnCode(Factory.create(), Code))
       << "Parsing error in \"" << Code << "\"";
   RewriterTestContext Context;
   FileID ID = Context.createInMemoryFile("input.cc", Code);
   EXPECT_TRUE(tooling::applyAllReplacements(Callback.getReplacements(),
                                             Context.Rewrite));
   EXPECT_EQ(Expected, Context.getRewrittenText(ID));
 }
 

unittests/Tooling/RefactoringTest.cpp

EXPECT_EQ("line1\nreplaced\nline3\nline4",
             getFileContentFromDisk("input.cpp"));
 }
 
 namespace {
 template <typename T>
 class TestVisitor : public clang::RecursiveASTVisitor<T> {
 public:
   bool runOver(StringRef Code) {
-    return runToolOnCode(new TestAction(this), Code);
+    return runToolOnCode(llvm::make_unique<TestAction>(this), Code);
   }
 
 protected:
   clang::SourceManager *SM;
 
 private:
   class FindConsumer : public clang::ASTConsumer {
   public:

unittests/Tooling/TestVisitor.h

bool shouldVisitTemplateInstantiations() const {
     return true;
   }
 
   bool shouldVisitImplicitCode() const {
     return true;
   }
 
 protected:
-  virtual ASTFrontendAction* CreateTestAction() {
-    return new TestAction(this);
+  virtual std::unique_ptr<ASTFrontendAction> CreateTestAction() {
+    return llvm::make_unique<TestAction>(this);
   }
 
   class FindConsumer : public ASTConsumer {
   public:
     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
 
     virtual void HandleTranslationUnit(clang::ASTContext &Context) {
       Visitor->Context = &Context;

unittests/Tooling/ToolingTest.cpp

public:
   }
  private:
   bool * const FoundTopLevelDecl;
 };
 } // end namespace
 
 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
   bool FoundTopLevelDecl = false;
-  EXPECT_TRUE(runToolOnCode(
-      new TestAction(new FindTopLevelDeclConsumer(&FoundTopLevelDecl)), ""));
+  EXPECT_TRUE(
+      runToolOnCode(llvm::make_unique<TestAction>(
+                        new FindTopLevelDeclConsumer(&FoundTopLevelDecl)),
+                    ""));
   EXPECT_FALSE(FoundTopLevelDecl);
 }
 
 namespace {
 class FindClassDeclXConsumer : public clang::ASTConsumer {
  public:
   FindClassDeclXConsumer(bool *FoundClassDeclX)
       : FoundClassDeclX(FoundClassDeclX) {}
for (std::vector<Decl *>::iterator i = AST->top_level_begin(),
     }
   }
   return false;
 }
 } // end namespace
 
 TEST(runToolOnCode, FindsClassDecl) {
   bool FoundClassDeclX = false;
-  EXPECT_TRUE(runToolOnCode(new TestAction(
-      new FindClassDeclXConsumer(&FoundClassDeclX)), "class X;"));
+  EXPECT_TRUE(runToolOnCode(llvm::make_unique<TestAction>(
+                                new FindClassDeclXConsumer(&FoundClassDeclX)),
+                            "class X;"));
   EXPECT_TRUE(FoundClassDeclX);
 
   FoundClassDeclX = false;
-  EXPECT_TRUE(runToolOnCode(new TestAction(
-      new FindClassDeclXConsumer(&FoundClassDeclX)), "class Y;"));
+  EXPECT_TRUE(runToolOnCode(llvm::make_unique<TestAction>(
+                                new FindClassDeclXConsumer(&FoundClassDeclX)),
+                            "class Y;"));
   EXPECT_FALSE(FoundClassDeclX);
 }
 
 TEST(buildASTFromCode, FindsClassDecl) {
   std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
   ASSERT_TRUE(AST.get());
   EXPECT_TRUE(FindClassDeclX(AST.get()));
 
   AST = buildASTFromCode("class Y;");
   ASSERT_TRUE(AST.get());
   EXPECT_FALSE(FindClassDeclX(AST.get()));
 }
 
 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) {
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory<SyntaxOnlyAction>());
-  std::unique_ptr<FrontendAction> Action(Factory->create());
+  auto Factory = newFrontendActionFactory<SyntaxOnlyAction>();
+  std::unique_ptr<FrontendAction> Action = Factory.create();
   EXPECT_TRUE(Action.get() != nullptr);
 }
 
 struct IndependentFrontendActionCreator {
   ASTConsumer *newASTConsumer() {
     return new FindTopLevelDeclConsumer(nullptr);
   }
 };
 
 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) {
   IndependentFrontendActionCreator Creator;
-  std::unique_ptr<FrontendActionFactory> Factory(
-      newFrontendActionFactory(&Creator));
-  std::unique_ptr<FrontendAction> Action(Factory->create());
+  auto Factory = newFrontendActionFactory(&Creator);
+  std::unique_ptr<FrontendAction> Action = Factory.create();
   EXPECT_TRUE(Action.get() != nullptr);
 }
 
 TEST(ToolInvocation, TestMapVirtualFile) {
   IntrusiveRefCntPtr<clang::FileManager> Files(
       new clang::FileManager(clang::FileSystemOptions()));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");
   Args.push_back("test.cpp");
-  clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
-                                            Files.getPtr());
+  clang::tooling::ToolInvocation Invocation(
+      Args, llvm::make_unique<SyntaxOnlyAction>(), Files.getPtr());
   Invocation.mapVirtualFile("test.cpp", "#include <abc>\n");
   Invocation.mapVirtualFile("def/abc", "\n");
   EXPECT_TRUE(Invocation.run());
 }
 
 TEST(ToolInvocation, TestVirtualModulesCompilation) {
   // FIXME: Currently, this only tests that we don't exit with an error if a
   // mapped module.map is found on the include path. In the future, expand this
   // test to run a full modules enabled compilation, so we make sure we can
   // rerun modules compilations with a virtual file system.
   IntrusiveRefCntPtr<clang::FileManager> Files(
       new clang::FileManager(clang::FileSystemOptions()));
   std::vector<std::string> Args;
   Args.push_back("tool-executable");
   Args.push_back("-Idef");
   Args.push_back("-fsyntax-only");
   Args.push_back("test.cpp");
-  clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction,
-                                            Files.getPtr());
+  clang::tooling::ToolInvocation Invocation(
+      Args, llvm::make_unique<SyntaxOnlyAction>(), Files.getPtr());
   Invocation.mapVirtualFile("test.cpp", "#include <abc>\n");
   Invocation.mapVirtualFile("def/abc", "\n");
   // Add a module.map file in the include directory of our header, so we trigger
   // the module.map header search logic.
   Invocation.mapVirtualFile("def/module.map", "\n");
   EXPECT_TRUE(Invocation.run());
 }
 
TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) {
   std::vector<std::string> Sources;
   Sources.push_back("/a.cc");
   Sources.push_back("/b.cc");
   ClangTool Tool(Compilations, Sources);
 
   Tool.mapVirtualFile("/a.cc", "void a() {}");
   Tool.mapVirtualFile("/b.cc", "void b() {}");
 
-  std::unique_ptr<FrontendActionFactory> Action(
-      newFrontendActionFactory(&EndCallback, &EndCallback));
-  Tool.run(Action.get());
+  auto Action = newFrontendActionFactory(&EndCallback, &EndCallback);
+  Tool.run(Action);
 
   EXPECT_TRUE(EndCallback.Matched);
   EXPECT_EQ(2u, EndCallback.BeginCalled);
   EXPECT_EQ(2u, EndCallback.EndCalled);
 }
 #endif
 
 struct SkipBodyConsumer : public clang::ASTConsumer {
   /// Skip the 'skipMe' function.
   virtual bool shouldSkipFunctionBody(Decl *D) {
     FunctionDecl *F = dyn_cast<FunctionDecl>(D);
     return F && F->getNameAsString() == "skipMe";
   }
 };
 
 struct SkipBodyAction : public clang::ASTFrontendAction {
   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler,
                                          StringRef) {
     Compiler.getFrontendOpts().SkipFunctionBodies = true;
     return new SkipBodyConsumer;
   }
 };
 
 TEST(runToolOnCode, TestSkipFunctionBody) {
-  EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
+  EXPECT_TRUE(runToolOnCode(llvm::make_unique<SkipBodyAction>(),
                             "int skipMe() { an_error_here }"));
-  EXPECT_FALSE(runToolOnCode(new SkipBodyAction,
+  EXPECT_FALSE(runToolOnCode(llvm::make_unique<SkipBodyAction>(),
                              "int skipMeNot() { an_error_here }"));
 }
 
 TEST(runToolOnCodeWithArgs, TestNoDepFile) {
   llvm::SmallString<32> DepFilePath;
   ASSERT_FALSE(
       llvm::sys::fs::createTemporaryFile("depfile", "d", DepFilePath));
   std::vector<std::string> Args;
   Args.push_back("-MMD");
   Args.push_back("-MT");
   Args.push_back(DepFilePath.str());
   Args.push_back("-MF");
   Args.push_back(DepFilePath.str());
-  EXPECT_TRUE(runToolOnCodeWithArgs(new SkipBodyAction, "", Args));
+  EXPECT_TRUE(
+      runToolOnCodeWithArgs(llvm::make_unique<SkipBodyAction>(), "", Args));
   EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str()));
   EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str()));
 }
 
 struct CheckSyntaxOnlyAdjuster: public ArgumentsAdjuster {
   bool &Found;
   bool &Ran;
 

 };
 
 TEST(ClangToolTest, ArgumentAdjusters) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
 
   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
   Tool.mapVirtualFile("/a.cc", "void a() {}");
 
-  std::unique_ptr<FrontendActionFactory> Action(
-      newFrontendActionFactory<SyntaxOnlyAction>());
+  auto Action = newFrontendActionFactory<SyntaxOnlyAction>();
 
   bool Found = false;
   bool Ran = false;
   Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
-  Tool.run(Action.get());
+  Tool.run(Action);
   EXPECT_TRUE(Ran);
   EXPECT_TRUE(Found);
 
   Ran = Found = false;
   Tool.clearArgumentsAdjusters();
   Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
   Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster());
-  Tool.run(Action.get());
+  Tool.run(Action);
   EXPECT_TRUE(Ran);
   EXPECT_FALSE(Found);
 }
 
 #ifndef LLVM_ON_WIN32
 TEST(ClangToolTest, BuildASTs) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
 

 };
 
 TEST(ClangToolTest, InjectDiagnosticConsumer) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
   Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
   TestDiagnosticConsumer Consumer;
   Tool.setDiagnosticConsumer(&Consumer);
-  std::unique_ptr<FrontendActionFactory> Action(
-      newFrontendActionFactory<SyntaxOnlyAction>());
-  Tool.run(Action.get());
+  auto Action = newFrontendActionFactory<SyntaxOnlyAction>();
+  Tool.run(Action);
   EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
 }
 
 TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) {
   FixedCompilationDatabase Compilations("/", std::vector<std::string>());
   ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
   Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
   TestDiagnosticConsumer Consumer;