clang-tools 17.0.0git
ParsedAST.h
Go to the documentation of this file.
1//===--- ParsedAST.h - Building translation units ----------------*- 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 exposes building a file as if it were open in clangd, and defines
10// the ParsedAST structure that holds the results.
11//
12// This is similar to a clang -fsyntax-only run that produces a clang AST, but
13// we have several customizations:
14// - preamble handling
15// - capturing diagnostics for later access
16// - running clang-tidy checks
17//
18//===----------------------------------------------------------------------===//
19
20#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H
21#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H
22
23#include "CollectMacros.h"
24#include "Compiler.h"
25#include "Diagnostics.h"
26#include "Headers.h"
27#include "Preamble.h"
28#include "clang-include-cleaner/Record.h"
30#include "support/Path.h"
31#include "clang/Frontend/FrontendAction.h"
32#include "clang/Lex/Preprocessor.h"
33#include "clang/Tooling/Syntax/Tokens.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/StringRef.h"
36#include <memory>
37#include <optional>
38#include <string>
39#include <vector>
40
41namespace clang {
42class Sema;
43namespace clangd {
44class HeuristicResolver;
45
46/// Stores and provides access to parsed AST.
47class ParsedAST {
48public:
49 /// Attempts to run Clang and store the parsed AST.
50 /// If \p Preamble is non-null it is reused during parsing.
51 /// This function does not check if preamble is valid to reuse.
52 static std::optional<ParsedAST>
53 build(llvm::StringRef Filename, const ParseInputs &Inputs,
54 std::unique_ptr<clang::CompilerInvocation> CI,
55 llvm::ArrayRef<Diag> CompilerInvocationDiags,
56 std::shared_ptr<const PreambleData> Preamble);
57
60
61 ~ParsedAST();
62
63 /// Note that the returned ast will not contain decls from the preamble that
64 /// were not deserialized during parsing. Clients should expect only decls
65 /// from the main file to be in the AST.
66 ASTContext &getASTContext();
67 const ASTContext &getASTContext() const;
68
69 Sema &getSema();
70
71 Preprocessor &getPreprocessor();
72 std::shared_ptr<Preprocessor> getPreprocessorPtr();
73 const Preprocessor &getPreprocessor() const;
74
75 SourceManager &getSourceManager() {
76 return getASTContext().getSourceManager();
77 }
78 const SourceManager &getSourceManager() const {
79 return getASTContext().getSourceManager();
80 }
81
82 const LangOptions &getLangOpts() const {
83 return getASTContext().getLangOpts();
84 }
85
86 /// This function returns top-level decls present in the main file of the AST.
87 /// The result does not include the decls that come from the preamble.
88 /// (These should be const, but RecursiveASTVisitor requires Decl*).
89 ArrayRef<Decl *> getLocalTopLevelDecls();
90 ArrayRef<const Decl *> getLocalTopLevelDecls() const;
91
92 const std::optional<std::vector<Diag>> &getDiagnostics() const {
93 return Diags;
94 }
95
96 /// Returns the estimated size of the AST and the accessory structures, in
97 /// bytes. Does not include the size of the preamble.
98 std::size_t getUsedBytes() const;
101
102 /// Gets all macro references (definition, expansions) present in the main
103 /// file, including those in the preamble region.
104 const MainFileMacros &getMacros() const;
105 /// Gets all pragma marks in the main file.
106 const std::vector<PragmaMark> &getMarks() const;
107 /// Tokens recorded while parsing the main file.
108 /// (!) does not have tokens from the preamble.
109 const syntax::TokenBuffer &getTokens() const { return Tokens; }
110 /// Returns the PramaIncludes from the preamble.
111 /// Might be null if AST is built without a preamble.
112 const include_cleaner::PragmaIncludes *getPragmaIncludes() const;
113
114 /// Returns the version of the ParseInputs this AST was built from.
115 llvm::StringRef version() const { return Version; }
116
117 /// Returns the path passed by the caller when building this AST.
118 PathRef tuPath() const { return TUPath; }
119
120 /// Returns the version of the ParseInputs used to build Preamble part of this
121 /// AST. Might be std::nullopt if no Preamble is used.
122 std::optional<llvm::StringRef> preambleVersion() const;
123
125 return Resolver.get();
126 }
127
128private:
129 ParsedAST(PathRef TUPath, llvm::StringRef Version,
130 std::shared_ptr<const PreambleData> Preamble,
131 std::unique_ptr<CompilerInstance> Clang,
132 std::unique_ptr<FrontendAction> Action, syntax::TokenBuffer Tokens,
133 MainFileMacros Macros, std::vector<PragmaMark> Marks,
134 std::vector<Decl *> LocalTopLevelDecls,
135 std::optional<std::vector<Diag>> Diags, IncludeStructure Includes,
136 CanonicalIncludes CanonIncludes);
137
138 Path TUPath;
139 std::string Version;
140 // In-memory preambles must outlive the AST, it is important that this member
141 // goes before Clang and Action.
142 std::shared_ptr<const PreambleData> Preamble;
143 // We store an "incomplete" FrontendAction (i.e. no EndSourceFile was called
144 // on it) and CompilerInstance used to run it. That way we don't have to do
145 // complex memory management of all Clang structures on our own. (They are
146 // stored in CompilerInstance and cleaned up by
147 // FrontendAction.EndSourceFile).
148 std::unique_ptr<CompilerInstance> Clang;
149 std::unique_ptr<FrontendAction> Action;
150 /// Tokens recorded after the preamble finished.
151 /// - Includes all spelled tokens for the main file.
152 /// - Includes expanded tokens produced **after** preamble.
153 /// - Does not have spelled or expanded tokens for files from preamble.
154 syntax::TokenBuffer Tokens;
155
156 /// All macro definitions and expansions in the main file.
157 MainFileMacros Macros;
158 // Pragma marks in the main file.
159 std::vector<PragmaMark> Marks;
160 // Data, stored after parsing. std::nullopt if AST was built with a stale
161 // preamble.
162 std::optional<std::vector<Diag>> Diags;
163 // Top-level decls inside the current file. Not that this does not include
164 // top-level decls from the preamble.
165 std::vector<Decl *> LocalTopLevelDecls;
166 IncludeStructure Includes;
167 CanonicalIncludes CanonIncludes;
168 std::unique_ptr<HeuristicResolver> Resolver;
169};
170
171} // namespace clangd
172} // namespace clang
173
174#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H
const PreambleData & Preamble
std::string Filename
Filename as a string.
std::unique_ptr< CompilerInvocation > CI
Maps a definition location onto an #include file, based on a set of filename rules.
Stores and provides access to parsed AST.
Definition: ParsedAST.h:47
std::size_t getUsedBytes() const
Returns the estimated size of the AST and the accessory structures, in bytes.
Definition: ParsedAST.cpp:740
PathRef tuPath() const
Returns the path passed by the caller when building this AST.
Definition: ParsedAST.h:118
std::optional< llvm::StringRef > preambleVersion() const
Returns the version of the ParseInputs used to build Preamble part of this AST.
Definition: ParsedAST.cpp:806
llvm::StringRef version() const
Returns the version of the ParseInputs this AST was built from.
Definition: ParsedAST.h:115
const std::vector< PragmaMark > & getMarks() const
Gets all pragma marks in the main file.
Definition: ParsedAST.cpp:738
const include_cleaner::PragmaIncludes * getPragmaIncludes() const
Returns the PramaIncludes from the preamble.
Definition: ParsedAST.cpp:800
SourceManager & getSourceManager()
Definition: ParsedAST.h:75
ASTContext & getASTContext()
Note that the returned ast will not contain decls from the preamble that were not deserialized during...
Definition: ParsedAST.cpp:711
const HeuristicResolver * getHeuristicResolver() const
Definition: ParsedAST.h:124
const std::optional< std::vector< Diag > > & getDiagnostics() const
Definition: ParsedAST.h:92
const LangOptions & getLangOpts() const
Definition: ParsedAST.h:82
const CanonicalIncludes & getCanonicalIncludes() const
Definition: ParsedAST.cpp:776
static std::optional< ParsedAST > build(llvm::StringRef Filename, const ParseInputs &Inputs, std::unique_ptr< clang::CompilerInvocation > CI, llvm::ArrayRef< Diag > CompilerInvocationDiags, std::shared_ptr< const PreambleData > Preamble)
Attempts to run Clang and store the parsed AST.
Definition: ParsedAST.cpp:345
std::shared_ptr< Preprocessor > getPreprocessorPtr()
Definition: ParsedAST.cpp:721
const syntax::TokenBuffer & getTokens() const
Tokens recorded while parsing the main file.
Definition: ParsedAST.h:109
Preprocessor & getPreprocessor()
Definition: ParsedAST.cpp:719
ArrayRef< Decl * > getLocalTopLevelDecls()
This function returns top-level decls present in the main file of the AST.
Definition: ParsedAST.cpp:729
ParsedAST & operator=(ParsedAST &&Other)
const IncludeStructure & getIncludeStructure() const
Definition: ParsedAST.cpp:772
const SourceManager & getSourceManager() const
Definition: ParsedAST.h:78
ParsedAST(ParsedAST &&Other)
const MainFileMacros & getMacros() const
Gets all macro references (definition, expansions) present in the main file, including those in the p...
Definition: ParsedAST.cpp:737
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:29
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Information required to run clang, e.g. to parse AST or do code completion.
Definition: Compiler.h:48