clang 20.0.0git
TestAST.h
Go to the documentation of this file.
1//===--- TestAST.h - Build clang ASTs for testing -------------------------===//
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// In normal operation of Clang, the FrontendAction's lifecycle both creates
10// and destroys the AST, and code should operate on it during callbacks in
11// between (e.g. via ASTConsumer).
12//
13// For tests it is often more convenient to parse an AST from code, and keep it
14// alive as a normal local object, with assertions as straight-line code.
15// TestAST provides such an interface.
16// (ASTUnit can be used for this purpose, but is a production library with
17// broad scope and complicated API).
18//
19//===----------------------------------------------------------------------===//
20
21#ifndef LLVM_CLANG_TESTING_TESTAST_H
22#define LLVM_CLANG_TESTING_TESTAST_H
23
24#include "clang/Basic/LLVM.h"
27#include "llvm/ADT/StringRef.h"
28#include <string>
29#include <vector>
30
31namespace clang {
32
33/// Specifies a virtual source file to be parsed as part of a test.
34struct TestInputs {
35 TestInputs() = default;
36 TestInputs(StringRef Code) : Code(Code) {}
37
38 /// The source code of the input file to be parsed.
39 std::string Code;
40
41 /// The language to parse as.
42 /// This affects the -x and -std flags used, and the filename.
44
45 /// Extra argv to pass to clang -cc1.
46 std::vector<std::string> ExtraArgs = {};
47
48 /// Extra virtual files that are available to be #included.
49 /// Keys are plain filenames ("foo.h"), values are file content.
50 llvm::StringMap<std::string> ExtraFiles = {};
51
52 /// Root of execution, all relative paths in Args/Files are resolved against
53 /// this.
54 std::string WorkingDir;
55
56 /// Filename to use for translation unit. A default will be used when empty.
57 std::string FileName;
58
59 /// By default, error diagnostics during parsing are reported as gtest errors.
60 /// To suppress this, set ErrorOK or include "error-ok" in a comment in Code.
61 /// In either case, all diagnostics appear in TestAST::diagnostics().
62 bool ErrorOK = false;
63
64 /// The action used to parse the code.
65 /// By default, a SyntaxOnlyAction is used.
66 std::function<std::unique_ptr<FrontendAction>()> MakeAction;
67};
68
69/// The result of parsing a file specified by TestInputs.
70///
71/// The ASTContext, Sema etc are valid as long as this object is alive.
72class TestAST {
73public:
74 /// Constructing a TestAST parses the virtual file.
75 ///
76 /// To keep tests terse, critical errors (e.g. invalid flags) are reported as
77 /// unit test failures with ADD_FAILURE() and produce an empty ASTContext,
78 /// Sema etc. This frees the test code from handling these explicitly.
79 TestAST(const TestInputs &);
80 TestAST(StringRef Code) : TestAST(TestInputs(Code)) {}
81 TestAST(TestAST &&M);
83 ~TestAST();
84
85 /// Provides access to the AST context and other parts of Clang.
86
87 ASTContext &context() { return Clang->getASTContext(); }
88 Sema &sema() { return Clang->getSema(); }
89 SourceManager &sourceManager() { return Clang->getSourceManager(); }
90 FileManager &fileManager() { return Clang->getFileManager(); }
91 Preprocessor &preprocessor() { return Clang->getPreprocessor(); }
92 FrontendAction &action() { return *Action; }
93
94 /// Returns diagnostics emitted during parsing.
95 /// (By default, errors cause test failures, see TestInputs::ErrorOK).
97
98private:
99 void clear();
100 std::unique_ptr<FrontendAction> Action;
101 std::unique_ptr<CompilerInstance> Clang;
102 std::vector<StoredDiagnostic> Diagnostics;
103};
104
105} // end namespace clang
106
107#endif
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:187
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
Abstract base class for actions which can be performed by the frontend.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:137
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:493
This class handles loading and caching of source files into memory.
The result of parsing a file specified by TestInputs.
Definition: TestAST.h:72
Sema & sema()
Definition: TestAST.h:88
Preprocessor & preprocessor()
Definition: TestAST.h:91
ASTContext & context()
Provides access to the AST context and other parts of Clang.
Definition: TestAST.h:87
FileManager & fileManager()
Definition: TestAST.h:90
TestAST(StringRef Code)
Definition: TestAST.h:80
FrontendAction & action()
Definition: TestAST.h:92
TestAST & operator=(TestAST &&)
Definition: TestAST.cpp:157
llvm::ArrayRef< StoredDiagnostic > diagnostics()
Returns diagnostics emitted during parsing.
Definition: TestAST.h:96
SourceManager & sourceManager()
Definition: TestAST.h:89
The JSON file list parser is used to communicate input to InstallAPI.
Language
The language for the input, used to select and validate the language standard and possible actions.
Definition: LangStandard.h:23
Specifies a virtual source file to be parsed as part of a test.
Definition: TestAST.h:34
TestInputs(StringRef Code)
Definition: TestAST.h:36
bool ErrorOK
By default, error diagnostics during parsing are reported as gtest errors.
Definition: TestAST.h:62
std::vector< std::string > ExtraArgs
Extra argv to pass to clang -cc1.
Definition: TestAST.h:46
std::string FileName
Filename to use for translation unit. A default will be used when empty.
Definition: TestAST.h:57
std::string WorkingDir
Root of execution, all relative paths in Args/Files are resolved against this.
Definition: TestAST.h:54
TestInputs()=default
llvm::StringMap< std::string > ExtraFiles
Extra virtual files that are available to be #included.
Definition: TestAST.h:50
std::function< std::unique_ptr< FrontendAction >()> MakeAction
The action used to parse the code.
Definition: TestAST.h:66
std::string Code
The source code of the input file to be parsed.
Definition: TestAST.h:39