clang 19.0.0git
HLSLExternalSemaSource.cpp
Go to the documentation of this file.
1//===--- HLSLExternalSemaSource.cpp - HLSL Sema Source --------------------===//
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//
10//===----------------------------------------------------------------------===//
11
14#include "clang/AST/Attr.h"
15#include "clang/AST/DeclCXX.h"
18#include "clang/Sema/Lookup.h"
19#include "clang/Sema/Sema.h"
20#include "llvm/Frontend/HLSL/HLSLResource.h"
21
22#include <functional>
23
24using namespace clang;
25using namespace llvm::hlsl;
26
27namespace {
28
29struct TemplateParameterListBuilder;
30
31struct BuiltinTypeDeclBuilder {
32 CXXRecordDecl *Record = nullptr;
33 ClassTemplateDecl *Template = nullptr;
34 ClassTemplateDecl *PrevTemplate = nullptr;
35 NamespaceDecl *HLSLNamespace = nullptr;
36 llvm::StringMap<FieldDecl *> Fields;
37
38 BuiltinTypeDeclBuilder(CXXRecordDecl *R) : Record(R) {
39 Record->startDefinition();
40 Template = Record->getDescribedClassTemplate();
41 }
42
43 BuiltinTypeDeclBuilder(Sema &S, NamespaceDecl *Namespace, StringRef Name)
44 : HLSLNamespace(Namespace) {
45 ASTContext &AST = S.getASTContext();
46 IdentifierInfo &II = AST.Idents.get(Name, tok::TokenKind::identifier);
47
49 CXXRecordDecl *PrevDecl = nullptr;
50 if (S.LookupQualifiedName(Result, HLSLNamespace)) {
51 NamedDecl *Found = Result.getFoundDecl();
52 if (auto *TD = dyn_cast<ClassTemplateDecl>(Found)) {
53 PrevDecl = TD->getTemplatedDecl();
54 PrevTemplate = TD;
55 } else
56 PrevDecl = dyn_cast<CXXRecordDecl>(Found);
57 assert(PrevDecl && "Unexpected lookup result type.");
58 }
59
60 if (PrevDecl && PrevDecl->isCompleteDefinition()) {
61 Record = PrevDecl;
62 return;
63 }
64
65 Record = CXXRecordDecl::Create(AST, TagDecl::TagKind::Class, HLSLNamespace,
67 PrevDecl, true);
68 Record->setImplicit(true);
69 Record->setLexicalDeclContext(HLSLNamespace);
70 Record->setHasExternalLexicalStorage();
71
72 // Don't let anyone derive from built-in types.
73 Record->addAttr(FinalAttr::CreateImplicit(AST, SourceRange(),
74 FinalAttr::Keyword_final));
75 }
76
77 ~BuiltinTypeDeclBuilder() {
78 if (HLSLNamespace && !Template && Record->getDeclContext() == HLSLNamespace)
79 HLSLNamespace->addDecl(Record);
80 }
81
82 BuiltinTypeDeclBuilder &
83 addMemberVariable(StringRef Name, QualType Type,
84 AccessSpecifier Access = AccessSpecifier::AS_private) {
85 if (Record->isCompleteDefinition())
86 return *this;
87 assert(Record->isBeingDefined() &&
88 "Definition must be started before adding members!");
89 ASTContext &AST = Record->getASTContext();
90
91 IdentifierInfo &II = AST.Idents.get(Name, tok::TokenKind::identifier);
92 TypeSourceInfo *MemTySource =
95 AST, Record, SourceLocation(), SourceLocation(), &II, Type, MemTySource,
96 nullptr, false, InClassInitStyle::ICIS_NoInit);
97 Field->setAccess(Access);
98 Field->setImplicit(true);
99 Record->addDecl(Field);
100 Fields[Name] = Field;
101 return *this;
102 }
103
104 BuiltinTypeDeclBuilder &
105 addHandleMember(AccessSpecifier Access = AccessSpecifier::AS_private) {
106 if (Record->isCompleteDefinition())
107 return *this;
108 QualType Ty = Record->getASTContext().VoidPtrTy;
109 if (Template) {
110 if (const auto *TTD = dyn_cast<TemplateTypeParmDecl>(
111 Template->getTemplateParameters()->getParam(0)))
112 Ty = Record->getASTContext().getPointerType(
113 QualType(TTD->getTypeForDecl(), 0));
114 }
115 return addMemberVariable("h", Ty, Access);
116 }
117
118 BuiltinTypeDeclBuilder &annotateResourceClass(ResourceClass RC,
119 ResourceKind RK, bool IsROV) {
120 if (Record->isCompleteDefinition())
121 return *this;
122 Record->addAttr(HLSLResourceAttr::CreateImplicit(Record->getASTContext(),
123 RC, RK, IsROV));
124 return *this;
125 }
126
127 static DeclRefExpr *lookupBuiltinFunction(ASTContext &AST, Sema &S,
128 StringRef Name) {
129 CXXScopeSpec SS;
130 IdentifierInfo &II = AST.Idents.get(Name, tok::TokenKind::identifier);
131 DeclarationNameInfo NameInfo =
134 S.LookupParsedName(R, S.getCurScope(), &SS, false);
135 assert(R.isSingleResult() &&
136 "Since this is a builtin it should always resolve!");
137 auto *VD = cast<ValueDecl>(R.getFoundDecl());
138 QualType Ty = VD->getType();
140 VD, false, NameInfo, Ty, VK_PRValue);
141 }
142
143 static Expr *emitResourceClassExpr(ASTContext &AST, ResourceClass RC) {
145 AST,
146 llvm::APInt(AST.getIntWidth(AST.UnsignedCharTy),
147 static_cast<uint8_t>(RC)),
149 }
150
151 BuiltinTypeDeclBuilder &addDefaultHandleConstructor(Sema &S,
152 ResourceClass RC) {
153 if (Record->isCompleteDefinition())
154 return *this;
155 ASTContext &AST = Record->getASTContext();
156
157 QualType ConstructorType =
159
160 CanQualType CanTy = Record->getTypeForDecl()->getCanonicalTypeUnqualified();
163 AST, Record, SourceLocation(),
164 DeclarationNameInfo(Name, SourceLocation()), ConstructorType,
165 AST.getTrivialTypeSourceInfo(ConstructorType, SourceLocation()),
166 ExplicitSpecifier(), false, true, false,
167 ConstexprSpecKind::Unspecified);
168
169 DeclRefExpr *Fn =
170 lookupBuiltinFunction(AST, S, "__builtin_hlsl_create_handle");
171
172 Expr *RCExpr = emitResourceClassExpr(AST, RC);
173 Expr *Call = CallExpr::Create(AST, Fn, {RCExpr}, AST.VoidPtrTy, VK_PRValue,
175
177 AST, SourceLocation(), Constructor->getFunctionObjectParameterType(),
178 true);
179 Expr *Handle = MemberExpr::CreateImplicit(AST, This, false, Fields["h"],
180 Fields["h"]->getType(), VK_LValue,
182
183 // If the handle isn't a void pointer, cast the builtin result to the
184 // correct type.
185 if (Handle->getType().getCanonicalType() != AST.VoidPtrTy) {
187 AST, Handle->getType(), VK_PRValue, CK_Dependent, Call, nullptr,
190 SourceRange());
191 }
192
194 AST, Handle, Call, BO_Assign, Handle->getType(), VK_LValue, OK_Ordinary,
196
197 Constructor->setBody(
200 Constructor->setAccess(AccessSpecifier::AS_public);
201 Record->addDecl(Constructor);
202 return *this;
203 }
204
205 BuiltinTypeDeclBuilder &addArraySubscriptOperators() {
206 if (Record->isCompleteDefinition())
207 return *this;
208 addArraySubscriptOperator(true);
209 addArraySubscriptOperator(false);
210 return *this;
211 }
212
213 BuiltinTypeDeclBuilder &addArraySubscriptOperator(bool IsConst) {
214 if (Record->isCompleteDefinition())
215 return *this;
216 assert(Fields.count("h") > 0 &&
217 "Subscript operator must be added after the handle.");
218
219 FieldDecl *Handle = Fields["h"];
220 ASTContext &AST = Record->getASTContext();
221
222 assert(Handle->getType().getCanonicalType() != AST.VoidPtrTy &&
223 "Not yet supported for void pointer handles.");
224
225 QualType ElemTy =
227 QualType ReturnTy = ElemTy;
228
230
231 // Subscript operators return references to elements, const makes the
232 // reference and method const so that the underlying data is not mutable.
233 ReturnTy = AST.getLValueReferenceType(ReturnTy);
234 if (IsConst) {
235 ExtInfo.TypeQuals.addConst();
236 ReturnTy.addConst();
237 }
238
239 QualType MethodTy =
240 AST.getFunctionType(ReturnTy, {AST.UnsignedIntTy}, ExtInfo);
241 auto *TSInfo = AST.getTrivialTypeSourceInfo(MethodTy, SourceLocation());
242 auto *MethodDecl = CXXMethodDecl::Create(
243 AST, Record, SourceLocation(),
245 AST.DeclarationNames.getCXXOperatorName(OO_Subscript),
247 MethodTy, TSInfo, SC_None, false, false, ConstexprSpecKind::Unspecified,
249
250 IdentifierInfo &II = AST.Idents.get("Idx", tok::TokenKind::identifier);
251 auto *IdxParam = ParmVarDecl::Create(
252 AST, MethodDecl->getDeclContext(), SourceLocation(), SourceLocation(),
253 &II, AST.UnsignedIntTy,
255 SC_None, nullptr);
256 MethodDecl->setParams({IdxParam});
257
258 // Also add the parameter to the function prototype.
259 auto FnProtoLoc = TSInfo->getTypeLoc().getAs<FunctionProtoTypeLoc>();
260 FnProtoLoc.setParam(0, IdxParam);
261
262 auto *This =
264 MethodDecl->getFunctionObjectParameterType(), true);
265 auto *HandleAccess = MemberExpr::CreateImplicit(
266 AST, This, false, Handle, Handle->getType(), VK_LValue, OK_Ordinary);
267
268 auto *IndexExpr = DeclRefExpr::Create(
269 AST, NestedNameSpecifierLoc(), SourceLocation(), IdxParam, false,
270 DeclarationNameInfo(IdxParam->getDeclName(), SourceLocation()),
272
273 auto *Array =
274 new (AST) ArraySubscriptExpr(HandleAccess, IndexExpr, ElemTy, VK_LValue,
276
277 auto *Return = ReturnStmt::Create(AST, SourceLocation(), Array, nullptr);
278
279 MethodDecl->setBody(CompoundStmt::Create(AST, {Return}, FPOptionsOverride(),
281 SourceLocation()));
282 MethodDecl->setLexicalDeclContext(Record);
283 MethodDecl->setAccess(AccessSpecifier::AS_public);
284 MethodDecl->addAttr(AlwaysInlineAttr::CreateImplicit(
285 AST, SourceRange(), AlwaysInlineAttr::CXX11_clang_always_inline));
286 Record->addDecl(MethodDecl);
287
288 return *this;
289 }
290
291 BuiltinTypeDeclBuilder &startDefinition() {
292 if (Record->isCompleteDefinition())
293 return *this;
294 Record->startDefinition();
295 return *this;
296 }
297
298 BuiltinTypeDeclBuilder &completeDefinition() {
299 if (Record->isCompleteDefinition())
300 return *this;
301 assert(Record->isBeingDefined() &&
302 "Definition must be started before completing it.");
303
304 Record->completeDefinition();
305 return *this;
306 }
307
308 TemplateParameterListBuilder addTemplateArgumentList();
309 BuiltinTypeDeclBuilder &addSimpleTemplateParams(ArrayRef<StringRef> Names);
310};
311
312struct TemplateParameterListBuilder {
313 BuiltinTypeDeclBuilder &Builder;
314 ASTContext &AST;
316
317 TemplateParameterListBuilder(BuiltinTypeDeclBuilder &RB)
318 : Builder(RB), AST(RB.Record->getASTContext()) {}
319
320 ~TemplateParameterListBuilder() { finalizeTemplateArgs(); }
321
322 TemplateParameterListBuilder &
323 addTypeParameter(StringRef Name, QualType DefaultValue = QualType()) {
324 if (Builder.Record->isCompleteDefinition())
325 return *this;
326 unsigned Position = static_cast<unsigned>(Params.size());
328 AST, Builder.Record->getDeclContext(), SourceLocation(),
329 SourceLocation(), /* TemplateDepth */ 0, Position,
330 &AST.Idents.get(Name, tok::TokenKind::identifier), /* Typename */ false,
331 /* ParameterPack */ false);
332 if (!DefaultValue.isNull())
333 Decl->setDefaultArgument(AST.getTrivialTypeSourceInfo(DefaultValue));
334
335 Params.emplace_back(Decl);
336 return *this;
337 }
338
339 BuiltinTypeDeclBuilder &finalizeTemplateArgs() {
340 if (Params.empty())
341 return Builder;
342 auto *ParamList =
343 TemplateParameterList::Create(AST, SourceLocation(), SourceLocation(),
344 Params, SourceLocation(), nullptr);
345 Builder.Template = ClassTemplateDecl::Create(
346 AST, Builder.Record->getDeclContext(), SourceLocation(),
347 DeclarationName(Builder.Record->getIdentifier()), ParamList,
348 Builder.Record);
349 Builder.Record->setDescribedClassTemplate(Builder.Template);
350 Builder.Template->setImplicit(true);
351 Builder.Template->setLexicalDeclContext(Builder.Record->getDeclContext());
352 // NOTE: setPreviousDecl before addDecl so new decl replace old decl when
353 // make visible.
354 Builder.Template->setPreviousDecl(Builder.PrevTemplate);
355 Builder.Record->getDeclContext()->addDecl(Builder.Template);
356 Params.clear();
357
358 QualType T = Builder.Template->getInjectedClassNameSpecialization();
359 T = AST.getInjectedClassNameType(Builder.Record, T);
360
361 return Builder;
362 }
363};
364} // namespace
365
366TemplateParameterListBuilder BuiltinTypeDeclBuilder::addTemplateArgumentList() {
367 return TemplateParameterListBuilder(*this);
368}
369
370BuiltinTypeDeclBuilder &
371BuiltinTypeDeclBuilder::addSimpleTemplateParams(ArrayRef<StringRef> Names) {
372 TemplateParameterListBuilder Builder = this->addTemplateArgumentList();
373 for (StringRef Name : Names)
374 Builder.addTypeParameter(Name);
375 return Builder.finalizeTemplateArgs();
376}
377
379
381 SemaPtr = &S;
382 ASTContext &AST = SemaPtr->getASTContext();
383 // If the translation unit has external storage force external decls to load.
385 (void)AST.getTranslationUnitDecl()->decls_begin();
386
387 IdentifierInfo &HLSL = AST.Idents.get("hlsl", tok::TokenKind::identifier);
389 NamespaceDecl *PrevDecl = nullptr;
391 PrevDecl = Result.getAsSingle<NamespaceDecl>();
392 HLSLNamespace = NamespaceDecl::Create(
393 AST, AST.getTranslationUnitDecl(), /*Inline=*/false, SourceLocation(),
394 SourceLocation(), &HLSL, PrevDecl, /*Nested=*/false);
395 HLSLNamespace->setImplicit(true);
396 HLSLNamespace->setHasExternalLexicalStorage();
397 AST.getTranslationUnitDecl()->addDecl(HLSLNamespace);
398
399 // Force external decls in the HLSL namespace to load from the PCH.
400 (void)HLSLNamespace->getCanonicalDecl()->decls_begin();
401 defineTrivialHLSLTypes();
402 defineHLSLTypesWithForwardDeclarations();
403
404 // This adds a `using namespace hlsl` directive. In DXC, we don't put HLSL's
405 // built in types inside a namespace, but we are planning to change that in
406 // the near future. In order to be source compatible older versions of HLSL
407 // will need to implicitly use the hlsl namespace. For now in clang everything
408 // will get added to the namespace, and we can remove the using directive for
409 // future language versions to match HLSL's evolution.
412 NestedNameSpecifierLoc(), SourceLocation(), HLSLNamespace,
414
416}
417
418void HLSLExternalSemaSource::defineHLSLVectorAlias() {
419 ASTContext &AST = SemaPtr->getASTContext();
420
421 llvm::SmallVector<NamedDecl *> TemplateParams;
422
423 auto *TypeParam = TemplateTypeParmDecl::Create(
424 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 0,
425 &AST.Idents.get("element", tok::TokenKind::identifier), false, false);
426 TypeParam->setDefaultArgument(AST.getTrivialTypeSourceInfo(AST.FloatTy));
427
428 TemplateParams.emplace_back(TypeParam);
429
430 auto *SizeParam = NonTypeTemplateParmDecl::Create(
431 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 1,
432 &AST.Idents.get("element_count", tok::TokenKind::identifier), AST.IntTy,
433 false, AST.getTrivialTypeSourceInfo(AST.IntTy));
434 Expr *LiteralExpr =
435 IntegerLiteral::Create(AST, llvm::APInt(AST.getIntWidth(AST.IntTy), 4),
436 AST.IntTy, SourceLocation());
437 SizeParam->setDefaultArgument(LiteralExpr);
438 TemplateParams.emplace_back(SizeParam);
439
440 auto *ParamList =
442 TemplateParams, SourceLocation(), nullptr);
443
444 IdentifierInfo &II = AST.Idents.get("vector", tok::TokenKind::identifier);
445
447 AST.getTemplateTypeParmType(0, 0, false, TypeParam),
449 AST, NestedNameSpecifierLoc(), SourceLocation(), SizeParam, false,
450 DeclarationNameInfo(SizeParam->getDeclName(), SourceLocation()),
451 AST.IntTy, VK_LValue),
453
454 auto *Record = TypeAliasDecl::Create(AST, HLSLNamespace, SourceLocation(),
455 SourceLocation(), &II,
456 AST.getTrivialTypeSourceInfo(AliasType));
457 Record->setImplicit(true);
458
459 auto *Template =
460 TypeAliasTemplateDecl::Create(AST, HLSLNamespace, SourceLocation(),
461 Record->getIdentifier(), ParamList, Record);
462
463 Record->setDescribedAliasTemplate(Template);
464 Template->setImplicit(true);
465 Template->setLexicalDeclContext(Record->getDeclContext());
466 HLSLNamespace->addDecl(Template);
467}
468
469void HLSLExternalSemaSource::defineTrivialHLSLTypes() {
470 defineHLSLVectorAlias();
471
472 ResourceDecl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "Resource")
474 .addHandleMember(AccessSpecifier::AS_public)
475 .completeDefinition()
476 .Record;
477}
478
479/// Set up common members and attributes for buffer types
480static BuiltinTypeDeclBuilder setupBufferType(CXXRecordDecl *Decl, Sema &S,
481 ResourceClass RC, ResourceKind RK,
482 bool IsROV) {
483 return BuiltinTypeDeclBuilder(Decl)
484 .addHandleMember()
485 .addDefaultHandleConstructor(S, RC)
486 .annotateResourceClass(RC, RK, IsROV);
487}
488
489void HLSLExternalSemaSource::defineHLSLTypesWithForwardDeclarations() {
491 Decl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RWBuffer")
492 .addSimpleTemplateParams({"element_type"})
493 .Record;
494 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
495 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
496 ResourceKind::TypedBuffer, /*IsROV=*/false)
497 .addArraySubscriptOperators()
498 .completeDefinition();
499 });
500
501 Decl =
502 BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RasterizerOrderedBuffer")
503 .addSimpleTemplateParams({"element_type"})
504 .Record;
505 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
506 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
507 ResourceKind::TypedBuffer, /*IsROV=*/true)
508 .addArraySubscriptOperators()
509 .completeDefinition();
510 });
511}
512
513void HLSLExternalSemaSource::onCompletion(CXXRecordDecl *Record,
514 CompletionFunction Fn) {
515 Completions.insert(std::make_pair(Record->getCanonicalDecl(), Fn));
516}
517
519 if (!isa<CXXRecordDecl>(Tag))
520 return;
521 auto Record = cast<CXXRecordDecl>(Tag);
522
523 // If this is a specialization, we need to get the underlying templated
524 // declaration and complete that.
525 if (auto TDecl = dyn_cast<ClassTemplateSpecializationDecl>(Record))
526 Record = TDecl->getSpecializedTemplate()->getTemplatedDecl();
527 Record = Record->getCanonicalDecl();
528 auto It = Completions.find(Record);
529 if (It == Completions.end())
530 return;
531 It->second(Record);
532}
Defines the clang::ASTContext interface.
Defines the clang::attr::Kind enum.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
static BuiltinTypeDeclBuilder setupBufferType(CXXRecordDecl *Decl, Sema &S, ResourceClass RC, ResourceKind RK, bool IsROV)
Set up common members and attributes for buffer types.
Defines helper utilities for supporting the HLSL runtime environment.
llvm::MachO::Record Record
Definition: MachO.h:31
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1073
unsigned getIntWidth(QualType T) const
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:648
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
CanQualType FloatTy
Definition: ASTContext.h:1103
CanQualType VoidPtrTy
Definition: ASTContext.h:1118
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
IdentifierTable & Idents
Definition: ASTContext.h:644
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType IntTy
Definition: ASTContext.h:1100
CanQualType VoidTy
Definition: ASTContext.h:1091
CanQualType UnsignedCharTy
Definition: ASTContext.h:1101
CanQualType UnsignedIntTy
Definition: ASTContext.h:1101
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1567
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2664
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3840
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
Definition: Expr.cpp:4781
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2532
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2721
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2273
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:131
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:73
static CXXStaticCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written, FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc, SourceRange AngleBrackets)
Definition: ExprCXX.cpp:712
Represents the this expression in C++.
Definition: ExprCXX.h:1148
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
Definition: ExprCXX.cpp:1519
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
Definition: Expr.cpp:1494
Declaration of a class template.
static ClassTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a class template node.
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:383
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1698
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2638
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
Definition: DeclBase.h:2644
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1554
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1260
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
Definition: Expr.cpp:488
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
void setImplicit(bool I=true)
Definition: DeclBase.h:601
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:340
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
DeclarationName getCXXConstructorName(CanQualType Ty)
Returns the name of a C++ constructor for the given Type.
The name of a declaration.
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1896
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
Represents difference between two FPOptions values.
Definition: LangOptions.h:906
Represents a member of a struct/union/class.
Definition: Decl.h:3058
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:4547
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1507
void CompleteType(TagDecl *Tag) override
Complete an incomplete HLSL builtin type.
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
One of these records is kept for each identifier that is lexed.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:977
Represents the results of name lookup.
Definition: Lookup.h:46
static MemberExpr * CreateImplicit(const ASTContext &C, Expr *Base, bool IsArrow, ValueDecl *MemberDecl, QualType T, ExprValueKind VK, ExprObjectKind OK)
Create an implicit MemberExpr, with no location, qualifier, template arguments, and so on.
Definition: Expr.h:3233
This represents a decl that may have a name.
Definition: Decl.h:249
Represent a C++ namespace.
Definition: Decl.h:547
NamespaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this namespace.
Definition: Decl.h:674
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Definition: DeclCXX.cpp:2980
A C++ nested-name-specifier augmented with source location information.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2915
A (possibly-)qualified type.
Definition: Type.h:738
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:949
QualType getCanonicalType() const
Definition: Type.h:7201
void addConst()
Definition: Type.h:268
static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
Create a return statement.
Definition: Stmt.cpp:1204
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:457
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:698
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:7368
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition: Sema.h:7391
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:7371
ASTContext & getASTContext() const
Definition: Sema.h:527
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Encodes a location in the source.
A trivial tuple used to represent a source range.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3585
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3688
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:4739
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:413
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:144
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:5555
static TypeAliasTemplateDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, TemplateParameterList *Params, NamedDecl *Decl)
Create a function template node.
A container of type source information.
Definition: Type.h:7120
The base class of the type hierarchy.
Definition: Type.h:1607
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
Definition: Type.h:7870
Represents a C++ using-declaration.
Definition: DeclCXX.h:3509
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2935
QualType getType() const
Definition: Decl.h:717
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:1867
The JSON file list parser is used to communicate input to InstallAPI.
@ OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:148
@ SC_None
Definition: Specifiers.h:247
@ Result
The result type of a method or function.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:132
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:136
const FunctionProtoType * T
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:120
@ AS_public
Definition: Specifiers.h:121
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Extra information about a function prototype.
Definition: Type.h:4525