[Tooling] Migrated APIs that take ownership of objects to unique_ptr

[lebedev.ri]

This is missing documentation changes.
And this likely would be good to mention in releasenotes.

[gribozavr]

In D66960#1651198, @lebedev.ri wrote:

This is missing documentation changes.

Could you point out such places? I tried to remove "takes ownership" comments which became redundant.

And this likely would be good to mention in releasenotes.

Will add.

[lebedev.ri]

In D66960#1651243, @gribozavr wrote:

In D66960#1651198, @lebedev.ri wrote:

This is missing documentation changes.

Could you point out such places? I tried to remove "takes ownership" comments which became redundant.

See my two original patches.

And this likely would be good to mention in releasenotes.

Will add.

[ilya-biryukov]

LGTM from my side.

[gribozavr]

Updated documentation and added release notes.

[gribozavr]

In D66960#1651258, @lebedev.ri wrote:

In D66960#1651243, @gribozavr wrote:

In D66960#1651198, @lebedev.ri wrote:

This is missing documentation changes.

Could you point out such places? I tried to remove "takes ownership" comments which became redundant.

See my two original patches.

Thanks, fixed docs.

And this likely would be good to mention in releasenotes.

Will add.

Added release notes.

cfe/trunk/docs/LibTooling.rst

 
 .. code-block:: c++
 
   #include "clang/Tooling/Tooling.h"
 
   TEST(runToolOnCode, CanSyntaxCheckCode) {
     // runToolOnCode returns whether the action was correctly run over the
     // given code.
-    EXPECT_TRUE(runToolOnCode(new clang::SyntaxOnlyAction, "class X {};"));
+    EXPECT_TRUE(runToolOnCode(std::make_unique<clang::SyntaxOnlyAction>(), "class X {};"));
   }
 
 Writing a standalone tool
 -------------------------
 
 Once you unit tested your ``FrontendAction`` to the point where it cannot
 possibly break, it's time to create a standalone tool.  For a standalone tool
 to run clang, it first needs to figure out what command line arguments to use

cfe/trunk/docs/RAVFrontendAction.rst

::
           clang::CompilerInstance &Compiler, llvm::StringRef InFile) {
           return std::unique_ptr<clang::ASTConsumer>(
               new FindNamedClassConsumer(&Compiler.getASTContext()));
         }
       };
 
       int main(int argc, char **argv) {
         if (argc > 1) {
-          clang::tooling::runToolOnCode(new FindNamedClassAction, argv[1]);
+          clang::tooling::runToolOnCode(std::make_unique<FindNamedClassAction>(), argv[1]);
         }
       }
 
 We store this into a file called FindClassDecls.cpp and create the
 following CMakeLists.txt to link it:
 
 ::
 

cfe/trunk/docs/ReleaseNotes.rst

 
 Internal API Changes
 --------------------
 
 These are major API changes that have happened since the 9.0.0 release of
 Clang. If upgrading an external codebase that uses Clang as a library,
 this section should help get you past the largest hurdles of upgrading.
 
+- libTooling APIs that transfer ownership of `FrontendAction` objects now pass
+  them by `unique_ptr`, making the ownership transfer obvious in the type
+  system. `FrontendActionFactory::create()` now returns a
+  `unique_ptr<FrontendAction>`. `runToolOnCode`, `runToolOnCodeWithArgs`,
+  `ToolInvocation::ToolInvocation()` now take a `unique_ptr<FrontendAction>`.
+
 Build System Changes
 --------------------
 
 These are major changes to the build system that have happened since the 9.0.0
 release of Clang. Users of the build system should adjust accordingly.
 
 - In 8.0.0 and below, the install-clang-headers target would install clang's
   resource directory headers. This installation is now performed by the

cfe/trunk/include/clang/Tooling/Tooling.h

 ///
 /// \param ToolAction The action to run over the code.
 /// \param Code C++ code.
 /// \param FileName The file name which 'Code' will be mapped as.
 /// \param PCHContainerOps  The PCHContainerOperations for loading and creating
 ///                         clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
-bool runToolOnCode(FrontendAction *ToolAction, const Twine &Code,
+bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
                    const Twine &FileName = "input.cc",
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                        std::make_shared<PCHContainerOperations>());
 
-inline bool
-runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
-              const Twine &FileName = "input.cc",
-              std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-                  std::make_shared<PCHContainerOperations>()) {
-  return runToolOnCode(ToolAction.release(), Code, FileName, PCHContainerOps);
-}
-
 /// The first part of the pair is the filename, the second part the
 /// file-content.
 using FileContentMappings = std::vector<std::pair<std::string, std::string>>;
 
 /// 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.
 /// \param ToolName The name of the binary running the tool. Standard library
 ///                 header paths will be resolved relative to this.
 /// \param PCHContainerOps   The PCHContainerOperations for loading and creating
 ///                          clang modules.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
 bool runToolOnCodeWithArgs(
-    FrontendAction *ToolAction, const Twine &Code,
-    const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
-    const Twine &ToolName = "clang-tool",
-    std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-        std::make_shared<PCHContainerOperations>(),
-    const FileContentMappings &VirtualMappedFiles = FileContentMappings());
-
-inline bool runToolOnCodeWithArgs(
     std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
     const Twine &ToolName = "clang-tool",
     std::shared_ptr<PCHContainerOperations> PCHContainerOps =
         std::make_shared<PCHContainerOperations>(),
-    const FileContentMappings &VirtualMappedFiles = FileContentMappings()) {
-  return runToolOnCodeWithArgs(ToolAction.release(), Code, Args, FileName,
-                               ToolName, PCHContainerOps, VirtualMappedFiles);
-}
+    const FileContentMappings &VirtualMappedFiles = FileContentMappings());
 
 // Similar to the overload except this takes a VFS.
 bool runToolOnCodeWithArgs(
-    FrontendAction *ToolAction, const Twine &Code,
-    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-    const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
-    const Twine &ToolName = "clang-tool",
-    std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-        std::make_shared<PCHContainerOperations>());
-
-inline bool runToolOnCodeWithArgs(
     std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
     const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
     const Twine &ToolName = "clang-tool",
     std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-        std::make_shared<PCHContainerOperations>()) {
-  return runToolOnCodeWithArgs(ToolAction.release(), Code, VFS, Args, FileName,
-                               ToolName, PCHContainerOps);
-}
+        std::make_shared<PCHContainerOperations>());
 
 /// Builds an AST for 'Code'.
 ///
 /// \param Code C++ code.
 /// \param FileName The file name which 'Code' will be mapped as.
 /// \param PCHContainerOps The PCHContainerOperations for loading and creating
 /// clang modules.
 ///

 class ToolInvocation {
 public:
   /// Create a tool invocation.
   ///
   /// \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 FAction The action to be executed.
   /// \param Files The FileManager used for the execution. Class does not take
   /// ownership.
   /// \param PCHContainerOps The PCHContainerOperations for loading and creating
   /// clang modules.
-  ToolInvocation(std::vector<std::string> CommandLine, FrontendAction *FAction,
-                 FileManager *Files,
-                 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-                     std::make_shared<PCHContainerOperations>());
-
   ToolInvocation(std::vector<std::string> CommandLine,
                  std::unique_ptr<FrontendAction> FAction, FileManager *Files,
                  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
-                     std::make_shared<PCHContainerOperations>())
-      : ToolInvocation(std::move(CommandLine), FAction.release(), Files,
-                       PCHContainerOps) {}
+                     std::make_shared<PCHContainerOperations>());
 
   /// 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.
   /// \param PCHContainerOps The PCHContainerOperations for loading and creating
   /// clang modules.

cfe/trunk/lib/Tooling/Tooling.cpp

CompilerInvocation *newInvocation(
   assert(!CC1Args.empty() && "Must at least contain the program name!");
   CompilerInvocation *Invocation = new CompilerInvocation;
   CompilerInvocation::CreateFromArgs(*Invocation, CC1Args, *Diagnostics);
   Invocation->getFrontendOpts().DisableFree = false;
   Invocation->getCodeGenOpts().DisableFree = false;
   return Invocation;
 }
 
-bool runToolOnCode(FrontendAction *ToolAction, const Twine &Code,
-                   const Twine &FileName,
+bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction,
+                   const Twine &Code, const Twine &FileName,
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
-  return runToolOnCodeWithArgs(ToolAction, Code, std::vector<std::string>(),
-                               FileName, "clang-tool",
-                               std::move(PCHContainerOps));
+  return runToolOnCodeWithArgs(std::move(ToolAction), Code,
+                               std::vector<std::string>(), FileName,
+                               "clang-tool", std::move(PCHContainerOps));
 }
 
 } // namespace tooling
 } // namespace clang
 
 static std::vector<std::string>
 getSyntaxOnlyToolArgs(const Twine &ToolName,
                       const std::vector<std::string> &ExtraArgs,
                       StringRef FileName) {
   std::vector<std::string> Args;
   Args.push_back(ToolName.str());
   Args.push_back("-fsyntax-only");
   Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
   Args.push_back(FileName.str());
   return Args;
 }
 
 namespace clang {
 namespace tooling {
 
 bool runToolOnCodeWithArgs(
-    FrontendAction *ToolAction, const Twine &Code,
+    std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
     const std::vector<std::string> &Args, const Twine &FileName,
     const Twine &ToolName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
   SmallString<16> FileNameStorage;
   StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage);
 
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), VFS));
   ArgumentsAdjuster Adjuster = getClangStripDependencyFileAdjuster();
   ToolInvocation Invocation(
       getSyntaxOnlyToolArgs(ToolName, Adjuster(Args, FileNameRef), FileNameRef),
-      ToolAction, Files.get(),
-      std::move(PCHContainerOps));
+      std::move(ToolAction), Files.get(), std::move(PCHContainerOps));
   return Invocation.run();
 }
 
 bool runToolOnCodeWithArgs(
-    FrontendAction *ToolAction, const Twine &Code,
+    std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
     const std::vector<std::string> &Args, const Twine &FileName,
     const Twine &ToolName,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     const FileContentMappings &VirtualMappedFiles) {
   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
 
   SmallString<1024> CodeStorage;
   InMemoryFileSystem->addFile(FileName, 0,
                               llvm::MemoryBuffer::getMemBuffer(
                                   Code.toNullTerminatedStringRef(CodeStorage)));
 
   for (auto &FilenameWithContent : VirtualMappedFiles) {
     InMemoryFileSystem->addFile(
         FilenameWithContent.first, 0,
         llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));
   }
 
-  return runToolOnCodeWithArgs(ToolAction, Code, OverlayFileSystem, Args,
-                               FileName, ToolName);
+  return runToolOnCodeWithArgs(std::move(ToolAction), Code, OverlayFileSystem,
+                               Args, FileName, ToolName);
 }
 
 llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS,
                                             StringRef File) {
   StringRef RelativePath(File);
   // FIXME: Should '.\\' be accepted on Win32?
   if (RelativePath.startswith("./")) {
     RelativePath = RelativePath.substr(strlen("./"));

 
 ToolInvocation::ToolInvocation(
     std::vector<std::string> CommandLine, ToolAction *Action,
     FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)), Action(Action), OwnsAction(false),
       Files(Files), PCHContainerOps(std::move(PCHContainerOps)) {}
 
 ToolInvocation::ToolInvocation(
-    std::vector<std::string> CommandLine, FrontendAction *FAction,
-    FileManager *Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)
+    std::vector<std::string> CommandLine,
+    std::unique_ptr<FrontendAction> FAction, FileManager *Files,
+    std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : CommandLine(std::move(CommandLine)),
-      Action(new SingleFrontendActionFactory(
-          std::unique_ptr<FrontendAction>(FAction))),
+      Action(new SingleFrontendActionFactory(std::move(FAction))),
       OwnsAction(true), Files(Files),
       PCHContainerOps(std::move(PCHContainerOps)) {}
 
 ToolInvocation::~ToolInvocation() {
   if (OwnsAction)
     delete Action;
 }
 

cfe/trunk/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(),
+        std::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));
   }
 }

cfe/trunk/unittests/AST/RecursiveASTVisitorTest.cpp

 
 private:
   std::vector<VisitEvent> Events;
 };
 
 std::vector<VisitEvent> collectEvents(llvm::StringRef Code) {
   CollectInterestingEvents Visitor;
   clang::tooling::runToolOnCode(
-      new ProcessASTAction(
+      std::make_unique<ProcessASTAction>(
           [&](clang::ASTContext &Ctx) { Visitor.TraverseAST(Ctx); }),
       Code);
   return std::move(Visitor).takeEvents();
 }
 } // namespace
 
 TEST(RecursiveASTVisitorTest, AttributesInsideDecls) {
   /// Check attributes are traversed inside TraverseFunctionDecl.

cfe/trunk/unittests/CrossTU/CrossTranslationUnitTest.cpp

private:
   bool *Success;
   const unsigned OverrideLimit;
 };
 
 } // end namespace
 
 TEST(CrossTranslationUnit, CanLoadFunctionDefinition) {
   bool Success = false;
-  EXPECT_TRUE(
-      tooling::runToolOnCode(new CTUAction(&Success, 1u), "int f(int);"));
+  EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 1u),
+                                     "int f(int);"));
   EXPECT_TRUE(Success);
 }
 
 TEST(CrossTranslationUnit, RespectsLoadThreshold) {
   bool Success = false;
-  EXPECT_TRUE(
-      tooling::runToolOnCode(new CTUAction(&Success, 0u), "int f(int);"));
+  EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<CTUAction>(&Success, 0u),
+                                     "int f(int);"));
   EXPECT_FALSE(Success);
 }
 
 TEST(CrossTranslationUnit, IndexFormatCanBeParsed) {
   llvm::StringMap<std::string> Index;
   Index["a"] = "/b/f1";
   Index["c"] = "/d/f2";
   Index["e"] = "/f/f3";

cfe/trunk/unittests/Index/IndexTests.cpp

 MATCHER_P(QName, Name, "") { return arg.QName == Name; }
 MATCHER_P(WrittenAt, Pos, "") { return arg.WrittenPos == Pos; }
 MATCHER_P(DeclAt, Pos, "") { return arg.DeclPos == Pos; }
 MATCHER_P(Kind, SymKind, "") { return arg.SymInfo.Kind == SymKind; }
 MATCHER_P(HasRole, Role, "") { return arg.Roles & static_cast<unsigned>(Role); }
 
 TEST(IndexTest, Simple) {
   auto Index = std::make_shared<Indexer>();
-  tooling::runToolOnCode(new IndexAction(Index), "class X {}; void f() {}");
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index),
+                         "class X {}; void f() {}");
   EXPECT_THAT(Index->Symbols, UnorderedElementsAre(QName("X"), QName("f")));
 }
 
 TEST(IndexTest, IndexPreprocessorMacros) {
   std::string Code = "#define INDEX_MAC 1";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
   Opts.IndexMacrosInPreprocessor = true;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, Contains(QName("INDEX_MAC")));
 
   Opts.IndexMacrosInPreprocessor = false;
   Index->Symbols.clear();
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, UnorderedElementsAre());
 }
 
 TEST(IndexTest, IndexParametersInDecls) {
   std::string Code = "void foo(int bar);";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
   Opts.IndexFunctionLocals = true;
   Opts.IndexParametersInDeclarations = true;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, Contains(QName("bar")));
 
   Opts.IndexParametersInDeclarations = false;
   Index->Symbols.clear();
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, Not(Contains(QName("bar"))));
 }
 
 TEST(IndexTest, IndexExplicitTemplateInstantiation) {
   std::string Code = R"cpp(
     template <typename T>
     struct Foo { void bar() {} };
     template <>
     struct Foo<int> { void bar() {} };
     void foo() {
       Foo<char> abc;
       Foo<int> b;
     }
   )cpp";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               AllOf(Contains(AllOf(QName("Foo"), WrittenAt(Position(8, 7)),
                                    DeclAt(Position(5, 12)))),
                     Contains(AllOf(QName("Foo"), WrittenAt(Position(7, 7)),
                                    DeclAt(Position(3, 12))))));
 }
 
 TEST(IndexTest, IndexTemplateInstantiationPartial) {
   std::string Code = R"cpp(
     template <typename T1, typename T2>
     struct Foo { void bar() {} };
     template <typename T>
     struct Foo<T, int> { void bar() {} };
     void foo() {
       Foo<char, char> abc;
       Foo<int, int> b;
     }
   )cpp";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               Contains(AllOf(QName("Foo"), WrittenAt(Position(8, 7)),
                              DeclAt(Position(5, 12)))));
 }
 
 TEST(IndexTest, IndexTypeParmDecls) {
   std::string Code = R"cpp(
     template <typename T, int I, template<typename> class C, typename NoRef>
     struct Foo {
       T t = I;
       C<int> x;
     };
   )cpp";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, AllOf(Not(Contains(QName("Foo::T"))),
                                     Not(Contains(QName("Foo::I"))),
                                     Not(Contains(QName("Foo::C"))),
                                     Not(Contains(QName("Foo::NoRef")))));
 
   Opts.IndexTemplateParameters = true;
   Index->Symbols.clear();
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               AllOf(Contains(QName("Foo::T")), Contains(QName("Foo::I")),
                     Contains(QName("Foo::C")), Contains(QName("Foo::NoRef"))));
 }
 
 TEST(IndexTest, UsingDecls) {
   std::string Code = R"cpp(
     void foo(int bar);
     namespace std {
       using ::foo;
     }
   )cpp";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               Contains(AllOf(QName("std::foo"), Kind(SymbolKind::Using))));
 }
 
 TEST(IndexTest, Constructors) {
   std::string Code = R"cpp(
     struct Foo {
       Foo(int);
       ~Foo();
     };
   )cpp";
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
-  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index, Opts), Code);
   EXPECT_THAT(
       Index->Symbols,
       UnorderedElementsAre(
           AllOf(QName("Foo"), Kind(SymbolKind::Struct),
                 WrittenAt(Position(2, 12))),
           AllOf(QName("Foo::Foo"), Kind(SymbolKind::Constructor),
                 WrittenAt(Position(3, 7))),
           AllOf(QName("Foo"), Kind(SymbolKind::Struct),

cfe/trunk/unittests/Sema/CodeCompleteTest.cpp

ParsedSourceLocation offsetToPosition(llvm::StringRef Code, size_t Offset) {
   size_t PrevNL = Before.rfind('\n');
   size_t StartOfLine = (PrevNL == StringRef::npos) ? 0 : (PrevNL + 1);
   return {TestCCName, static_cast<unsigned>(Lines + 1),
           static_cast<unsigned>(Offset - StartOfLine + 1)};
 }
 
 CompletionContext runCompletion(StringRef Code, size_t Offset) {
   CompletionContext ResultCtx;
-  auto Action = std::make_unique<CodeCompleteAction>(
-      offsetToPosition(Code, Offset), ResultCtx);
-  clang::tooling::runToolOnCodeWithArgs(Action.release(), Code, {"-std=c++11"},
-                                        TestCCName);
+  clang::tooling::runToolOnCodeWithArgs(
+      std::make_unique<CodeCompleteAction>(offsetToPosition(Code, Offset),
+                                           ResultCtx),
+      Code, {"-std=c++11"}, TestCCName);
   return ResultCtx;
 }
 
 CompletionContext runCodeCompleteOnCode(StringRef AnnotatedCode) {
   llvm::Annotations A(AnnotatedCode);
   return runCompletion(A.code(), A.point());
 }
 

cfe/trunk/unittests/Sema/ExternalSemaSourceTest.cpp

void PushSource(clang::ExternalSemaSource *Source) {
     Sources.push_back(Source);
   }
 
   void PushWatcher(DiagnosticWatcher *Watcher) { Watchers.push_back(Watcher); }
 };
 
 // Make sure that the DiagnosticWatcher is not miscounting.
 TEST(ExternalSemaSource, SanityCheck) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
   DiagnosticWatcher 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 = std::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider Provider("AAB", "BBB");
   DiagnosticWatcher 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 = std::make_unique<ExternalSemaSourceInstaller>();
   NamespaceTypoProvider First("XXX", "BBB");
   NamespaceTypoProvider Second("AAB", "CCC");
   NamespaceTypoProvider Third("AAB", "DDD");
   DiagnosticWatcher 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);
 }
 
 TEST(ExternalSemaSource, ExternalDelayedTypoCorrection) {
-  std::unique_ptr<ExternalSemaSourceInstaller> Installer(
-      new ExternalSemaSourceInstaller);
+  auto Installer = std::make_unique<ExternalSemaSourceInstaller>();
   FunctionTypoProvider Provider("aaa", "bbb");
   DiagnosticWatcher Watcher("aaa", "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 { } void foo() { AAA::aaa(); }",
+      std::move(Installer), "namespace AAA { } void foo() { AAA::aaa(); }",
       Args));
   ASSERT_LE(0, Provider.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 = std::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 = std::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

cfe/trunk/unittests/StaticAnalyzer/CallDescriptionTest.cpp

std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef File) override {
     return std::make_unique<CallDescriptionConsumer>(Compiler, RM);
   }
 };
 
 TEST(CallEvent, CallDescription) {
   // Test simple name matching.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{"bar"}, false}, // false: there's no call to 'bar' in this code.
           {{"foo"}, true},  // true: there's a call to 'foo' in this code.
-      }), "void foo(); void bar() { foo(); }"));
+      })), "void foo(); void bar() { foo(); }"));
 
   // Test arguments check.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{"foo", 1}, true},
           {{"foo", 2}, false},
-      }), "void foo(int); void foo(int, int); void bar() { foo(1); }"));
+      })), "void foo(int); void foo(int, int); void bar() { foo(1); }"));
 
   // Test lack of arguments check.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{"foo", None}, true},
           {{"foo", 2}, false},
-      }), "void foo(int); void foo(int, int); void bar() { foo(1); }"));
+      })), "void foo(int); void foo(int, int); void bar() { foo(1); }"));
 
   // Test qualified names.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{{"std", "basic_string", "c_str"}}, true},
-      }),
+      })),
       "namespace std { inline namespace __1 {"
       "  template<typename T> class basic_string {"
       "  public:"
       "    T *c_str();"
       "  };"
       "}}"
       "void foo() {"
       "  using namespace std;"
       "  basic_string<char> s;"
       "  s.c_str();"
       "}"));
 
   // A negative test for qualified names.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{{"foo", "bar"}}, false},
           {{{"bar", "foo"}}, false},
           {{"foo"}, true},
-      }), "void foo(); struct bar { void foo(); }; void test() { foo(); }"));
+      })), "void foo(); struct bar { void foo(); }; void test() { foo(); }"));
 
   // Test CDF_MaybeBuiltin - a flag that allows matching weird builtins.
   EXPECT_TRUE(tooling::runToolOnCode(
-      new CallDescriptionAction({
+      std::unique_ptr<CallDescriptionAction>(new CallDescriptionAction({
           {{"memset", 3}, false},
           {{CDF_MaybeBuiltin, "memset", 3}, true}
-      }),
+      })),
       "void foo() {"
       "  int x;"
       "  __builtin___memset_chk(&x, 0, sizeof(x),"
       "                         __builtin_object_size(&x, 0));"
       "}"));
 }
 
 } // namespace
 } // namespace ento
 } // namespace clang

cfe/trunk/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp

std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
     });
     return std::move(AnalysisConsumer);
   }
 };
 
 template <typename CheckerT>
 bool runCheckerOnCode(const std::string &Code, std::string &Diags) {
   llvm::raw_string_ostream OS(Diags);
-  return tooling::runToolOnCode(new TestAction<CheckerT>(OS), Code);
+  return tooling::runToolOnCode(std::make_unique<TestAction<CheckerT>>(OS),
+                                Code);
 }
 template <typename CheckerT>
 bool runCheckerOnCode(const std::string &Code) {
   std::string Diags;
   return runCheckerOnCode<CheckerT>(Code, Diags);
 }
 
 

cfe/trunk/unittests/StaticAnalyzer/StoreTest.cpp

 public:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef File) override {
     return std::make_unique<VariableBindConsumer>(Compiler);
   }
 };
 
 TEST(Store, VariableBind) {
-  EXPECT_TRUE(tooling::runToolOnCode(
-      new VariableBindAction, "void foo() { int x0, y0, z0, x1, y1; }"));
+  EXPECT_TRUE(tooling::runToolOnCode(std::make_unique<VariableBindAction>(),
+                                     "void foo() { int x0, y0, z0, x1, y1; }"));
 }
 
 } // namespace
 } // namespace ento
 } // namespace clang

cfe/trunk/unittests/StaticAnalyzer/SymbolReaperTest.cpp

public:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef File) override {
     return std::make_unique<SuperRegionLivenessConsumer>(Compiler);
   }
 };
 
 // Test that marking s.x as live would also make s live.
 TEST(SymbolReaper, SuperRegionLiveness) {
-  EXPECT_TRUE(tooling::runToolOnCode(new SuperRegionLivenessAction,
-                                     "void foo() { struct S { int x; } s; }"));
+  EXPECT_TRUE(
+      tooling::runToolOnCode(std::make_unique<SuperRegionLivenessAction>(),
 }
 
 } // namespace
 } // namespace ento
 } // namespace clang

cfe/trunk/unittests/Tooling/CommentHandlerTest.cpp

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

cfe/trunk/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(std::make_unique<TestAction>(this), Code);
   }
 
 protected:
   clang::SourceManager *SM;
   clang::ASTContext *Context;
 
 private:
   class FindConsumer : public clang::ASTConsumer {

cfe/trunk/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 std::make_unique<TestAction>(this);
   }
 
   class FindConsumer : public ASTConsumer {
   public:
     FindConsumer(TestVisitor *Visitor) : Visitor(Visitor) {}
 
     void HandleTranslationUnit(clang::ASTContext &Context) override {
       Visitor->Context = &Context;

cfe/trunk/unittests/Tooling/ToolingTest.cpp

public:
   }
  private:
   bool * const FoundTopLevelDecl;
 };
 } // end namespace
 
 TEST(runToolOnCode, FindsNoTopLevelDeclOnEmptyCode) {
   bool FoundTopLevelDecl = false;
-  EXPECT_TRUE(
-      runToolOnCode(new TestAction(std::make_unique<FindTopLevelDeclConsumer>(
-                        &FoundTopLevelDecl)),
-                    ""));
+  EXPECT_TRUE(runToolOnCode(
+      std::make_unique<TestAction>(
+          std::make_unique<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(std::make_unique<FindClassDeclXConsumer>(
-                        &FoundClassDeclX)),
-                    "class X;"));
+  EXPECT_TRUE(runToolOnCode(
+      std::make_unique<TestAction>(
+          std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
   EXPECT_TRUE(FoundClassDeclX);
 
   FoundClassDeclX = false;
-  EXPECT_TRUE(
-      runToolOnCode(new TestAction(std::make_unique<FindClassDeclXConsumer>(
-                        &FoundClassDeclX)),
-                    "class Y;"));
+  EXPECT_TRUE(runToolOnCode(
+      std::make_unique<TestAction>(
+          std::make_unique<FindClassDeclXConsumer>(&FoundClassDeclX)),
   EXPECT_FALSE(FoundClassDeclX);
 }
 
 TEST(buildASTFromCode, FindsClassDecl) {
   std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
   ASSERT_TRUE(AST.get());
   EXPECT_TRUE(FindClassDeclX(AST.get()));
 
TEST(ToolInvocation, TestMapVirtualFile) {
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   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.get());
+  clang::tooling::ToolInvocation Invocation(
+      Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
   InMemoryFileSystem->addFile(
       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
   InMemoryFileSystem->addFile("def/abc", 0,
                               llvm::MemoryBuffer::getMemBuffer("\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.
   llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFileSystem(
       new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
   OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), OverlayFileSystem));
   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.get());
+  clang::tooling::ToolInvocation Invocation(
+      Args, std::make_unique<SyntaxOnlyAction>(), Files.get());
   InMemoryFileSystem->addFile(
       "test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("#include <abc>\n"));
   InMemoryFileSystem->addFile("def/abc", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   // Add a module.map file in the include directory of our header, so we trigger
   // the module.map header search logic.
   InMemoryFileSystem->addFile("def/module.map", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
     return std::make_unique<SkipBodyConsumer>();
   }
 };
 
 TEST(runToolOnCode, TestSkipFunctionBody) {
   std::vector<std::string> Args = {"-std=c++11"};
   std::vector<std::string> Args2 = {"-fno-delayed-template-parsing"};
 
-  EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
+  EXPECT_TRUE(runToolOnCode(std::make_unique<SkipBodyAction>(),
                             "int skipMe() { an_error_here }"));
-  EXPECT_FALSE(runToolOnCode(new SkipBodyAction,
+  EXPECT_FALSE(runToolOnCode(std::make_unique<SkipBodyAction>(),
                              "int skipMeNot() { an_error_here }"));
 
   // Test constructors with initializers
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "struct skipMe { skipMe() : an_error() { more error } };", Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe(); };"
+      std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
                           "skipMe::skipMe() : an_error([](){;}) { more error }",
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe(); };"
+      std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe(); };"
                           "skipMe::skipMe() : an_error{[](){;}} { more error }",
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "struct skipMe { skipMe(); };"
       "skipMe::skipMe() : a<b<c>(e)>>(), f{}, g() { error }",
       Args));
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMe { skipMe() : bases()... { error } };",
+      std::make_unique<SkipBodyAction>(), "struct skipMe { skipMe() : bases()... { error } };",
       Args));
 
   EXPECT_FALSE(runToolOnCodeWithArgs(
-      new SkipBodyAction, "struct skipMeNot { skipMeNot() : an_error() { } };",
+      std::make_unique<SkipBodyAction>(), "struct skipMeNot { skipMeNot() : an_error() { } };",
       Args));
-  EXPECT_FALSE(runToolOnCodeWithArgs(new SkipBodyAction,
+  EXPECT_FALSE(runToolOnCodeWithArgs(std::make_unique<SkipBodyAction>(),
                                      "struct skipMeNot { skipMeNot(); };"
                                      "skipMeNot::skipMeNot() : an_error() { }",
                                      Args));
 
   // Try/catch
   EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "void skipMe() try { an_error() } catch(error) { error };"));
   EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "struct S { void skipMe() try { an_error() } catch(error) { error } };"));
   EXPECT_TRUE(
-      runToolOnCode(new SkipBodyAction,
+      runToolOnCode(std::make_unique<SkipBodyAction>(),
                     "void skipMe() try { an_error() } catch(error) { error; }"
                     "catch(error) { error } catch (error) { }"));
   EXPECT_FALSE(runToolOnCode(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "void skipMe() try something;")); // don't crash while parsing
 
   // Template
   EXPECT_TRUE(runToolOnCode(
-      new SkipBodyAction, "template<typename T> int skipMe() { an_error_here }"
+      std::make_unique<SkipBodyAction>(), "template<typename T> int skipMe() { an_error_here }"
                           "int x = skipMe<int>();"));
   EXPECT_FALSE(runToolOnCodeWithArgs(
-      new SkipBodyAction,
+      std::make_unique<SkipBodyAction>(),
       "template<typename T> int skipMeNot() { an_error_here }", Args2));
 }
 
 TEST(runToolOnCodeWithArgs, TestNoDepFile) {
   llvm::SmallString<32> DepFilePath;
   ASSERT_FALSE(llvm::sys::fs::getPotentiallyUniqueTempFileName("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(std::make_unique<SkipBodyAction>(), "", Args));
   EXPECT_FALSE(llvm::sys::fs::exists(DepFilePath.str()));
   EXPECT_FALSE(llvm::sys::fs::remove(DepFilePath.str()));
 }
 
 struct CheckColoredDiagnosticsAction : public clang::ASTFrontendAction {
   CheckColoredDiagnosticsAction(bool ShouldShowColor)
       : ShouldShowColor(ShouldShowColor) {}
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef) override {
     if (Compiler.getDiagnosticOpts().ShowColors != ShouldShowColor)
       Compiler.getDiagnostics().Report(
           Compiler.getDiagnostics().getCustomDiagID(
               DiagnosticsEngine::Fatal,
               "getDiagnosticOpts().ShowColors != ShouldShowColor"));
     return std::make_unique<ASTConsumer>();
   }
 
 private:
   bool ShouldShowColor = true;
 };
 
 TEST(runToolOnCodeWithArgs, DiagnosticsColor) {
-
-  EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "",
-                                    {"-fcolor-diagnostics"}));
-  EXPECT_TRUE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false),
-                                    "", {"-fno-color-diagnostics"}));
-  EXPECT_TRUE(
-      runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(true), "",
-                            {"-fno-color-diagnostics", "-fcolor-diagnostics"}));
-  EXPECT_TRUE(
-      runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false), "",
-                            {"-fcolor-diagnostics", "-fno-color-diagnostics"}));
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      std::make_unique<CheckColoredDiagnosticsAction>(true), "",
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      std::make_unique<CheckColoredDiagnosticsAction>(false), "",
+      {"-fno-color-diagnostics"}));
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      std::make_unique<CheckColoredDiagnosticsAction>(true), "",
+  EXPECT_TRUE(runToolOnCodeWithArgs(
+      std::make_unique<CheckColoredDiagnosticsAction>(false), "",
   EXPECT_TRUE(runToolOnCodeWithArgs(
-      new CheckColoredDiagnosticsAction(true), "",
+      std::make_unique<CheckColoredDiagnosticsAction>(true), "",
       {"-fno-color-diagnostics", "-fdiagnostics-color=always"}));
 
   // Check that this test would fail if ShowColors is not what it should.
-  EXPECT_FALSE(runToolOnCodeWithArgs(new CheckColoredDiagnosticsAction(false),
-                                     "", {"-fcolor-diagnostics"}));
+  EXPECT_FALSE(runToolOnCodeWithArgs(
+      std::make_unique<CheckColoredDiagnosticsAction>(false), "",
+      {"-fcolor-diagnostics"}));
 }
 
 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<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
         }
       };
       return std::make_unique<Consumer>();
     }
   };
 
   // Should not crash
   EXPECT_FALSE(
-      runToolOnCode(new ResetDiagnosticAction,
+      runToolOnCode(std::make_unique<ResetDiagnosticAction>(),
                     "struct Foo { Foo(int); ~Foo(); struct Fwd _fwd; };"
                     "void func() { long x; Foo f(x); }"));
 }
 
 } // end namespace tooling
 } // end namespace clang

clang-tools-extra/trunk/clangd/unittests/IndexActionTests.cpp

runIndexingAction(llvm::StringRef MainFilePath,
 
     std::vector<std::string> Args = {"index_action", "-fsyntax-only",
                                      "-xc++",        "-std=c++11",
                                      "-iquote",      testRoot()};
     Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());
     Args.push_back(MainFilePath);
 
     tooling::ToolInvocation Invocation(
-        Args, Action.release(), Files.get(),
+        Args, std::move(Action), Files.get(),
         std::make_shared<PCHContainerOperations>());
 
     Invocation.run();
 
     checkNodesAreInitialized(IndexFile, FilePaths);
     return IndexFile;
   }
 

clang-tools-extra/trunk/unittests/clang-tidy/ClangTidyTest.h

runCheckOnCode(StringRef Code, std::vector<ClangTidyError> *Errors = nullptr,
   ast_matchers::MatchFinder Finder;
   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
   SmallVector<std::unique_ptr<ClangTidyCheck>, 1> Checks;
   tooling::ToolInvocation Invocation(
-      Args, new TestClangTidyAction<CheckTypes...>(Checks, Finder, Context),
+      Args,
+      std::make_unique<TestClangTidyAction<CheckTypes...>>(Checks, Finder,
+                                                           Context),
       Files.get());
   InMemoryFileSystem->addFile(Filename, 0,
                               llvm::MemoryBuffer::getMemBuffer(Code));
   for (const auto &FileContent : PathsToContent) {
     InMemoryFileSystem->addFile(
         Twine("include/") + FileContent.first, 0,
         llvm::MemoryBuffer::getMemBuffer(FileContent.second));
   }