[tooling] Create executor by name

[juliehockett]

Summary

Allow creation of a ToolExecutor given a name and a set of parsed options. This is useful in the case where the calling tool always wants to use a particular non-default implementation (e.g. the tool should always be run with the all-TUs executor)

[ioeric]

This is useful in the case where the calling tool always wants to use a particular non-default implementation (e.g. the tool should always be run with the all-TUs executor)

Any reason not to use the constructor of AllTUsToolExecutor directly? There is one that takes CommonOptionsParser.

clang/include/clang/Tooling/Execution.h

 ///
 /// By default, this creates a `StandaloneToolExecutor` ("standalone") if
 /// `--executor` is not provided.
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview = nullptr);
 
+/// This creates a ToolExecutor that is in the global registry.
+///
+/// This picks the executor based on the provided name. The caller must parse
+/// commandline arguments with `CommonOptionsParser` prior to calling this.
+///
+/// If no name is provided, or the provided name is not found, an error will be
+/// returned.
+llvm::Expected<std::unique_ptr<ToolExecutor>>
+createExecutor(StringRef ExecutorName, CommonOptionsParser &OptionsParser);
+
 namespace internal {
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                       llvm::cl::OptionCategory &Category,
                                       const char *Overview = nullptr);
+llvm::Expected<std::unique_ptr<ToolExecutor>>
+createExecutorImpl(StringRef ExecutorName, CommonOptionsParser &OptionsParser);
 } // end namespace internal
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_EXECUTION_H

clang/lib/Tooling/Execution.cpp

 createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                       llvm::cl::OptionCategory &Category,
                                       const char *Overview) {
   auto OptionsParser =
       CommonOptionsParser::create(argc, argv, Category, llvm::cl::ZeroOrMore,
                                   /*Overview=*/Overview);
   if (!OptionsParser)
     return OptionsParser.takeError();
+  return createExecutorImpl(ExecutorName, OptionsParser.get());
+}
+
+llvm::Expected<std::unique_ptr<ToolExecutor>>
+createExecutorImpl(StringRef ExecutorName, CommonOptionsParser &OptionsParser) {
+  if (ExecutorName.empty())
+    return llvm::make_error<llvm::StringError>("Must provide an executor name.",
+                                               llvm::inconvertibleErrorCode());
   for (auto I = ToolExecutorPluginRegistry::begin(),
             E = ToolExecutorPluginRegistry::end();
        I != E; ++I) {
     if (I->getName() != ExecutorName) {
       continue;
     }
     std::unique_ptr<ToolExecutorPlugin> Plugin(I->instantiate());
     llvm::Expected<std::unique_ptr<ToolExecutor>> Executor =
-        Plugin->create(*OptionsParser);
+        Plugin->create(OptionsParser);
     if (!Executor) {
       return llvm::make_error<llvm::StringError>(
           llvm::Twine("Failed to create '") + I->getName() +
               "': " + llvm::toString(Executor.takeError()) + "\n",
           llvm::inconvertibleErrorCode());
     }
     return std::move(*Executor);
   }
   return llvm::make_error<llvm::StringError>(
       llvm::Twine("Executor \"") + ExecutorName + "\" is not registered.",
       llvm::inconvertibleErrorCode());
 }
 } // end namespace internal
 
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview) {
   return internal::createExecutorFromCommandLineArgsImpl(argc, argv, Category,
                                                          Overview);
 }
 
+llvm::Expected<std::unique_ptr<ToolExecutor>>
+createExecutor(StringRef ExecutorName, CommonOptionsParser &OptionsParser) {
+  return internal::createExecutorImpl(ExecutorName, OptionsParser);
+}
+
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the StandaloneToolExecutorPlugin etc.
 extern volatile int StandaloneToolExecutorAnchorSource;
 extern volatile int AllTUsToolExecutorAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED StandaloneToolExecutorAnchorDest =
     StandaloneToolExecutorAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED AllTUsToolExecutorAnchorDest =
     AllTUsToolExecutorAnchorSource;
 
 } // end namespace tooling
 } // end namespace clang