clang 18.0.0git
ASTRecordReader.h
Go to the documentation of this file.
1//===- ASTRecordReader.h - Helper classes for reading AST -------*- 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 classes that are useful in the implementation of
10// the ASTReader.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_SERIALIZATION_ASTRECORDREADER_H
15#define LLVM_CLANG_SERIALIZATION_ASTRECORDREADER_H
16
19#include "clang/Lex/Token.h"
22#include "llvm/ADT/APFloat.h"
23#include "llvm/ADT/APInt.h"
24#include "llvm/ADT/APSInt.h"
25
26namespace clang {
27class OMPTraitInfo;
28class OMPChildren;
29
30/// An object for streaming information from a record.
32 : public serialization::DataStreamBasicReader<ASTRecordReader> {
35
36 ASTReader *Reader;
37 ModuleFile *F;
38 unsigned Idx = 0;
40
43
44public:
45 /// Construct an ASTRecordReader that uses the default encoding scheme.
47 : DataStreamBasicReader(Reader.getContext()), Reader(&Reader), F(&F) {}
48
49 /// Reads a record with id AbbrevID from Cursor, resetting the
50 /// internal state.
51 Expected<unsigned> readRecord(llvm::BitstreamCursor &Cursor,
52 unsigned AbbrevID);
53
54 /// Is this a module file for a module (rather than a PCH or similar).
55 bool isModule() const { return F->isModule(); }
56
57 /// Retrieve the AST context that this AST reader supplements.
58 ASTContext &getContext() { return Reader->getContext(); }
59
60 /// The current position in this record.
61 unsigned getIdx() const { return Idx; }
62
63 /// The length of this record.
64 size_t size() const { return Record.size(); }
65
66 /// An arbitrary index in this record.
67 const uint64_t &operator[](size_t N) { return Record[N]; }
68
69 /// Returns the last value in this record.
70 uint64_t back() { return Record.back(); }
71
72 /// Returns the current value in this record, and advances to the
73 /// next value.
74 uint64_t readInt() { return Record[Idx++]; }
75
77 auto Array = llvm::ArrayRef(Record).slice(Idx, Len);
78 Idx += Len;
79 return Array;
80 }
81
82 /// Returns the current value in this record, without advancing.
83 uint64_t peekInt() { return Record[Idx]; }
84
85 /// Skips the specified number of values.
86 void skipInts(unsigned N) { Idx += N; }
87
88 /// Retrieve the global submodule ID its local ID number.
90 getGlobalSubmoduleID(unsigned LocalID) {
91 return Reader->getGlobalSubmoduleID(*F, LocalID);
92 }
93
94 /// Retrieve the submodule that corresponds to a global submodule ID.
96 return Reader->getSubmodule(GlobalID);
97 }
98
99 /// Read the record that describes the lexical contents of a DC.
100 bool readLexicalDeclContextStorage(uint64_t Offset, DeclContext *DC) {
101 return Reader->ReadLexicalDeclContextStorage(*F, F->DeclsCursor, Offset,
102 DC);
103 }
104
105 /// Read the record that describes the visible contents of a DC.
106 bool readVisibleDeclContextStorage(uint64_t Offset,
108 return Reader->ReadVisibleDeclContextStorage(*F, F->DeclsCursor, Offset,
109 ID);
110 }
111
113 uint64_t Kind = readInt();
114 bool HasExpr = Kind & 0x1;
115 Kind = Kind >> 1;
116 return ExplicitSpecifier(HasExpr ? readExpr() : nullptr,
117 static_cast<ExplicitSpecKind>(Kind));
118 }
119
120 /// Read information about an exception specification (inherited).
121 //FunctionProtoType::ExceptionSpecInfo
122 //readExceptionSpecInfo(SmallVectorImpl<QualType> &ExceptionStorage);
123
124 /// Get the global offset corresponding to a local offset.
125 uint64_t getGlobalBitOffset(uint64_t LocalOffset) {
126 return Reader->getGlobalBitOffset(*F, LocalOffset);
127 }
128
129 /// Reads a statement.
130 Stmt *readStmt() { return Reader->ReadStmt(*F); }
131 Stmt *readStmtRef() { return readStmt(); /* FIXME: readSubStmt? */ }
132
133 /// Reads an expression.
134 Expr *readExpr() { return Reader->ReadExpr(*F); }
135
136 /// Reads a sub-statement operand during statement reading.
137 Stmt *readSubStmt() { return Reader->ReadSubStmt(); }
138
139 /// Reads a sub-expression operand during statement reading.
140 Expr *readSubExpr() { return Reader->ReadSubExpr(); }
141
142 /// Reads a declaration with the given local ID in the given module.
143 ///
144 /// \returns The requested declaration, casted to the given return type.
145 template<typename T>
146 T *GetLocalDeclAs(uint32_t LocalID) {
147 return cast_or_null<T>(Reader->GetLocalDecl(*F, LocalID));
148 }
149
150 /// Reads a TemplateArgumentLocInfo appropriate for the
151 /// given TemplateArgument kind, advancing Idx.
154
155 /// Reads a TemplateArgumentLoc, advancing Idx.
157
159
162
163 // Reads a concept reference from the given record.
165
166 /// Reads a declarator info from the given record, advancing Idx.
168
169 /// Reads the location information for a type.
170 void readTypeLoc(TypeLoc TL, LocSeq *Seq = nullptr);
171
172 /// Map a local type ID within a given AST file to a global type ID.
173 serialization::TypeID getGlobalTypeID(unsigned LocalID) const {
174 return Reader->getGlobalTypeID(*F, LocalID);
175 }
176
179 }
180
181 /// Read a type from the current position in the record.
183 return Reader->readType(*F, Record, Idx);
184 }
186 return readType();
187 }
188
189 /// Reads a declaration ID from the given position in this record.
190 ///
191 /// \returns The declaration ID read from the record, adjusted to a global ID.
193 return Reader->ReadDeclID(*F, Record, Idx);
194 }
195
196 /// Reads a declaration from the given position in a record in the
197 /// given module, advancing Idx.
199 return Reader->ReadDecl(*F, Record, Idx);
200 }
202 return readDecl();
203 }
204
205 /// Reads a declaration from the given position in the record,
206 /// advancing Idx.
207 ///
208 /// \returns The declaration read from this location, casted to the given
209 /// result type.
210 template<typename T>
212 return Reader->ReadDeclAs<T>(*F, Record, Idx);
213 }
214
216 return Reader->readIdentifier(*F, Record, Idx);
217 }
218
219 /// Read a selector from the Record, advancing Idx.
221 return Reader->ReadSelector(*F, Record, Idx);
222 }
223
224 /// Read a declaration name, advancing Idx.
225 // DeclarationName readDeclarationName(); (inherited)
228
230
231 /// Return a nested name specifier, advancing Idx.
232 // NestedNameSpecifier *readNestedNameSpecifier(); (inherited)
233
235
236 /// Read a template name, advancing Idx.
237 // TemplateName readTemplateName(); (inherited)
238
239 /// Read a template argument, advancing Idx. (inherited)
240 // TemplateArgument readTemplateArgument();
241 using DataStreamBasicReader::readTemplateArgument;
244 if (Canonicalize) {
246 }
247 return Arg;
248 }
249
250 /// Read a template parameter list, advancing Idx.
252
253 /// Read a template argument array, advancing Idx.
255 bool Canonicalize = false);
256
257 /// Read a UnresolvedSet structure, advancing Idx.
259
260 /// Read a C++ base specifier, advancing Idx.
262
263 /// Read a CXXCtorInitializer array, advancing Idx.
265
267 return Reader->ReadCXXTemporary(*F, Record, Idx);
268 }
269
270 /// Read an OMPTraitInfo object, advancing Idx.
272
273 /// Read an OpenMP clause, advancing Idx.
275
276 /// Read an OpenMP children, advancing Idx.
278
279 /// Read a source location, advancing Idx.
281 return Reader->ReadSourceLocation(*F, Record, Idx, Seq);
282 }
283
284 /// Read a source range, advancing Idx.
286 return Reader->ReadSourceRange(*F, Record, Idx, Seq);
287 }
288
289 /// Read an arbitrary constant value, advancing Idx.
290 // APValue readAPValue(); (inherited)
291
292 /// Read an integral value, advancing Idx.
293 // llvm::APInt readAPInt(); (inherited)
294
295 /// Read a signed integral value, advancing Idx.
296 // llvm::APSInt readAPSInt(); (inherited)
297
298 /// Read a floating-point value, advancing Idx.
299 llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem);
300
301 /// Read a boolean value, advancing Idx.
302 bool readBool() { return readInt() != 0; }
303
304 /// Read a 32-bit unsigned value; required to satisfy BasicReader.
305 uint32_t readUInt32() {
306 return uint32_t(readInt());
307 }
308
309 /// Read a 64-bit unsigned value; required to satisfy BasicReader.
310 uint64_t readUInt64() {
311 return readInt();
312 }
313
314 /// Read a string, advancing Idx.
315 std::string readString() {
316 return Reader->ReadString(Record, Idx);
317 }
318
319 /// Read a path, advancing Idx.
320 std::string readPath() {
321 return Reader->ReadPath(*F, Record, Idx);
322 }
323
324 /// Read a version tuple, advancing Idx.
325 VersionTuple readVersionTuple() {
326 return ASTReader::ReadVersionTuple(Record, Idx);
327 }
328
329 /// Reads one attribute from the current stream position, advancing Idx.
330 Attr *readAttr();
331
332 /// Reads attributes from the current stream position, advancing Idx.
333 void readAttributes(AttrVec &Attrs);
334
335 /// Read an BTFTypeTagAttr object.
336 BTFTypeTagAttr *readBTFTypeTagAttr() {
337 return cast<BTFTypeTagAttr>(readAttr());
338 }
339
340 /// Reads a token out of a record, advancing Idx.
342 return Reader->ReadToken(*F, Record, Idx);
343 }
344
345 void recordSwitchCaseID(SwitchCase *SC, unsigned ID) {
346 Reader->RecordSwitchCaseID(SC, ID);
347 }
348
349 /// Retrieve the switch-case statement with the given ID.
351 return Reader->getSwitchCaseWithID(ID);
352 }
353};
354
355/// Helper class that saves the current stream position and
356/// then restores it when destroyed.
358 explicit SavedStreamPosition(llvm::BitstreamCursor &Cursor)
359 : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) {}
360
362 if (llvm::Error Err = Cursor.JumpToBit(Offset))
363 llvm::report_fatal_error(
364 llvm::Twine("Cursor should always be able to go back, failed: ") +
365 toString(std::move(Err)));
366 }
367
368private:
369 llvm::BitstreamCursor &Cursor;
370 uint64_t Offset;
371};
372
373} // namespace clang
374
375#endif
Defines the clang::ASTContext interface.
static char ID
Definition: Arena.cpp:183
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:366
SmallVectorImpl< uint64_t > RecordDataImpl
Definition: ASTReader.h:380
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
Definition: ASTReader.cpp:9356
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2347
static std::string ReadString(const RecordDataImpl &Record, unsigned &Idx)
Definition: ASTReader.cpp:9299
Decl * GetLocalDecl(ModuleFile &F, uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
Definition: ASTReader.h:1914
QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a type from the current position in the given record, which was read from the given AST file.
Definition: ASTReader.h:1882
Stmt * ReadSubStmt()
Reads a sub-statement operand during statement reading.
Definition: ASTReader.h:2302
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, SourceLocation::UIntTy Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
Definition: ASTReader.h:2225
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx, LocSeq *Seq=nullptr)
Read a source range.
Definition: ASTReader.cpp:9286
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9306
serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
Definition: ASTReader.cpp:7784
Selector ReadSelector(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:2200
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Definition: ASTReader.cpp:9321
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
Definition: ASTReader.cpp:1784
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.cpp:9363
T * ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1954
Stmt * ReadStmt(ModuleFile &F)
Reads a statement.
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
Definition: ASTReader.cpp:8916
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9333
Decl * ReadDecl(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1944
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:8931
SmallVector< uint64_t, 64 > RecordData
Definition: ASTReader.h:379
serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const
Map a local type ID within a given AST file into a global type ID.
Definition: ASTReader.cpp:7399
IdentifierInfo * readIdentifier(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:2126
An object for streaming information from a record.
bool readBool()
Read a boolean value, advancing Idx.
std::string readString()
Read a string, advancing Idx.
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx.
uint32_t readUInt32()
Read a 32-bit unsigned value; required to satisfy BasicReader.
llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem)
Read an arbitrary constant value, advancing Idx.
Definition: ASTReader.cpp:9294
TemplateArgumentLoc readTemplateArgumentLoc()
Reads a TemplateArgumentLoc, advancing Idx.
Definition: ASTReader.cpp:7449
void readTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Reads the location information for a type.
Definition: ASTReader.cpp:7088
ExplicitSpecifier readExplicitSpec()
uint64_t getGlobalBitOffset(uint64_t LocalOffset)
Read information about an exception specification (inherited).
void readUnresolvedSet(LazyASTUnresolvedSet &Set)
Read a UnresolvedSet structure, advancing Idx.
Definition: ASTReader.cpp:9134
bool readLexicalDeclContextStorage(uint64_t Offset, DeclContext *DC)
Read the record that describes the lexical contents of a DC.
void readTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, bool Canonicalize=false)
Read a template argument array, advancing Idx.
Definition: ASTReader.cpp:9124
void readAttributes(AttrVec &Attrs)
Reads attributes from the current stream position, advancing Idx.
void readQualifierInfo(QualifierInfo &Info)
Definition: ASTReader.cpp:9092
unsigned getIdx() const
The current position in this record.
DeclarationNameLoc readDeclarationNameLoc(DeclarationName Name)
Read a declaration name, advancing Idx.
Definition: ASTReader.cpp:9059
CXXBaseSpecifier readCXXBaseSpecifier()
Read a C++ base specifier, advancing Idx.
Definition: ASTReader.cpp:9145
QualType readType()
Read a type from the current position in the record.
T * GetLocalDeclAs(uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
Expected< unsigned > readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
DeclarationNameInfo readDeclarationNameInfo()
Definition: ASTReader.cpp:9084
const uint64_t & operator[](size_t N)
An arbitrary index in this record.
serialization::DeclID readDeclID()
Reads a declaration ID from the given position in this record.
size_t size() const
The length of this record.
IdentifierInfo * readIdentifier()
TemplateArgumentLocInfo readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind)
Reads a TemplateArgumentLocInfo appropriate for the given TemplateArgument kind, advancing Idx.
Definition: ASTReader.cpp:7418
uint64_t readUInt64()
Read a 64-bit unsigned value; required to satisfy BasicReader.
TemplateArgument readTemplateArgument(bool Canonicalize)
std::string readPath()
Read a path, advancing Idx.
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
Definition: ASTReader.cpp:7095
uint64_t peekInt()
Returns the current value in this record, without advancing.
void readTemplateArgumentListInfo(TemplateArgumentListInfo &Result)
Definition: ASTReader.cpp:7459
BTFTypeTagAttr * readBTFTypeTagAttr()
Read an BTFTypeTagAttr object.
void skipInts(unsigned N)
Skips the specified number of values.
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
serialization::TypeID getGlobalTypeID(unsigned LocalID) const
Map a local type ID within a given AST file to a global type ID.
NestedNameSpecifierLoc readNestedNameSpecifierLoc()
Return a nested name specifier, advancing Idx.
Definition: ASTReader.cpp:9225
ASTRecordReader(ASTReader &Reader, ModuleFile &F)
Construct an ASTRecordReader that uses the default encoding scheme.
ConceptReference * readConceptReference()
Definition: ASTReader.cpp:6935
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Token readToken()
Reads a token out of a record, advancing Idx.
void recordSwitchCaseID(SwitchCase *SC, unsigned ID)
void readOMPChildren(OMPChildren *Data)
Read an OpenMP children, advancing Idx.
OMPClause * readOMPClause()
Read an OpenMP clause, advancing Idx.
Selector readSelector()
Read a selector from the Record, advancing Idx.
CXXTemporary * readCXXTemporary()
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
TemplateParameterList * readTemplateParameterList()
Read a template parameter list, advancing Idx.
Definition: ASTReader.cpp:9105
VersionTuple readVersionTuple()
Read a version tuple, advancing Idx.
uint64_t back()
Returns the last value in this record.
serialization::SubmoduleID getGlobalSubmoduleID(unsigned LocalID)
Retrieve the global submodule ID its local ID number.
CXXCtorInitializer ** readCXXCtorInitializers()
Read a CXXCtorInitializer array, advancing Idx.
Definition: ASTReader.cpp:9160
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Stmt * readStmt()
Reads a statement.
const ASTTemplateArgumentListInfo * readASTTemplateArgumentListInfo()
Definition: ASTReader.cpp:7469
Stmt * readSubStmt()
Reads a sub-statement operand during statement reading.
bool readVisibleDeclContextStorage(uint64_t Offset, serialization::DeclID ID)
Read the record that describes the visible contents of a DC.
uint64_t readInt()
Returns the current value in this record, and advances to the next value.
Attr * readAttr()
Reads one attribute from the current stream position, advancing Idx.
Expr * readExpr()
Reads an expression.
ArrayRef< uint64_t > readIntArray(unsigned Len)
SourceLocation readSourceLocation(LocSeq *Seq=nullptr)
Read a source location, advancing Idx.
Expr * readSubExpr()
Reads a sub-expression operand during statement reading.
Attr - This represents one attribute.
Definition: Attr.h:41
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2293
Represents a C++ temporary.
Definition: ExprCXX.h:1443
A reference to a concept and its template args, as it appears in the code.
Definition: ASTConcept.h:128
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1435
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
DeclarationNameLoc - Additional source/type location info for a declaration name.
The name of a declaration.
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1900
This represents one expression.
Definition: Expr.h:110
One of these records is kept for each identifier that is lexed.
An UnresolvedSet-like class that might not have been loaded from the external AST source yet.
Describes a module or submodule.
Definition: Module.h:105
A C++ nested-name-specifier augmented with source location information.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:55
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
A (possibly-)qualified type.
Definition: Type.h:736
The collection of all-type qualifiers we support.
Definition: Type.h:146
static Qualifiers fromOpaqueValue(unsigned opaque)
Definition: Type.h:252
Smart pointer class that efficiently represents Objective-C method names.
Serialized encoding of a sequence of SourceLocations.
Encodes a location in the source.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
Definition: Stmt.h:84
A convenient class for passing around template argument information.
Definition: TemplateBase.h:601
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:495
Represents a template argument.
Definition: TemplateBase.h:60
ArgKind
The kind of template argument we're storing.
Definition: TemplateBase.h:63
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
A container of type source information.
Definition: Type.h:6752
DataStreamBasicReader provides convenience implementations for many BasicReader methods based on the ...
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:124
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:446
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: ModuleFile.h:520
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:85
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:171
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
@ Result
The result type of a method or function.
ExplicitSpecKind
Define the meaning of possible values of the kind in ExplicitSpecifier.
Definition: Specifiers.h:28
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:652
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:741
Helper class that saves the current stream position and then restores it when destroyed.
SavedStreamPosition(llvm::BitstreamCursor &Cursor)
Location information for a TemplateArgument.
Definition: TemplateBase.h:443