clang 20.0.0git
Tooling.h
Go to the documentation of this file.
1//===- Tooling.h - Framework for standalone Clang tools ---------*- 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 implements functions to run clang tools standalone instead
10// of running them as a plugin.
11//
12// A ClangTool is initialized with a CompilationDatabase and a set of files
13// to run over. The tool will then run a user-specified FrontendAction over
14// all TUs in which the given files are compiled.
15//
16// It is also possible to run a FrontendAction over a snippet of code by
17// calling runToolOnCode, which is useful for unit testing.
18//
19// Applications that need more fine grained control over how to run
20// multiple FrontendActions over code can use ToolInvocation.
21//
22// Example tools:
23// - running clang -fsyntax-only over source code from an editor to get
24// fast syntax checks
25// - running match/replace tools over C++ code
26//
27//===----------------------------------------------------------------------===//
28
29#ifndef LLVM_CLANG_TOOLING_TOOLING_H
30#define LLVM_CLANG_TOOLING_TOOLING_H
31
34#include "clang/Basic/LLVM.h"
38#include "llvm/ADT/ArrayRef.h"
39#include "llvm/ADT/IntrusiveRefCntPtr.h"
40#include "llvm/ADT/StringMap.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/StringSet.h"
43#include "llvm/ADT/Twine.h"
44#include "llvm/Option/Option.h"
45#include "llvm/Support/VirtualFileSystem.h"
46#include <memory>
47#include <string>
48#include <utility>
49#include <vector>
50
51namespace clang {
52
53class CompilerInstance;
54class CompilerInvocation;
55class DiagnosticConsumer;
56class DiagnosticsEngine;
57
58namespace driver {
59
60class Compilation;
61
62} // namespace driver
63
64namespace tooling {
65
66class CompilationDatabase;
67
68/// Retrieves the flags of the `-cc1` job in `Compilation` that has only source
69/// files as its inputs.
70/// Returns nullptr if there are no such jobs or multiple of them. Note that
71/// offloading jobs are ignored.
72const llvm::opt::ArgStringList *
73getCC1Arguments(DiagnosticsEngine *Diagnostics,
74 driver::Compilation *Compilation);
75
76/// Interface to process a clang::CompilerInvocation.
77///
78/// If your tool is based on FrontendAction, you should be deriving from
79/// FrontendActionFactory instead.
81public:
82 virtual ~ToolAction();
83
84 /// Perform an action for an invocation.
85 virtual bool
86 runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
87 FileManager *Files,
88 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
89 DiagnosticConsumer *DiagConsumer) = 0;
90};
91
92/// Interface to generate clang::FrontendActions.
93///
94/// Having a factory interface allows, for example, a new FrontendAction to be
95/// created for each translation unit processed by ClangTool. This class is
96/// also a ToolAction which uses the FrontendActions created by create() to
97/// process each translation unit.
99public:
101
102 /// Invokes the compiler with a FrontendAction created by create().
103 bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
104 FileManager *Files,
105 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
106 DiagnosticConsumer *DiagConsumer) override;
107
108 /// Returns a new clang::FrontendAction.
109 virtual std::unique_ptr<FrontendAction> create() = 0;
110};
111
112/// Returns a new FrontendActionFactory for a given type.
113///
114/// T must derive from clang::FrontendAction.
115///
116/// Example:
117/// std::unique_ptr<FrontendActionFactory> Factory =
118/// newFrontendActionFactory<clang::SyntaxOnlyAction>();
119template <typename T>
120std::unique_ptr<FrontendActionFactory> newFrontendActionFactory();
121
122/// Callbacks called before and after each source file processed by a
123/// FrontendAction created by the FrontedActionFactory returned by \c
124/// newFrontendActionFactory.
126public:
127 virtual ~SourceFileCallbacks() = default;
128
129 /// Called before a source file is processed by a FrontEndAction.
130 /// \see clang::FrontendAction::BeginSourceFileAction
132 return true;
133 }
134
135 /// Called after a source file is processed by a FrontendAction.
136 /// \see clang::FrontendAction::EndSourceFileAction
137 virtual void handleEndSource() {}
138};
139
140/// Returns a new FrontendActionFactory for any type that provides an
141/// implementation of newASTConsumer().
142///
143/// FactoryT must implement: ASTConsumer *newASTConsumer().
144///
145/// Example:
146/// struct ProvidesASTConsumers {
147/// std::unique_ptr<clang::ASTConsumer> newASTConsumer();
148/// } Factory;
149/// std::unique_ptr<FrontendActionFactory> FactoryAdapter(
150/// newFrontendActionFactory(&Factory));
151template <typename FactoryT>
152inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
153 FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks = nullptr);
154
155/// Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag.
156///
157/// \param ToolAction The action to run over the code.
158/// \param Code C++ code.
159/// \param FileName The file name which 'Code' will be mapped as.
160/// \param PCHContainerOps The PCHContainerOperations for loading and creating
161/// clang modules.
162///
163/// \return - True if 'ToolAction' was successfully executed.
164bool runToolOnCode(std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
165 const Twine &FileName = "input.cc",
166 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
167 std::make_shared<PCHContainerOperations>());
168
169/// The first part of the pair is the filename, the second part the
170/// file-content.
171using FileContentMappings = std::vector<std::pair<std::string, std::string>>;
172
173/// Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag and
174/// with additional other flags.
175///
176/// \param ToolAction The action to run over the code.
177/// \param Code C++ code.
178/// \param Args Additional flags to pass on.
179/// \param FileName The file name which 'Code' will be mapped as.
180/// \param ToolName The name of the binary running the tool. Standard library
181/// header paths will be resolved relative to this.
182/// \param PCHContainerOps The PCHContainerOperations for loading and creating
183/// clang modules.
184///
185/// \return - True if 'ToolAction' was successfully executed.
187 std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
188 const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
189 const Twine &ToolName = "clang-tool",
190 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
191 std::make_shared<PCHContainerOperations>(),
192 const FileContentMappings &VirtualMappedFiles = FileContentMappings());
193
194// Similar to the overload except this takes a VFS.
196 std::unique_ptr<FrontendAction> ToolAction, const Twine &Code,
198 const std::vector<std::string> &Args, const Twine &FileName = "input.cc",
199 const Twine &ToolName = "clang-tool",
200 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
201 std::make_shared<PCHContainerOperations>());
202
203/// Builds an AST for 'Code'.
204///
205/// \param Code C++ code.
206/// \param FileName The file name which 'Code' will be mapped as.
207/// \param PCHContainerOps The PCHContainerOperations for loading and creating
208/// clang modules.
209///
210/// \return The resulting AST or null if an error occurred.
211std::unique_ptr<ASTUnit>
212buildASTFromCode(StringRef Code, StringRef FileName = "input.cc",
213 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
214 std::make_shared<PCHContainerOperations>());
215
216/// Builds an AST for 'Code' with additional flags.
217///
218/// \param Code C++ code.
219/// \param Args Additional flags to pass on.
220/// \param FileName The file name which 'Code' will be mapped as.
221/// \param ToolName The name of the binary running the tool. Standard library
222/// header paths will be resolved relative to this.
223/// \param PCHContainerOps The PCHContainerOperations for loading and creating
224/// clang modules.
225///
226/// \param Adjuster A function to filter the command line arguments as
227/// specified.
228///
229/// \param BaseFS FileSystem for managing and looking up files.
230/// VirtualMappedFiles takes precedence.
231///
232/// \return The resulting AST or null if an error occurred.
233std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
234 StringRef Code, const std::vector<std::string> &Args,
235 StringRef FileName = "input.cc", StringRef ToolName = "clang-tool",
236 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
237 std::make_shared<PCHContainerOperations>(),
239 const FileContentMappings &VirtualMappedFiles = FileContentMappings(),
240 DiagnosticConsumer *DiagConsumer = nullptr,
242 llvm::vfs::getRealFileSystem());
243
244/// Utility to run a FrontendAction in a single clang invocation.
246public:
247 /// Create a tool invocation.
248 ///
249 /// \param CommandLine The command line arguments to clang. Note that clang
250 /// uses its binary name (CommandLine[0]) to locate its builtin headers.
251 /// Callers have to ensure that they are installed in a compatible location
252 /// (see clang driver implementation) or mapped in via mapVirtualFile.
253 /// \param FAction The action to be executed.
254 /// \param Files The FileManager used for the execution. Class does not take
255 /// ownership.
256 /// \param PCHContainerOps The PCHContainerOperations for loading and creating
257 /// clang modules.
258 ToolInvocation(std::vector<std::string> CommandLine,
259 std::unique_ptr<FrontendAction> FAction, FileManager *Files,
260 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
261 std::make_shared<PCHContainerOperations>());
262
263 /// Create a tool invocation.
264 ///
265 /// \param CommandLine The command line arguments to clang.
266 /// \param Action The action to be executed.
267 /// \param Files The FileManager used for the execution.
268 /// \param PCHContainerOps The PCHContainerOperations for loading and creating
269 /// clang modules.
270 ToolInvocation(std::vector<std::string> CommandLine, ToolAction *Action,
271 FileManager *Files,
272 std::shared_ptr<PCHContainerOperations> PCHContainerOps);
273
275
278
279 /// Set a \c DiagnosticConsumer to use during driver command-line parsing and
280 /// the action invocation itself.
282 this->DiagConsumer = DiagConsumer;
283 }
284
285 /// Set a \c DiagnosticOptions to use during driver command-line parsing.
287 this->DiagOpts = DiagOpts;
288 }
289
290 /// Run the clang invocation.
291 ///
292 /// \returns True if there were no errors during execution.
293 bool run();
294
295 private:
296 bool runInvocation(const char *BinaryName,
297 driver::Compilation *Compilation,
298 std::shared_ptr<CompilerInvocation> Invocation,
299 std::shared_ptr<PCHContainerOperations> PCHContainerOps);
300
301 std::vector<std::string> CommandLine;
302 ToolAction *Action;
303 bool OwnsAction;
304 FileManager *Files;
305 std::shared_ptr<PCHContainerOperations> PCHContainerOps;
306 DiagnosticConsumer *DiagConsumer = nullptr;
307 DiagnosticOptions *DiagOpts = nullptr;
308};
309
310/// Utility to run a FrontendAction over a set of files.
311///
312/// This class is written to be usable for command line utilities.
313/// By default the class uses ClangSyntaxOnlyAdjuster to modify
314/// command line arguments before the arguments are used to run
315/// a frontend action. One could install an additional command line
316/// arguments adjuster by calling the appendArgumentsAdjuster() method.
318public:
319 /// Constructs a clang tool to run over a list of files.
320 ///
321 /// \param Compilations The CompilationDatabase which contains the compile
322 /// command lines for the given source paths.
323 /// \param SourcePaths The source files to run over. If a source files is
324 /// not found in Compilations, it is skipped.
325 /// \param PCHContainerOps The PCHContainerOperations for loading and creating
326 /// clang modules.
327 /// \param BaseFS VFS used for all underlying file accesses when running the
328 /// tool.
329 /// \param Files The file manager to use for underlying file operations when
330 /// running the tool.
331 ClangTool(const CompilationDatabase &Compilations,
332 ArrayRef<std::string> SourcePaths,
333 std::shared_ptr<PCHContainerOperations> PCHContainerOps =
334 std::make_shared<PCHContainerOperations>(),
336 llvm::vfs::getRealFileSystem(),
337 IntrusiveRefCntPtr<FileManager> Files = nullptr);
338
340
341 /// Set a \c DiagnosticConsumer to use during parsing.
343 this->DiagConsumer = DiagConsumer;
344 }
345
346 /// Map a virtual file to be used while running the tool.
347 ///
348 /// \param FilePath The path at which the content will be mapped.
349 /// \param Content A null terminated buffer of the file's content.
350 void mapVirtualFile(StringRef FilePath, StringRef Content);
351
352 /// Append a command line arguments adjuster to the adjuster chain.
353 ///
354 /// \param Adjuster An argument adjuster, which will be run on the output of
355 /// previous argument adjusters.
357
358 /// Clear the command line arguments adjuster chain.
360
361 /// Runs an action over all files specified in the command line.
362 ///
363 /// \param Action Tool action.
364 ///
365 /// \returns 0 on success; 1 if any error occurred; 2 if there is no error but
366 /// some files are skipped due to missing compile commands.
367 int run(ToolAction *Action);
368
369 /// Create an AST for each file specified in the command line and
370 /// append them to ASTs.
371 int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
372
373 /// Sets whether an error message should be printed out if an action fails. By
374 /// default, if an action fails, a message is printed out to stderr.
375 void setPrintErrorMessage(bool PrintErrorMessage);
376
377 /// Returns the file manager used in the tool.
378 ///
379 /// The file manager is shared between all translation units.
380 FileManager &getFiles() { return *Files; }
381
382 llvm::ArrayRef<std::string> getSourcePaths() const { return SourcePaths; }
383
384private:
385 const CompilationDatabase &Compilations;
386 std::vector<std::string> SourcePaths;
387 std::shared_ptr<PCHContainerOperations> PCHContainerOps;
388
392
393 // Contains a list of pairs (<file name>, <file content>).
394 std::vector<std::pair<StringRef, StringRef>> MappedFileContents;
395
396 llvm::StringSet<> SeenWorkingDirectories;
397
398 ArgumentsAdjuster ArgsAdjuster;
399
400 DiagnosticConsumer *DiagConsumer = nullptr;
401
402 bool PrintErrorMessage = true;
403};
404
405template <typename T>
406std::unique_ptr<FrontendActionFactory> newFrontendActionFactory() {
407 class SimpleFrontendActionFactory : public FrontendActionFactory {
408 public:
409 std::unique_ptr<FrontendAction> create() override {
410 return std::make_unique<T>();
411 }
412 };
413
414 return std::unique_ptr<FrontendActionFactory>(
415 new SimpleFrontendActionFactory);
416}
417
418template <typename FactoryT>
419inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
420 FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks) {
421 class FrontendActionFactoryAdapter : public FrontendActionFactory {
422 public:
423 explicit FrontendActionFactoryAdapter(FactoryT *ConsumerFactory,
424 SourceFileCallbacks *Callbacks)
425 : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
426
427 std::unique_ptr<FrontendAction> create() override {
428 return std::make_unique<ConsumerFactoryAdaptor>(ConsumerFactory,
429 Callbacks);
430 }
431
432 private:
433 class ConsumerFactoryAdaptor : public ASTFrontendAction {
434 public:
435 ConsumerFactoryAdaptor(FactoryT *ConsumerFactory,
436 SourceFileCallbacks *Callbacks)
437 : ConsumerFactory(ConsumerFactory), Callbacks(Callbacks) {}
438
439 std::unique_ptr<ASTConsumer>
440 CreateASTConsumer(CompilerInstance &, StringRef) override {
441 return ConsumerFactory->newASTConsumer();
442 }
443
444 protected:
445 bool BeginSourceFileAction(CompilerInstance &CI) override {
446 if (!ASTFrontendAction::BeginSourceFileAction(CI))
447 return false;
448 if (Callbacks)
449 return Callbacks->handleBeginSource(CI);
450 return true;
451 }
452
453 void EndSourceFileAction() override {
454 if (Callbacks)
455 Callbacks->handleEndSource();
456 ASTFrontendAction::EndSourceFileAction();
457 }
458
459 private:
460 FactoryT *ConsumerFactory;
461 SourceFileCallbacks *Callbacks;
462 };
463 FactoryT *ConsumerFactory;
464 SourceFileCallbacks *Callbacks;
465 };
466
467 return std::unique_ptr<FrontendActionFactory>(
468 new FrontendActionFactoryAdapter(ConsumerFactory, Callbacks));
469}
470
471/// Returns the absolute path of \c File, by prepending it with
472/// the current directory if \c File is not absolute.
473///
474/// Otherwise returns \c File.
475/// If 'File' starts with "./", the returned path will not contain the "./".
476/// Otherwise, the returned path will contain the literal path-concatenation of
477/// the current directory and \c File.
478///
479/// The difference to llvm::sys::fs::make_absolute is the canonicalization this
480/// does by removing "./" and computing native paths.
481///
482/// \param File Either an absolute or relative path.
483std::string getAbsolutePath(StringRef File);
484
485/// An overload of getAbsolutePath that works over the provided \p FS.
486llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS,
487 StringRef File);
488
489/// Changes CommandLine to contain implicit flags that would have been
490/// defined had the compiler driver been invoked through the path InvokedAs.
491///
492/// For example, when called with \c InvokedAs set to `i686-linux-android-g++`,
493/// the arguments '-target', 'i686-linux-android`, `--driver-mode=g++` will
494/// be inserted after the first argument in \c CommandLine.
495///
496/// This function will not add new `-target` or `--driver-mode` flags if they
497/// are already present in `CommandLine` (even if they have different settings
498/// than would have been inserted).
499///
500/// \pre `llvm::InitializeAllTargets()` has been called.
501///
502/// \param CommandLine the command line used to invoke the compiler driver or
503/// Clang tool, including the path to the executable as \c CommandLine[0].
504/// \param InvokedAs the path to the driver used to infer implicit flags.
505///
506/// \note This will not set \c CommandLine[0] to \c InvokedAs. The tooling
507/// infrastructure expects that CommandLine[0] is a tool path relative to which
508/// the builtin headers can be found.
509void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
510 StringRef InvokedAs);
511
512/// Helper function that expands response files in command line.
513void addExpandedResponseFiles(std::vector<std::string> &CommandLine,
514 llvm::StringRef WorkingDir,
515 llvm::cl::TokenizerCallback Tokenizer,
516 llvm::vfs::FileSystem &FS);
517
518/// Creates a \c CompilerInvocation.
521 const char *const BinaryName);
522
523} // namespace tooling
524
525} // namespace clang
526
527#endif // LLVM_CLANG_TOOLING_TOOLING_H
Defines the clang::FileManager interface and associated types.
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Abstract base class to use for AST consumer-based frontend actions.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Helper class for holding the data necessary to invoke the compiler.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1684
Options for controlling the compiler diagnostics engine.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:231
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
Utility to run a FrontendAction over a set of files.
Definition: Tooling.h:317
int run(ToolAction *Action)
Runs an action over all files specified in the command line.
Definition: Tooling.cpp:519
void setPrintErrorMessage(bool PrintErrorMessage)
Sets whether an error message should be printed out if an action fails.
Definition: Tooling.cpp:677
void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer)
Set a DiagnosticConsumer to use during parsing.
Definition: Tooling.h:342
void appendArgumentsAdjuster(ArgumentsAdjuster Adjuster)
Append a command line arguments adjuster to the adjuster chain.
Definition: Tooling.cpp:498
void clearArgumentsAdjusters()
Clear the command line arguments adjuster chain.
Definition: Tooling.cpp:502
void mapVirtualFile(StringRef FilePath, StringRef Content)
Map a virtual file to be used while running the tool.
Definition: Tooling.cpp:494
FileManager & getFiles()
Returns the file manager used in the tool.
Definition: Tooling.h:380
llvm::ArrayRef< std::string > getSourcePaths() const
Definition: Tooling.h:382
int buildASTs(std::vector< std::unique_ptr< ASTUnit > > &ASTs)
Create an AST for each file specified in the command line and append them to ASTs.
Definition: Tooling.cpp:672
Interface for compilation databases.
Interface to generate clang::FrontendActions.
Definition: Tooling.h:98
virtual std::unique_ptr< FrontendAction > create()=0
Returns a new clang::FrontendAction.
bool runInvocation(std::shared_ptr< CompilerInvocation > Invocation, FileManager *Files, std::shared_ptr< PCHContainerOperations > PCHContainerOps, DiagnosticConsumer *DiagConsumer) override
Invokes the compiler with a FrontendAction created by create().
Definition: Tooling.cpp:445
Callbacks called before and after each source file processed by a FrontendAction created by the Front...
Definition: Tooling.h:125
virtual bool handleBeginSource(CompilerInstance &CI)
Called before a source file is processed by a FrontEndAction.
Definition: Tooling.h:131
virtual ~SourceFileCallbacks()=default
virtual void handleEndSource()
Called after a source file is processed by a FrontendAction.
Definition: Tooling.h:137
Interface to process a clang::CompilerInvocation.
Definition: Tooling.h:80
virtual bool runInvocation(std::shared_ptr< CompilerInvocation > Invocation, FileManager *Files, std::shared_ptr< PCHContainerOperations > PCHContainerOps, DiagnosticConsumer *DiagConsumer)=0
Perform an action for an invocation.
Utility to run a FrontendAction in a single clang invocation.
Definition: Tooling.h:245
ToolInvocation & operator=(const ToolInvocation &)=delete
void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer)
Set a DiagnosticConsumer to use during driver command-line parsing and the action invocation itself.
Definition: Tooling.h:281
void setDiagnosticOptions(DiagnosticOptions *DiagOpts)
Set a DiagnosticOptions to use during driver command-line parsing.
Definition: Tooling.h:286
ToolInvocation(const ToolInvocation &)=delete
bool run()
Run the clang invocation.
Definition: Tooling.cpp:372
std::vector< std::pair< std::string, std::string > > FileContentMappings
The first part of the pair is the filename, the second part the file-content.
Definition: Tooling.h:171
const llvm::opt::ArgStringList * getCC1Arguments(DiagnosticsEngine *Diagnostics, driver::Compilation *Compilation)
Retrieves the flags of the -cc1 job in Compilation that has only source files as its inputs.
Definition: Tooling.cpp:133
std::unique_ptr< ASTUnit > buildASTFromCode(StringRef Code, StringRef FileName="input.cc", std::shared_ptr< PCHContainerOperations > PCHContainerOps=std::make_shared< PCHContainerOperations >())
Builds an AST for 'Code'.
Definition: Tooling.cpp:685
ArgumentsAdjuster getClangStripDependencyFileAdjuster()
Gets an argument adjuster which removes dependency-file related command line arguments.
std::unique_ptr< ASTUnit > buildASTFromCodeWithArgs(StringRef Code, const std::vector< std::string > &Args, StringRef FileName="input.cc", StringRef ToolName="clang-tool", std::shared_ptr< PCHContainerOperations > PCHContainerOps=std::make_shared< PCHContainerOperations >(), ArgumentsAdjuster Adjuster=getClangStripDependencyFileAdjuster(), const FileContentMappings &VirtualMappedFiles=FileContentMappings(), DiagnosticConsumer *DiagConsumer=nullptr, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS=llvm::vfs::getRealFileSystem())
Builds an AST for 'Code' with additional flags.
Definition: Tooling.cpp:691
std::function< CommandLineArguments(const CommandLineArguments &, StringRef Filename)> ArgumentsAdjuster
A prototype of a command line adjuster.
void addExpandedResponseFiles(std::vector< std::string > &CommandLine, llvm::StringRef WorkingDir, llvm::cl::TokenizerCallback Tokenizer, llvm::vfs::FileSystem &FS)
Helper function that expands response files in command line.
Definition: Tooling.cpp:308
void addTargetAndModeForProgramName(std::vector< std::string > &CommandLine, StringRef InvokedAs)
Changes CommandLine to contain implicit flags that would have been defined had the compiler driver be...
Definition: Tooling.cpp:271
bool runToolOnCodeWithArgs(std::unique_ptr< FrontendAction > ToolAction, const Twine &Code, const std::vector< std::string > &Args, const Twine &FileName="input.cc", const Twine &ToolName="clang-tool", std::shared_ptr< PCHContainerOperations > PCHContainerOps=std::make_shared< PCHContainerOperations >(), const FileContentMappings &VirtualMappedFiles=FileContentMappings())
Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag and with additional other flags.
Definition: Tooling.cpp:227
CompilerInvocation * newInvocation(DiagnosticsEngine *Diagnostics, ArrayRef< const char * > CC1Args, const char *const BinaryName)
Creates a CompilerInvocation.
Definition: Tooling.cpp:171
std::unique_ptr< FrontendActionFactory > newFrontendActionFactory()
Returns a new FrontendActionFactory for a given type.
Definition: Tooling.h:406
std::string getAbsolutePath(StringRef File)
Returns the absolute path of File, by prepending it with the current directory if File is not absolut...
Definition: Tooling.cpp:267
bool runToolOnCode(std::unique_ptr< FrontendAction > ToolAction, const Twine &Code, const Twine &FileName="input.cc", std::shared_ptr< PCHContainerOperations > PCHContainerOps=std::make_shared< PCHContainerOperations >())
Runs (and deletes) the tool on 'Code' with the -fsyntax-only flag.
Definition: Tooling.cpp:183
The JSON file list parser is used to communicate input to InstallAPI.