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