clang 20.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, llvm::ArrayRef<Attr *> Attrs,
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 for (Attr *A : Attrs) {
100 if (A)
101 Field->addAttr(A);
102 }
103
104 Record->addDecl(Field);
105 Fields[Name] = Field;
106 return *this;
107 }
108
109 BuiltinTypeDeclBuilder &
110 addHandleMember(ResourceClass RC, ResourceKind RK, bool IsROV,
111 AccessSpecifier Access = AccessSpecifier::AS_private) {
112 if (Record->isCompleteDefinition())
113 return *this;
114 QualType Ty = Record->getASTContext().VoidPtrTy;
115 if (Template) {
116 if (const auto *TTD = dyn_cast<TemplateTypeParmDecl>(
117 Template->getTemplateParameters()->getParam(0)))
118 Ty = Record->getASTContext().getPointerType(
119 QualType(TTD->getTypeForDecl(), 0));
120 }
121 // add handle member
122 Attr *ResourceClassAttr =
123 HLSLResourceClassAttr::CreateImplicit(Record->getASTContext(), RC);
124 Attr *ResourceAttr =
125 HLSLResourceAttr::CreateImplicit(Record->getASTContext(), RK);
126 Attr *ROVAttr =
127 IsROV ? HLSLROVAttr::CreateImplicit(Record->getASTContext()) : nullptr;
128 addMemberVariable("h", Ty, {ResourceClassAttr, ResourceAttr, ROVAttr},
129 Access);
130
131 return *this;
132 }
133
134 static DeclRefExpr *lookupBuiltinFunction(ASTContext &AST, Sema &S,
135 StringRef Name) {
136 IdentifierInfo &II = AST.Idents.get(Name, tok::TokenKind::identifier);
137 DeclarationNameInfo NameInfo =
140 // AllowBuiltinCreation is false but LookupDirect will create
141 // the builtin when searching the global scope anyways...
142 S.LookupName(R, S.getCurScope());
143 // FIXME: If the builtin function was user-declared in global scope,
144 // this assert *will* fail. Should this call LookupBuiltin instead?
145 assert(R.isSingleResult() &&
146 "Since this is a builtin it should always resolve!");
147 auto *VD = cast<ValueDecl>(R.getFoundDecl());
148 QualType Ty = VD->getType();
150 VD, false, NameInfo, Ty, VK_PRValue);
151 }
152
153 static Expr *emitResourceClassExpr(ASTContext &AST, ResourceClass RC) {
155 AST,
156 llvm::APInt(AST.getIntWidth(AST.UnsignedCharTy),
157 static_cast<uint8_t>(RC)),
159 }
160
161 BuiltinTypeDeclBuilder &addDefaultHandleConstructor(Sema &S,
162 ResourceClass RC) {
163 if (Record->isCompleteDefinition())
164 return *this;
165 ASTContext &AST = Record->getASTContext();
166
167 QualType ConstructorType =
169
170 CanQualType CanTy = Record->getTypeForDecl()->getCanonicalTypeUnqualified();
173 AST, Record, SourceLocation(),
174 DeclarationNameInfo(Name, SourceLocation()), ConstructorType,
175 AST.getTrivialTypeSourceInfo(ConstructorType, SourceLocation()),
176 ExplicitSpecifier(), false, true, false,
177 ConstexprSpecKind::Unspecified);
178
179 DeclRefExpr *Fn =
180 lookupBuiltinFunction(AST, S, "__builtin_hlsl_create_handle");
181 Expr *RCExpr = emitResourceClassExpr(AST, RC);
182 Expr *Call = CallExpr::Create(AST, Fn, {RCExpr}, AST.VoidPtrTy, VK_PRValue,
184
186 AST, SourceLocation(), Constructor->getFunctionObjectParameterType(),
187 true);
188 Expr *Handle = MemberExpr::CreateImplicit(AST, This, false, Fields["h"],
189 Fields["h"]->getType(), VK_LValue,
191
192 // If the handle isn't a void pointer, cast the builtin result to the
193 // correct type.
194 if (Handle->getType().getCanonicalType() != AST.VoidPtrTy) {
196 AST, Handle->getType(), VK_PRValue, CK_Dependent, Call, nullptr,
199 SourceRange());
200 }
201
203 AST, Handle, Call, BO_Assign, Handle->getType(), VK_LValue, OK_Ordinary,
205
206 Constructor->setBody(
209 Constructor->setAccess(AccessSpecifier::AS_public);
210 Record->addDecl(Constructor);
211 return *this;
212 }
213
214 BuiltinTypeDeclBuilder &addArraySubscriptOperators() {
215 if (Record->isCompleteDefinition())
216 return *this;
217 addArraySubscriptOperator(true);
218 addArraySubscriptOperator(false);
219 return *this;
220 }
221
222 BuiltinTypeDeclBuilder &addArraySubscriptOperator(bool IsConst) {
223 if (Record->isCompleteDefinition())
224 return *this;
225 assert(Fields.count("h") > 0 &&
226 "Subscript operator must be added after the handle.");
227
228 FieldDecl *Handle = Fields["h"];
229 ASTContext &AST = Record->getASTContext();
230
231 assert(Handle->getType().getCanonicalType() != AST.VoidPtrTy &&
232 "Not yet supported for void pointer handles.");
233
234 QualType ElemTy =
236 QualType ReturnTy = ElemTy;
237
239
240 // Subscript operators return references to elements, const makes the
241 // reference and method const so that the underlying data is not mutable.
242 ReturnTy = AST.getLValueReferenceType(ReturnTy);
243 if (IsConst) {
244 ExtInfo.TypeQuals.addConst();
245 ReturnTy.addConst();
246 }
247
248 QualType MethodTy =
249 AST.getFunctionType(ReturnTy, {AST.UnsignedIntTy}, ExtInfo);
250 auto *TSInfo = AST.getTrivialTypeSourceInfo(MethodTy, SourceLocation());
251 auto *MethodDecl = CXXMethodDecl::Create(
252 AST, Record, SourceLocation(),
254 AST.DeclarationNames.getCXXOperatorName(OO_Subscript),
256 MethodTy, TSInfo, SC_None, false, false, ConstexprSpecKind::Unspecified,
258
259 IdentifierInfo &II = AST.Idents.get("Idx", tok::TokenKind::identifier);
260 auto *IdxParam = ParmVarDecl::Create(
261 AST, MethodDecl->getDeclContext(), SourceLocation(), SourceLocation(),
262 &II, AST.UnsignedIntTy,
264 SC_None, nullptr);
265 MethodDecl->setParams({IdxParam});
266
267 // Also add the parameter to the function prototype.
268 auto FnProtoLoc = TSInfo->getTypeLoc().getAs<FunctionProtoTypeLoc>();
269 FnProtoLoc.setParam(0, IdxParam);
270
271 auto *This =
273 MethodDecl->getFunctionObjectParameterType(), true);
274 auto *HandleAccess = MemberExpr::CreateImplicit(
275 AST, This, false, Handle, Handle->getType(), VK_LValue, OK_Ordinary);
276
277 auto *IndexExpr = DeclRefExpr::Create(
278 AST, NestedNameSpecifierLoc(), SourceLocation(), IdxParam, false,
279 DeclarationNameInfo(IdxParam->getDeclName(), SourceLocation()),
281
282 auto *Array =
283 new (AST) ArraySubscriptExpr(HandleAccess, IndexExpr, ElemTy, VK_LValue,
285
286 auto *Return = ReturnStmt::Create(AST, SourceLocation(), Array, nullptr);
287
288 MethodDecl->setBody(CompoundStmt::Create(AST, {Return}, FPOptionsOverride(),
290 SourceLocation()));
291 MethodDecl->setLexicalDeclContext(Record);
292 MethodDecl->setAccess(AccessSpecifier::AS_public);
293 MethodDecl->addAttr(AlwaysInlineAttr::CreateImplicit(
294 AST, SourceRange(), AlwaysInlineAttr::CXX11_clang_always_inline));
295 Record->addDecl(MethodDecl);
296
297 return *this;
298 }
299
300 BuiltinTypeDeclBuilder &startDefinition() {
301 if (Record->isCompleteDefinition())
302 return *this;
303 Record->startDefinition();
304 return *this;
305 }
306
307 BuiltinTypeDeclBuilder &completeDefinition() {
308 if (Record->isCompleteDefinition())
309 return *this;
310 assert(Record->isBeingDefined() &&
311 "Definition must be started before completing it.");
312
313 Record->completeDefinition();
314 return *this;
315 }
316
317 TemplateParameterListBuilder addTemplateArgumentList(Sema &S);
318 BuiltinTypeDeclBuilder &addSimpleTemplateParams(Sema &S,
319 ArrayRef<StringRef> Names);
320};
321
322struct TemplateParameterListBuilder {
323 BuiltinTypeDeclBuilder &Builder;
324 Sema &S;
326
327 TemplateParameterListBuilder(Sema &S, BuiltinTypeDeclBuilder &RB)
328 : Builder(RB), S(S) {}
329
330 ~TemplateParameterListBuilder() { finalizeTemplateArgs(); }
331
332 TemplateParameterListBuilder &
333 addTypeParameter(StringRef Name, QualType DefaultValue = QualType()) {
334 if (Builder.Record->isCompleteDefinition())
335 return *this;
336 unsigned Position = static_cast<unsigned>(Params.size());
338 S.Context, Builder.Record->getDeclContext(), SourceLocation(),
339 SourceLocation(), /* TemplateDepth */ 0, Position,
340 &S.Context.Idents.get(Name, tok::TokenKind::identifier),
341 /* Typename */ false,
342 /* ParameterPack */ false);
343 if (!DefaultValue.isNull())
344 Decl->setDefaultArgument(
346 SourceLocation()));
347
348 Params.emplace_back(Decl);
349 return *this;
350 }
351
352 BuiltinTypeDeclBuilder &finalizeTemplateArgs() {
353 if (Params.empty())
354 return Builder;
355 auto *ParamList = TemplateParameterList::Create(S.Context, SourceLocation(),
356 SourceLocation(), Params,
357 SourceLocation(), nullptr);
358 Builder.Template = ClassTemplateDecl::Create(
359 S.Context, Builder.Record->getDeclContext(), SourceLocation(),
360 DeclarationName(Builder.Record->getIdentifier()), ParamList,
361 Builder.Record);
362 Builder.Record->setDescribedClassTemplate(Builder.Template);
363 Builder.Template->setImplicit(true);
364 Builder.Template->setLexicalDeclContext(Builder.Record->getDeclContext());
365 // NOTE: setPreviousDecl before addDecl so new decl replace old decl when
366 // make visible.
367 Builder.Template->setPreviousDecl(Builder.PrevTemplate);
368 Builder.Record->getDeclContext()->addDecl(Builder.Template);
369 Params.clear();
370
371 QualType T = Builder.Template->getInjectedClassNameSpecialization();
372 T = S.Context.getInjectedClassNameType(Builder.Record, T);
373
374 return Builder;
375 }
376};
377} // namespace
378
379TemplateParameterListBuilder
380BuiltinTypeDeclBuilder::addTemplateArgumentList(Sema &S) {
381 return TemplateParameterListBuilder(S, *this);
382}
383
384BuiltinTypeDeclBuilder &
385BuiltinTypeDeclBuilder::addSimpleTemplateParams(Sema &S,
386 ArrayRef<StringRef> Names) {
387 TemplateParameterListBuilder Builder = this->addTemplateArgumentList(S);
388 for (StringRef Name : Names)
389 Builder.addTypeParameter(Name);
390 return Builder.finalizeTemplateArgs();
391}
392
394
396 SemaPtr = &S;
397 ASTContext &AST = SemaPtr->getASTContext();
398 // If the translation unit has external storage force external decls to load.
400 (void)AST.getTranslationUnitDecl()->decls_begin();
401
402 IdentifierInfo &HLSL = AST.Idents.get("hlsl", tok::TokenKind::identifier);
404 NamespaceDecl *PrevDecl = nullptr;
406 PrevDecl = Result.getAsSingle<NamespaceDecl>();
407 HLSLNamespace = NamespaceDecl::Create(
408 AST, AST.getTranslationUnitDecl(), /*Inline=*/false, SourceLocation(),
409 SourceLocation(), &HLSL, PrevDecl, /*Nested=*/false);
410 HLSLNamespace->setImplicit(true);
411 HLSLNamespace->setHasExternalLexicalStorage();
412 AST.getTranslationUnitDecl()->addDecl(HLSLNamespace);
413
414 // Force external decls in the HLSL namespace to load from the PCH.
415 (void)HLSLNamespace->getCanonicalDecl()->decls_begin();
416 defineTrivialHLSLTypes();
417 defineHLSLTypesWithForwardDeclarations();
418
419 // This adds a `using namespace hlsl` directive. In DXC, we don't put HLSL's
420 // built in types inside a namespace, but we are planning to change that in
421 // the near future. In order to be source compatible older versions of HLSL
422 // will need to implicitly use the hlsl namespace. For now in clang everything
423 // will get added to the namespace, and we can remove the using directive for
424 // future language versions to match HLSL's evolution.
427 NestedNameSpecifierLoc(), SourceLocation(), HLSLNamespace,
429
431}
432
433void HLSLExternalSemaSource::defineHLSLVectorAlias() {
434 ASTContext &AST = SemaPtr->getASTContext();
435
436 llvm::SmallVector<NamedDecl *> TemplateParams;
437
438 auto *TypeParam = TemplateTypeParmDecl::Create(
439 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 0,
440 &AST.Idents.get("element", tok::TokenKind::identifier), false, false);
441 TypeParam->setDefaultArgument(
442 AST, SemaPtr->getTrivialTemplateArgumentLoc(
444
445 TemplateParams.emplace_back(TypeParam);
446
447 auto *SizeParam = NonTypeTemplateParmDecl::Create(
448 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 1,
449 &AST.Idents.get("element_count", tok::TokenKind::identifier), AST.IntTy,
450 false, AST.getTrivialTypeSourceInfo(AST.IntTy));
451 llvm::APInt Val(AST.getIntWidth(AST.IntTy), 4);
452 TemplateArgument Default(AST, llvm::APSInt(std::move(Val)), AST.IntTy,
453 /*IsDefaulted=*/true);
454 SizeParam->setDefaultArgument(
456 SourceLocation(), SizeParam));
457 TemplateParams.emplace_back(SizeParam);
458
459 auto *ParamList =
461 TemplateParams, SourceLocation(), nullptr);
462
463 IdentifierInfo &II = AST.Idents.get("vector", tok::TokenKind::identifier);
464
466 AST.getTemplateTypeParmType(0, 0, false, TypeParam),
468 AST, NestedNameSpecifierLoc(), SourceLocation(), SizeParam, false,
469 DeclarationNameInfo(SizeParam->getDeclName(), SourceLocation()),
470 AST.IntTy, VK_LValue),
472
473 auto *Record = TypeAliasDecl::Create(AST, HLSLNamespace, SourceLocation(),
474 SourceLocation(), &II,
475 AST.getTrivialTypeSourceInfo(AliasType));
476 Record->setImplicit(true);
477
478 auto *Template =
479 TypeAliasTemplateDecl::Create(AST, HLSLNamespace, SourceLocation(),
480 Record->getIdentifier(), ParamList, Record);
481
482 Record->setDescribedAliasTemplate(Template);
483 Template->setImplicit(true);
484 Template->setLexicalDeclContext(Record->getDeclContext());
485 HLSLNamespace->addDecl(Template);
486}
487
488void HLSLExternalSemaSource::defineTrivialHLSLTypes() {
489 defineHLSLVectorAlias();
490}
491
492/// Set up common members and attributes for buffer types
493static BuiltinTypeDeclBuilder setupBufferType(CXXRecordDecl *Decl, Sema &S,
494 ResourceClass RC, ResourceKind RK,
495 bool IsROV) {
496 return BuiltinTypeDeclBuilder(Decl)
497 .addHandleMember(RC, RK, IsROV)
498 .addDefaultHandleConstructor(S, RC);
499}
500
501void HLSLExternalSemaSource::defineHLSLTypesWithForwardDeclarations() {
503 Decl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RWBuffer")
504 .addSimpleTemplateParams(*SemaPtr, {"element_type"})
505 .Record;
506 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
507 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
508 ResourceKind::TypedBuffer, /*IsROV=*/false)
509 .addArraySubscriptOperators()
510 .completeDefinition();
511 });
512
513 Decl =
514 BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RasterizerOrderedBuffer")
515 .addSimpleTemplateParams(*SemaPtr, {"element_type"})
516 .Record;
517 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
518 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
519 ResourceKind::TypedBuffer, /*IsROV=*/true)
520 .addArraySubscriptOperators()
521 .completeDefinition();
522 });
523}
524
525void HLSLExternalSemaSource::onCompletion(CXXRecordDecl *Record,
526 CompletionFunction Fn) {
527 Completions.insert(std::make_pair(Record->getCanonicalDecl(), Fn));
528}
529
531 if (!isa<CXXRecordDecl>(Tag))
532 return;
533 auto Record = cast<CXXRecordDecl>(Tag);
534
535 // If this is a specialization, we need to get the underlying templated
536 // declaration and complete that.
537 if (auto TDecl = dyn_cast<ClassTemplateSpecializationDecl>(Record))
538 Record = TDecl->getSpecializedTemplate()->getTemplatedDecl();
539 Record = Record->getCanonicalDecl();
540 auto It = Completions.find(Record);
541 if (It == Completions.end())
542 return;
543 It->second(Record);
544}
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:187
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1101
unsigned getIntWidth(QualType T) const
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:664
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:1131
CanQualType VoidPtrTy
Definition: ASTContext.h:1146
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:660
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:1128
CanQualType VoidTy
Definition: ASTContext.h:1119
CanQualType UnsignedCharTy
Definition: ASTContext.h:1129
CanQualType UnsignedIntTy
Definition: ASTContext.h:1129
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:1615
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2674
Attr - This represents one attribute.
Definition: Attr.h:42
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3860
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:4859
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2539
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:2761
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:2312
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:132
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:762
Represents the this expression in C++.
Definition: ExprCXX.h:1152
static CXXThisExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType Ty, bool IsImplicit)
Definition: ExprCXX.cpp:1569
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:1766
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2665
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
Definition: DeclBase.h:2671
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1622
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1265
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:86
void setImplicit(bool I=true)
Definition: DeclBase.h:601
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:362
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:1901
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
Represents difference between two FPOptions values.
Definition: LangOptions.h:947
Represents a member of a struct/union/class.
Definition: Decl.h:3030
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:4531
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:3248
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:639
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Definition: DeclCXX.cpp:3013
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:2903
A (possibly-)qualified type.
Definition: Type.h:941
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:1163
QualType getCanonicalType() const
Definition: Type.h:7807
void addConst()
Definition: Type.h:447
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:493
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc, NamedDecl *TemplateParam=nullptr)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location.
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:763
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:9015
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition: Sema.h:9038
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:9018
ASTContext & Context
Definition: Sema.h:962
ASTContext & getASTContext() const
Definition: Sema.h:560
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
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:3561
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3664
Represents a template argument.
Definition: TemplateBase.h:61
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:5553
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:7726
The base class of the type hierarchy.
Definition: Type.h:1829
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
Definition: Type.h:8502
Represents a C++ using-declaration.
Definition: DeclCXX.h:3516
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2975
QualType getType() const
Definition: Decl.h:678
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:2269
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:151
@ SC_None
Definition: Specifiers.h:250
@ 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:135
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:139
const FunctionProtoType * T
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:123
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Extra information about a function prototype.
Definition: Type.h:5092