[Tooling] [1/1] Refactor FrontendActionFactory::create() to return std::unique_ptr<>

[lebedev.ri]

Summary

I'm not sure whether there are any principal reasons why it returns raw owning pointer,
or it is just a old code that was not updated post-C++11.

I'm not too sure what testing i should do, because check-all is not error clean here for some reason,
but it does not appear asif those failures are related to these changes.

This is Clang-tools-extra part.
Clang part is D43779.

[alexfh]

Awesome, thank you for this cleanup!

[lebedev.ri]

Thank you.

I did re-read the diffs, and i don't see any invalid changes here.
I'm going to try to commit this (as two revisions, need to migrate to monorepo one day :/),
and if the bots show that i still did miss something here, i'll revert.

[lebedev.ri]

Superseded by D66960

clang-tools-extra/trunk/clang-move/ClangMove.h

 };
 
 class ClangMoveActionFactory : public tooling::FrontendActionFactory {
 public:
   ClangMoveActionFactory(ClangMoveContext *const Context,
                          DeclarationReporter *const Reporter = nullptr)
       : Context(Context), Reporter(Reporter) {}
 
-  clang::FrontendAction *create() override {
-    return new ClangMoveAction(Context, Reporter);
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<ClangMoveAction>(Context, Reporter);
   }
 
 private:
   // Not owned.
   ClangMoveContext *const Context;
   DeclarationReporter *const Reporter;
 };
 
 } // namespace move
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H

clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp

void runClangTidy(clang::tidy::ClangTidyContext &Context,
 
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
   class ActionFactory : public FrontendActionFactory {
   public:
     ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
-    FrontendAction *create() override { return new Action(&ConsumerFactory); }
+    std::unique_ptr<clang::FrontendAction> create() override {
+      return llvm::make_unique<Action>(&ConsumerFactory);
+    }
 
   private:
     class Action : public ASTFrontendAction {
     public:
       Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
       std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                      StringRef File) override {
         return Factory->CreateASTConsumer(Compiler, File);

clang-tools-extra/trunk/clangd/global-symbol-builder/GlobalSymbolBuilderMain.cpp

llvm::cl::desc("The index includes header that a symbol is defined in. "
                    "this directory, which must be absolute. If this flag is "
                    "not given, such headers will have relative paths."),
     llvm::cl::init(""));
 
 class SymbolIndexActionFactory : public tooling::FrontendActionFactory {
 public:
   SymbolIndexActionFactory(tooling::ExecutionContext *Ctx) : Ctx(Ctx) {}
 
-  clang::FrontendAction *create() override {
+  std::unique_ptr<clang::FrontendAction> create() override {
     // Wraps the index action and reports collected symbols to the execution
     // context at the end of each translation unit.
     class WrappedIndexAction : public WrapperFrontendAction {
     public:
       WrappedIndexAction(std::shared_ptr<SymbolCollector> C,
                          std::unique_ptr<CanonicalIncludes> Includes,
                          const index::IndexingOptions &Opts,
                          tooling::ExecutionContext *Ctx)
IndexOpts.SystemSymbolFilter =
         index::IndexingOptions::SystemSymbolFilterKind::All;
     IndexOpts.IndexFunctionLocals = false;
     auto CollectorOpts = SymbolCollector::Options();
     CollectorOpts.FallbackDir = AssumedHeaderDir;
     CollectorOpts.CollectIncludePath = true;
     auto Includes = llvm::make_unique<CanonicalIncludes>();
     addSystemHeadersMapping(Includes.get());
     CollectorOpts.Includes = Includes.get();
-    return new WrappedIndexAction(
+
+    return llvm::make_unique<WrappedIndexAction>(
         std::make_shared<SymbolCollector>(std::move(CollectorOpts)),
         std::move(Includes), IndexOpts, Ctx);
   }
 
   tooling::ExecutionContext *Ctx;
 };
 
 // Combine occurrences of the same symbol across translation units.

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllSymbolsAction.h

 
 class FindAllSymbolsActionFactory : public tooling::FrontendActionFactory {
 public:
   FindAllSymbolsActionFactory(
       SymbolReporter *Reporter,
       const HeaderMapCollector::RegexHeaderMap *RegexHeaderMap = nullptr)
       : Reporter(Reporter), RegexHeaderMap(RegexHeaderMap) {}
 
-  clang::FrontendAction *create() override {
-    return new FindAllSymbolsAction(Reporter, RegexHeaderMap);
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<FindAllSymbolsAction>(Reporter, RegexHeaderMap);
   }
 
 private:
   SymbolReporter *const Reporter;
   const HeaderMapCollector::RegexHeaderMap *const RegexHeaderMap;
 };
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_FIND_ALL_SYMBOLS_ACTION_H

clang-tools-extra/trunk/modularize/CoverageChecker.cpp

private:
   CoverageChecker &Checker;
 };
 
 class CoverageCheckerFrontendActionFactory : public FrontendActionFactory {
 public:
   CoverageCheckerFrontendActionFactory(CoverageChecker &Checker)
     : Checker(Checker) {}
 
-  CoverageCheckerAction *create() override {
-    return new CoverageCheckerAction(Checker);
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<CoverageCheckerAction>(Checker);
   }
 
 private:
   CoverageChecker &Checker;
 };
 
 // CoverageChecker class implementation.
 

clang-tools-extra/trunk/modularize/Modularize.cpp

 class ModularizeFrontendActionFactory : public FrontendActionFactory {
 public:
   ModularizeFrontendActionFactory(EntityMap &Entities,
                                   PreprocessorTracker &preprocessorTracker,
                                   int &HadErrors)
       : Entities(Entities), PPTracker(preprocessorTracker),
         HadErrors(HadErrors) {}
 
-  CollectEntitiesAction *create() override {
-    return new CollectEntitiesAction(Entities, PPTracker, HadErrors);
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<CollectEntitiesAction>(Entities, PPTracker,
+                                                    HadErrors);
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
   int &HadErrors;
 };
 
std::unique_ptr<clang::ASTConsumer>
     return llvm::make_unique<CompileCheckConsumer>();
   }
 };
 
 class CompileCheckFrontendActionFactory : public FrontendActionFactory {
 public:
   CompileCheckFrontendActionFactory() {}
 
-  CompileCheckAction *create() override {
-    return new CompileCheckAction();
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<CompileCheckAction>();
   }
 };
 
 int main(int Argc, const char **Argv) {
 
   // Save program name for error messages.
   Argv0 = Argv[0];
 

clang-tools-extra/trunk/pp-trace/PPTrace.cpp

 };
 
 class PPTraceFrontendActionFactory : public FrontendActionFactory {
 public:
   PPTraceFrontendActionFactory(SmallSet<std::string, 4> &Ignore,
                                std::vector<CallbackCall> &CallbackCalls)
       : Ignore(Ignore), CallbackCalls(CallbackCalls) {}
 
-  PPTraceAction *create() override {
-    return new PPTraceAction(Ignore, CallbackCalls);
+  std::unique_ptr<clang::FrontendAction> create() override {
+    return llvm::make_unique<PPTraceAction>(Ignore, CallbackCalls);
   }
 
 private:
   SmallSet<std::string, 4> &Ignore;
   std::vector<CallbackCall> &CallbackCalls;
 };
 } // namespace
 

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

runCheckOnCode(StringRef Code, std::vector<ClangTidyError> *Errors = nullptr,
   llvm::IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions(), InMemoryFileSystem));
 
   SmallVector<std::unique_ptr<ClangTidyCheck>, 1> Checks;
   CheckFactory<CheckList...>::createChecks(&Context, Checks);
   tooling::ToolInvocation Invocation(
-      Args, new TestClangTidyAction(Checks, Finder, Context), Files.get());
+      Args, llvm::make_unique<TestClangTidyAction>(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));
   }
   Invocation.setDiagnosticConsumer(&DiagConsumer);

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

 
 namespace {
 class SymbolIndexActionFactory : public tooling::FrontendActionFactory {
 public:
   SymbolIndexActionFactory(SymbolCollector::Options COpts,
                            CommentHandler *PragmaHandler)
       : COpts(std::move(COpts)), PragmaHandler(PragmaHandler) {}
 
-  clang::FrontendAction *create() override {
+  std::unique_ptr<clang::FrontendAction> create() override {
     class WrappedIndexAction : public WrapperFrontendAction {
     public:
       WrappedIndexAction(std::shared_ptr<SymbolCollector> C,
                          const index::IndexingOptions &Opts,
                          CommentHandler *PragmaHandler)
           : WrapperFrontendAction(
                 index::createIndexingAction(C, Opts, nullptr)),
             PragmaHandler(PragmaHandler) {}
private:
       index::IndexingOptions IndexOpts;
       CommentHandler *PragmaHandler;
     };
     index::IndexingOptions IndexOpts;
     IndexOpts.SystemSymbolFilter =
         index::IndexingOptions::SystemSymbolFilterKind::All;
     IndexOpts.IndexFunctionLocals = false;
     Collector = std::make_shared<SymbolCollector>(COpts);
-    return new WrappedIndexAction(Collector, std::move(IndexOpts),
-                                  PragmaHandler);
+
+    return llvm::make_unique<WrappedIndexAction>(
+        Collector, std::move(IndexOpts), PragmaHandler);
   }
 
   std::shared_ptr<SymbolCollector> Collector;
   SymbolCollector::Options COpts;
   CommentHandler *PragmaHandler;
 };
 
 class SymbolCollectorTest : public ::testing::Test {