1 //===--- StandaloneExecution.h - Standalone execution. -*- C++ ----------*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines standalone execution of clang tools. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H 14 #define LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H 15 16 #include "clang/Tooling/ArgumentsAdjusters.h" 17 #include "clang/Tooling/Execution.h" 18 #include <optional> 19 20 namespace clang { 21 namespace tooling { 22 23 /// A standalone executor that runs FrontendActions on a given set of 24 /// TUs in sequence. 25 /// 26 /// By default, this executor uses the following arguments adjusters (as defined 27 /// in `clang/Tooling/ArgumentsAdjusters.h`): 28 /// - `getClangStripOutputAdjuster()` 29 /// - `getClangSyntaxOnlyAdjuster()` 30 /// - `getClangStripDependencyFileAdjuster()` 31 class StandaloneToolExecutor : public ToolExecutor { 32 public: 33 static const char *ExecutorName; 34 35 /// Init with \p CompilationDatabase and the paths of all files to be 36 /// proccessed. 37 StandaloneToolExecutor( 38 const CompilationDatabase &Compilations, 39 llvm::ArrayRef<std::string> SourcePaths, 40 IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS = 41 llvm::vfs::getRealFileSystem(), 42 std::shared_ptr<PCHContainerOperations> PCHContainerOps = 43 std::make_shared<PCHContainerOperations>()); 44 45 /// Init with \p CommonOptionsParser. This is expected to be used by 46 /// `createExecutorFromCommandLineArgs` based on commandline options. 47 /// 48 /// The executor takes ownership of \p Options. 49 StandaloneToolExecutor( 50 CommonOptionsParser Options, 51 std::shared_ptr<PCHContainerOperations> PCHContainerOps = 52 std::make_shared<PCHContainerOperations>()); 53 getExecutorName()54 StringRef getExecutorName() const override { return ExecutorName; } 55 56 using ToolExecutor::execute; 57 58 llvm::Error 59 execute(llvm::ArrayRef< 60 std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>> 61 Actions) override; 62 63 /// Set a \c DiagnosticConsumer to use during parsing. setDiagnosticConsumer(DiagnosticConsumer * DiagConsumer)64 void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer) { 65 Tool.setDiagnosticConsumer(DiagConsumer); 66 } 67 getExecutionContext()68 ExecutionContext *getExecutionContext() override { return &Context; }; 69 getToolResults()70 ToolResults *getToolResults() override { return &Results; } 71 getSourcePaths()72 llvm::ArrayRef<std::string> getSourcePaths() const { 73 return Tool.getSourcePaths(); 74 } 75 mapVirtualFile(StringRef FilePath,StringRef Content)76 void mapVirtualFile(StringRef FilePath, StringRef Content) override { 77 Tool.mapVirtualFile(FilePath, Content); 78 } 79 80 /// Returns the file manager used in the tool. 81 /// 82 /// The file manager is shared between all translation units. getFiles()83 FileManager &getFiles() { return Tool.getFiles(); } 84 85 private: 86 // Used to store the parser when the executor is initialized with parser. 87 std::optional<CommonOptionsParser> OptionsParser; 88 // FIXME: The standalone executor is currently just a wrapper of `ClangTool`. 89 // Merge `ClangTool` implementation into the this. 90 ClangTool Tool; 91 ExecutionContext Context; 92 InMemoryToolResults Results; 93 ArgumentsAdjuster ArgsAdjuster; 94 }; 95 96 } // end namespace tooling 97 } // end namespace clang 98 99 #endif // LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H 100