[Tooling] Add a isSingleProcess() helper to ToolExecutor

[ilya-biryukov]

Summary

Used in clangd's symbol builder to optimize for the common
shared-memory executor case.

[ioeric]

lgtm

include/clang/Tooling/AllTUsExecution.h

public:
   ///
   /// The executor takes ownership of \p Options.
   AllTUsToolExecutor(CommonOptionsParser Options, unsigned ThreadCount,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                          std::make_shared<PCHContainerOperations>());
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
+  bool isSingleProcess() const override { return true; }
+
   using ToolExecutor::execute;
 
   llvm::Error
   execute(llvm::ArrayRef<
           std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
               Actions) override;
 
   ExecutionContext *getExecutionContext() override { return &Context; };

include/clang/Tooling/Execution.h

 ///  executor according to the command-line arguments.
 class ToolExecutor {
 public:
   virtual ~ToolExecutor() {}
 
   /// Returns the name of a specific executor.
   virtual StringRef getExecutorName() const = 0;
 
+  /// Should return true iff executor runs all actions in a single process.
+  /// Clients can use this signal to find out if they can collect results
+  /// in-memory (e.g. to avoid serialization costs of using ToolResults).
+  /// The single-process executors can still run multiple threads, but all
+  /// executions are guaranteed to share the same memory.
+  virtual bool isSingleProcess() const = 0;
+
   /// Executes each action with a corresponding arguments adjuster.
   virtual llvm::Error
   execute(llvm::ArrayRef<
           std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
               Actions) = 0;
 
   /// Convenient functions for the above `execute`.
   llvm::Error execute(std::unique_ptr<FrontendActionFactory> Action);

include/clang/Tooling/StandaloneExecution.h

public:
   /// The executor takes ownership of \p Options.
   StandaloneToolExecutor(
       CommonOptionsParser Options,
       std::shared_ptr<PCHContainerOperations> PCHContainerOps =
           std::make_shared<PCHContainerOperations>());
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
+  bool isSingleProcess() const override { return true; }
+
   using ToolExecutor::execute;
 
   llvm::Error
   execute(llvm::ArrayRef<
           std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
               Actions) override;
 
   /// Set a \c DiagnosticConsumer to use during parsing.

unittests/Tooling/ExecutionTest.cpp

 public:
   static const char *ExecutorName;
 
   TestToolExecutor(CommonOptionsParser Options)
       : OptionsParser(std::move(Options)) {}
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
+  bool isSingleProcess() const override { return true; }
+
   llvm::Error
   execute(llvm::ArrayRef<std::pair<std::unique_ptr<FrontendActionFactory>,
                                    ArgumentsAdjuster>>) override {
     return llvm::Error::success();
   }
 
   ExecutionContext *getExecutionContext() override { return nullptr; };