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 &annotateHLSLResource(ResourceClass RC,
119 ResourceKind RK, bool IsROV) {
120 if (Record->isCompleteDefinition())
121 return *this;
122 Record->addAttr(
123 HLSLResourceClassAttr::CreateImplicit(Record->getASTContext(), RC));
124 Record->addAttr(
125 HLSLResourceAttr::CreateImplicit(Record->getASTContext(), RK, IsROV));
126 return *this;
127 }
128
129 static DeclRefExpr *lookupBuiltinFunction(ASTContext &AST, Sema &S,
130 StringRef Name) {
131 IdentifierInfo &II = AST.Idents.get(Name, tok::TokenKind::identifier);
132 DeclarationNameInfo NameInfo =
135 // AllowBuiltinCreation is false but LookupDirect will create
136 // the builtin when searching the global scope anyways...
137 S.LookupName(R, S.getCurScope());
138 // FIXME: If the builtin function was user-declared in global scope,
139 // this assert *will* fail. Should this call LookupBuiltin instead?
140 assert(R.isSingleResult() &&
141 "Since this is a builtin it should always resolve!");
142 auto *VD = cast<ValueDecl>(R.getFoundDecl());
143 QualType Ty = VD->getType();
145 VD, false, NameInfo, Ty, VK_PRValue);
146 }
147
148 static Expr *emitResourceClassExpr(ASTContext &AST, ResourceClass RC) {
150 AST,
151 llvm::APInt(AST.getIntWidth(AST.UnsignedCharTy),
152 static_cast<uint8_t>(RC)),
154 }
155
156 BuiltinTypeDeclBuilder &addDefaultHandleConstructor(Sema &S,
157 ResourceClass RC) {
158 if (Record->isCompleteDefinition())
159 return *this;
160 ASTContext &AST = Record->getASTContext();
161
162 QualType ConstructorType =
164
165 CanQualType CanTy = Record->getTypeForDecl()->getCanonicalTypeUnqualified();
168 AST, Record, SourceLocation(),
169 DeclarationNameInfo(Name, SourceLocation()), ConstructorType,
170 AST.getTrivialTypeSourceInfo(ConstructorType, SourceLocation()),
171 ExplicitSpecifier(), false, true, false,
172 ConstexprSpecKind::Unspecified);
173
174 DeclRefExpr *Fn =
175 lookupBuiltinFunction(AST, S, "__builtin_hlsl_create_handle");
176 Expr *RCExpr = emitResourceClassExpr(AST, RC);
177 Expr *Call = CallExpr::Create(AST, Fn, {RCExpr}, AST.VoidPtrTy, VK_PRValue,
179
181 AST, SourceLocation(), Constructor->getFunctionObjectParameterType(),
182 true);
183 Expr *Handle = MemberExpr::CreateImplicit(AST, This, false, Fields["h"],
184 Fields["h"]->getType(), VK_LValue,
186
187 // If the handle isn't a void pointer, cast the builtin result to the
188 // correct type.
189 if (Handle->getType().getCanonicalType() != AST.VoidPtrTy) {
191 AST, Handle->getType(), VK_PRValue, CK_Dependent, Call, nullptr,
194 SourceRange());
195 }
196
198 AST, Handle, Call, BO_Assign, Handle->getType(), VK_LValue, OK_Ordinary,
200
201 Constructor->setBody(
204 Constructor->setAccess(AccessSpecifier::AS_public);
205 Record->addDecl(Constructor);
206 return *this;
207 }
208
209 BuiltinTypeDeclBuilder &addArraySubscriptOperators() {
210 if (Record->isCompleteDefinition())
211 return *this;
212 addArraySubscriptOperator(true);
213 addArraySubscriptOperator(false);
214 return *this;
215 }
216
217 BuiltinTypeDeclBuilder &addArraySubscriptOperator(bool IsConst) {
218 if (Record->isCompleteDefinition())
219 return *this;
220 assert(Fields.count("h") > 0 &&
221 "Subscript operator must be added after the handle.");
222
223 FieldDecl *Handle = Fields["h"];
224 ASTContext &AST = Record->getASTContext();
225
226 assert(Handle->getType().getCanonicalType() != AST.VoidPtrTy &&
227 "Not yet supported for void pointer handles.");
228
229 QualType ElemTy =
231 QualType ReturnTy = ElemTy;
232
234
235 // Subscript operators return references to elements, const makes the
236 // reference and method const so that the underlying data is not mutable.
237 ReturnTy = AST.getLValueReferenceType(ReturnTy);
238 if (IsConst) {
239 ExtInfo.TypeQuals.addConst();
240 ReturnTy.addConst();
241 }
242
243 QualType MethodTy =
244 AST.getFunctionType(ReturnTy, {AST.UnsignedIntTy}, ExtInfo);
245 auto *TSInfo = AST.getTrivialTypeSourceInfo(MethodTy, SourceLocation());
246 auto *MethodDecl = CXXMethodDecl::Create(
247 AST, Record, SourceLocation(),
249 AST.DeclarationNames.getCXXOperatorName(OO_Subscript),
251 MethodTy, TSInfo, SC_None, false, false, ConstexprSpecKind::Unspecified,
253
254 IdentifierInfo &II = AST.Idents.get("Idx", tok::TokenKind::identifier);
255 auto *IdxParam = ParmVarDecl::Create(
256 AST, MethodDecl->getDeclContext(), SourceLocation(), SourceLocation(),
257 &II, AST.UnsignedIntTy,
259 SC_None, nullptr);
260 MethodDecl->setParams({IdxParam});
261
262 // Also add the parameter to the function prototype.
263 auto FnProtoLoc = TSInfo->getTypeLoc().getAs<FunctionProtoTypeLoc>();
264 FnProtoLoc.setParam(0, IdxParam);
265
266 auto *This =
268 MethodDecl->getFunctionObjectParameterType(), true);
269 auto *HandleAccess = MemberExpr::CreateImplicit(
270 AST, This, false, Handle, Handle->getType(), VK_LValue, OK_Ordinary);
271
272 auto *IndexExpr = DeclRefExpr::Create(
273 AST, NestedNameSpecifierLoc(), SourceLocation(), IdxParam, false,
274 DeclarationNameInfo(IdxParam->getDeclName(), SourceLocation()),
276
277 auto *Array =
278 new (AST) ArraySubscriptExpr(HandleAccess, IndexExpr, ElemTy, VK_LValue,
280
281 auto *Return = ReturnStmt::Create(AST, SourceLocation(), Array, nullptr);
282
283 MethodDecl->setBody(CompoundStmt::Create(AST, {Return}, FPOptionsOverride(),
285 SourceLocation()));
286 MethodDecl->setLexicalDeclContext(Record);
287 MethodDecl->setAccess(AccessSpecifier::AS_public);
288 MethodDecl->addAttr(AlwaysInlineAttr::CreateImplicit(
289 AST, SourceRange(), AlwaysInlineAttr::CXX11_clang_always_inline));
290 Record->addDecl(MethodDecl);
291
292 return *this;
293 }
294
295 BuiltinTypeDeclBuilder &startDefinition() {
296 if (Record->isCompleteDefinition())
297 return *this;
298 Record->startDefinition();
299 return *this;
300 }
301
302 BuiltinTypeDeclBuilder &completeDefinition() {
303 if (Record->isCompleteDefinition())
304 return *this;
305 assert(Record->isBeingDefined() &&
306 "Definition must be started before completing it.");
307
308 Record->completeDefinition();
309 return *this;
310 }
311
312 TemplateParameterListBuilder addTemplateArgumentList(Sema &S);
313 BuiltinTypeDeclBuilder &addSimpleTemplateParams(Sema &S,
314 ArrayRef<StringRef> Names);
315};
316
317struct TemplateParameterListBuilder {
318 BuiltinTypeDeclBuilder &Builder;
319 Sema &S;
321
322 TemplateParameterListBuilder(Sema &S, BuiltinTypeDeclBuilder &RB)
323 : Builder(RB), S(S) {}
324
325 ~TemplateParameterListBuilder() { finalizeTemplateArgs(); }
326
327 TemplateParameterListBuilder &
328 addTypeParameter(StringRef Name, QualType DefaultValue = QualType()) {
329 if (Builder.Record->isCompleteDefinition())
330 return *this;
331 unsigned Position = static_cast<unsigned>(Params.size());
333 S.Context, Builder.Record->getDeclContext(), SourceLocation(),
334 SourceLocation(), /* TemplateDepth */ 0, Position,
335 &S.Context.Idents.get(Name, tok::TokenKind::identifier),
336 /* Typename */ false,
337 /* ParameterPack */ false);
338 if (!DefaultValue.isNull())
339 Decl->setDefaultArgument(
341 SourceLocation()));
342
343 Params.emplace_back(Decl);
344 return *this;
345 }
346
347 BuiltinTypeDeclBuilder &finalizeTemplateArgs() {
348 if (Params.empty())
349 return Builder;
350 auto *ParamList = TemplateParameterList::Create(S.Context, SourceLocation(),
351 SourceLocation(), Params,
352 SourceLocation(), nullptr);
353 Builder.Template = ClassTemplateDecl::Create(
354 S.Context, Builder.Record->getDeclContext(), SourceLocation(),
355 DeclarationName(Builder.Record->getIdentifier()), ParamList,
356 Builder.Record);
357 Builder.Record->setDescribedClassTemplate(Builder.Template);
358 Builder.Template->setImplicit(true);
359 Builder.Template->setLexicalDeclContext(Builder.Record->getDeclContext());
360 // NOTE: setPreviousDecl before addDecl so new decl replace old decl when
361 // make visible.
362 Builder.Template->setPreviousDecl(Builder.PrevTemplate);
363 Builder.Record->getDeclContext()->addDecl(Builder.Template);
364 Params.clear();
365
366 QualType T = Builder.Template->getInjectedClassNameSpecialization();
367 T = S.Context.getInjectedClassNameType(Builder.Record, T);
368
369 return Builder;
370 }
371};
372} // namespace
373
374TemplateParameterListBuilder
375BuiltinTypeDeclBuilder::addTemplateArgumentList(Sema &S) {
376 return TemplateParameterListBuilder(S, *this);
377}
378
379BuiltinTypeDeclBuilder &
380BuiltinTypeDeclBuilder::addSimpleTemplateParams(Sema &S,
381 ArrayRef<StringRef> Names) {
382 TemplateParameterListBuilder Builder = this->addTemplateArgumentList(S);
383 for (StringRef Name : Names)
384 Builder.addTypeParameter(Name);
385 return Builder.finalizeTemplateArgs();
386}
387
389
391 SemaPtr = &S;
392 ASTContext &AST = SemaPtr->getASTContext();
393 // If the translation unit has external storage force external decls to load.
395 (void)AST.getTranslationUnitDecl()->decls_begin();
396
397 IdentifierInfo &HLSL = AST.Idents.get("hlsl", tok::TokenKind::identifier);
399 NamespaceDecl *PrevDecl = nullptr;
401 PrevDecl = Result.getAsSingle<NamespaceDecl>();
402 HLSLNamespace = NamespaceDecl::Create(
403 AST, AST.getTranslationUnitDecl(), /*Inline=*/false, SourceLocation(),
404 SourceLocation(), &HLSL, PrevDecl, /*Nested=*/false);
405 HLSLNamespace->setImplicit(true);
406 HLSLNamespace->setHasExternalLexicalStorage();
407 AST.getTranslationUnitDecl()->addDecl(HLSLNamespace);
408
409 // Force external decls in the HLSL namespace to load from the PCH.
410 (void)HLSLNamespace->getCanonicalDecl()->decls_begin();
411 defineTrivialHLSLTypes();
412 defineHLSLTypesWithForwardDeclarations();
413
414 // This adds a `using namespace hlsl` directive. In DXC, we don't put HLSL's
415 // built in types inside a namespace, but we are planning to change that in
416 // the near future. In order to be source compatible older versions of HLSL
417 // will need to implicitly use the hlsl namespace. For now in clang everything
418 // will get added to the namespace, and we can remove the using directive for
419 // future language versions to match HLSL's evolution.
422 NestedNameSpecifierLoc(), SourceLocation(), HLSLNamespace,
424
426}
427
428void HLSLExternalSemaSource::defineHLSLVectorAlias() {
429 ASTContext &AST = SemaPtr->getASTContext();
430
431 llvm::SmallVector<NamedDecl *> TemplateParams;
432
433 auto *TypeParam = TemplateTypeParmDecl::Create(
434 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 0,
435 &AST.Idents.get("element", tok::TokenKind::identifier), false, false);
436 TypeParam->setDefaultArgument(
437 AST, SemaPtr->getTrivialTemplateArgumentLoc(
439
440 TemplateParams.emplace_back(TypeParam);
441
442 auto *SizeParam = NonTypeTemplateParmDecl::Create(
443 AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 1,
444 &AST.Idents.get("element_count", tok::TokenKind::identifier), AST.IntTy,
445 false, AST.getTrivialTypeSourceInfo(AST.IntTy));
446 llvm::APInt Val(AST.getIntWidth(AST.IntTy), 4);
447 TemplateArgument Default(AST, llvm::APSInt(std::move(Val)), AST.IntTy,
448 /*IsDefaulted=*/true);
449 SizeParam->setDefaultArgument(
451 SourceLocation(), SizeParam));
452 TemplateParams.emplace_back(SizeParam);
453
454 auto *ParamList =
456 TemplateParams, SourceLocation(), nullptr);
457
458 IdentifierInfo &II = AST.Idents.get("vector", tok::TokenKind::identifier);
459
461 AST.getTemplateTypeParmType(0, 0, false, TypeParam),
463 AST, NestedNameSpecifierLoc(), SourceLocation(), SizeParam, false,
464 DeclarationNameInfo(SizeParam->getDeclName(), SourceLocation()),
465 AST.IntTy, VK_LValue),
467
468 auto *Record = TypeAliasDecl::Create(AST, HLSLNamespace, SourceLocation(),
469 SourceLocation(), &II,
470 AST.getTrivialTypeSourceInfo(AliasType));
471 Record->setImplicit(true);
472
473 auto *Template =
474 TypeAliasTemplateDecl::Create(AST, HLSLNamespace, SourceLocation(),
475 Record->getIdentifier(), ParamList, Record);
476
477 Record->setDescribedAliasTemplate(Template);
478 Template->setImplicit(true);
479 Template->setLexicalDeclContext(Record->getDeclContext());
480 HLSLNamespace->addDecl(Template);
481}
482
483void HLSLExternalSemaSource::defineTrivialHLSLTypes() {
484 defineHLSLVectorAlias();
485}
486
487/// Set up common members and attributes for buffer types
488static BuiltinTypeDeclBuilder setupBufferType(CXXRecordDecl *Decl, Sema &S,
489 ResourceClass RC, ResourceKind RK,
490 bool IsROV) {
491 return BuiltinTypeDeclBuilder(Decl)
492 .addHandleMember()
493 .addDefaultHandleConstructor(S, RC)
494 .annotateHLSLResource(RC, RK, IsROV);
495}
496
497void HLSLExternalSemaSource::defineHLSLTypesWithForwardDeclarations() {
499 Decl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RWBuffer")
500 .addSimpleTemplateParams(*SemaPtr, {"element_type"})
501 .Record;
502 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
503 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
504 ResourceKind::TypedBuffer, /*IsROV=*/false)
505 .addArraySubscriptOperators()
506 .completeDefinition();
507 });
508
509 Decl =
510 BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RasterizerOrderedBuffer")
511 .addSimpleTemplateParams(*SemaPtr, {"element_type"})
512 .Record;
513 onCompletion(Decl, [this](CXXRecordDecl *Decl) {
514 setupBufferType(Decl, *SemaPtr, ResourceClass::UAV,
515 ResourceKind::TypedBuffer, /*IsROV=*/true)
516 .addArraySubscriptOperators()
517 .completeDefinition();
518 });
519}
520
521void HLSLExternalSemaSource::onCompletion(CXXRecordDecl *Record,
522 CompletionFunction Fn) {
523 Completions.insert(std::make_pair(Record->getCanonicalDecl(), Fn));
524}
525
527 if (!isa<CXXRecordDecl>(Tag))
528 return;
529 auto Record = cast<CXXRecordDecl>(Tag);
530
531 // If this is a specialization, we need to get the underlying templated
532 // declaration and complete that.
533 if (auto TDecl = dyn_cast<ClassTemplateSpecializationDecl>(Record))
534 Record = TDecl->getSpecializedTemplate()->getTemplatedDecl();
535 Record = Record->getCanonicalDecl();
536 auto It = Completions.find(Record);
537 if (It == Completions.end())
538 return;
539 It->second(Record);
540}
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:186
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1094
unsigned getIntWidth(QualType T) const
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:663
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:1124
CanQualType VoidPtrTy
Definition: ASTContext.h:1139
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:659
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:1121
CanQualType VoidTy
Definition: ASTContext.h:1112
CanQualType UnsignedCharTy
Definition: ASTContext.h:1122
CanQualType UnsignedIntTy
Definition: ASTContext.h:1122
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:1606
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2674
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:4804
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2535
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:2722
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: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:759
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:1566
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:1742
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2654
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
Definition: DeclBase.h:2660
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1598
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:600
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:1897
This represents one expression.
Definition: Expr.h:110
QualType getType() const
Definition: Expr.h:142
Represents difference between two FPOptions values.
Definition: LangOptions.h:919
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:4533
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:2974
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:7795
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:535
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:803
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:8997
@ LookupNamespaceName
Look up a namespace name within a C++ using directive or namespace alias definition,...
Definition: Sema.h:9020
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
Definition: Sema.h:9000
ASTContext & Context
Definition: Sema.h:1002
ASTContext & getASTContext() const
Definition: Sema.h:600
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:3557
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3660
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:5542
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:7714
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:8473
Represents a C++ using-declaration.
Definition: DeclCXX.h:3512
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2936
QualType getType() const
Definition: Decl.h:678
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:2216
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
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Extra information about a function prototype.
Definition: Type.h:5058