13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
47#include "llvm/ADT/ArrayRef.h"
48#include "llvm/Support/ErrorHandling.h"
52using namespace llvm::omp;
108template<
typename Derived>
113 class ForgetPartiallySubstitutedPackRAII {
121 ForgetPartiallySubstitutedPackRAII(Derived &Self)
122 : Self(Self), ResetPackSubstIndex(Self.getSema(), -1) {
123 Old = Self.ForgetPartiallySubstitutedPack();
126 ~ForgetPartiallySubstitutedPackRAII() {
127 Self.RememberPartiallySubstitutedPack(Old);
144 Derived &
getDerived() {
return static_cast<Derived&
>(*this); }
148 return static_cast<const Derived&
>(*this);
213 OldLocation = Self.getDerived().getBaseLocation();
214 OldEntity = Self.getDerived().getBaseEntity();
217 Self.getDerived().setBase(Location, Entity);
221 Self.getDerived().setBase(OldLocation, OldEntity);
251 return E->isDefaultArgument();
294 bool &ShouldExpand,
bool &RetainExpansion,
295 std::optional<unsigned> &NumExpansions) {
296 ShouldExpand =
false;
411 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
412#include "clang/Basic/AttrList.inc"
422 const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \
423 const X##Attr *A) { \
424 return getDerived().Transform##X##Attr(A); \
426#include "clang/Basic/AttrList.inc"
472 bool *ArgChanged =
nullptr);
481 llvm::DenseMap<Decl *, Decl *>::iterator Known
484 return Known->second;
512 assert(New.size() == 1 &&
513 "must override transformedLocalDecl if performing pack expansion");
551 NamedDecl *FirstQualifierInScope =
nullptr);
596 NamedDecl *FirstQualifierInScope =
nullptr,
597 bool AllowInjectedClassName =
false);
609 bool Uneval =
false);
632 bool Uneval =
false) {
651 template<
typename InputIterator>
655 bool Uneval =
false);
667#define ABSTRACT_TYPELOC(CLASS, PARENT)
668#define TYPELOC(CLASS, PARENT) \
669 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
670#include "clang/AST/TypeLocNodes.def"
674 bool SuppressObjCLifetime);
678 bool SuppressObjCLifetime);
680 template<
typename Fn>
733 return getDerived().TransformFunctionTypeParams(
734 Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos,
nullptr);
752 KWLoc, Params,
nullptr,
753 nullptr, PTypes, &TransParams, PInfos))
766 std::optional<unsigned> NumExpansions,
767 bool ExpectParameterPack);
794 bool IsAddressOfOperand,
802 bool IsAddressOfOperand);
810#define STMT(Node, Parent) \
811 LLVM_ATTRIBUTE_NOINLINE \
812 StmtResult Transform##Node(Node *S);
813#define VALUESTMT(Node, Parent) \
814 LLVM_ATTRIBUTE_NOINLINE \
815 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
816#define EXPR(Node, Parent) \
817 LLVM_ATTRIBUTE_NOINLINE \
818 ExprResult Transform##Node(Node *E);
819#define ABSTRACT_STMT(Stmt)
820#include "clang/AST/StmtNodes.inc"
822#define GEN_CLANG_CLAUSE_CLASS
823#define CLAUSE_CLASS(Enum, Str, Class) \
824 LLVM_ATTRIBUTE_NOINLINE \
825 OMPClause *Transform##Class(Class *S);
826#include "llvm/Frontend/OpenMP/OMP.inc"
903 const llvm::APInt *Size,
Expr *SizeExpr,
904 unsigned IndexTypeQuals,
SourceRange BracketsRange);
913 const llvm::APInt &Size,
Expr *SizeExpr,
914 unsigned IndexTypeQuals,
924 unsigned IndexTypeQuals,
934 unsigned IndexTypeQuals,
945 unsigned IndexTypeQuals,
983 unsigned NumColumns);
1000 Expr *AddrSpaceExpr,
1070 bool FullySubstituted,
1084 TypeConstraintConcept,
1085 TypeConstraintArgs);
1093 Template, Deduced,
false);
1139 bool AllowInjectedClassName) {
1143 SS.
Adopt(QualifierLoc);
1145 SS, TemplateKWLoc, *Name, NameLoc,
QualType(),
nullptr,
1146 AllowInjectedClassName);
1160 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
1177 bool DeducedTSTContext) {
1179 SS.
Adopt(QualifierLoc);
1192 *
Id, IdLoc, DeducedTSTContext);
1210 switch (
Result.getResultKind()) {
1221 llvm_unreachable(
"Tag lookup cannot find non-tags");
1233 switch (
Result.getResultKind()) {
1239 SemaRef.
Diag(IdLoc, diag::err_tag_reference_non_tag)
1240 << SomeDecl << NTK << llvm::to_underlying(Kind);
1246 << llvm::to_underlying(Kind) <<
Id << DC
1255 SemaRef.
Diag(KeywordLoc, diag::err_use_with_wrong_tag) <<
Id;
1256 SemaRef.
Diag(Tag->getLocation(), diag::note_previous_use);
1273 std::optional<unsigned> NumExpansions) {
1318 bool AllowInjectedClassName);
1331 bool AllowInjectedClassName);
1341 Decl *AssociatedDecl,
unsigned Index,
1344 ArgPack, AssociatedDecl, Index, Final);
1422 Then, ElseLoc, Else);
1476 Inc, RParenLoc, Body);
1521 bool IsVolatile,
unsigned NumOutputs,
1528 NumInputs, Names, Constraints, Exprs,
1529 AsmString, Clobbers, NumLabels, RParenLoc);
1538 StringRef AsmString,
1539 unsigned NumOutputs,
unsigned NumInputs,
1545 NumOutputs, NumInputs,
1546 Constraints, Clobbers, Exprs, EndLoc);
1575 CoawaitLoc, Operand, OpCoawaitLookup);
1579 Suspend.
get(),
true);
1680 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1692 Kind, DirName, Clauses, AStmt, StartLoc, EndLoc);
1706 NameModifier,
Condition, StartLoc, LParenLoc, NameModifierLoc, ColonLoc,
1817 Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
1830 Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
1843 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1894 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1921 VarList, Modifier, StartLoc, LParenLoc, ModifierLoc, ColonLoc, EndLoc,
1922 ReductionIdScopeSpec, ReductionId, UnresolvedReductions);
1936 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1937 ReductionId, UnresolvedReductions);
1952 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1953 ReductionId, UnresolvedReductions);
1966 VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc,
1967 StepModifierLoc, EndLoc);
1980 VarList, Alignment, StartLoc, LParenLoc, ColonLoc, EndLoc);
2040 Data, DepModifier, VarList, StartLoc, LParenLoc, EndLoc);
2053 Modifier,
Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2068 IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
2069 MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
2070 ColonLoc, VarList, Locs,
2071 false, UnresolvedMappers);
2086 Allocate, ACModifier, VarList, StartLoc, LParenLoc, ColonLoc, EndLoc);
2134 Modifier,
Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2147 Modifier, NumTasks, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2182 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2197 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2198 ColonLoc, VarList, Locs, UnresolvedMappers);
2213 MotionModifiers, MotionModifiersLoc, MapperIdScopeSpec, MapperId,
2214 ColonLoc, VarList, Locs, UnresolvedMappers);
2265 M, Kind, StartLoc, LParenLoc, MLoc, KindLoc, EndLoc);
2312 StartLoc, LParenLoc, EndLoc,
Data);
2325 StartLoc, LParenLoc, ColonLoc, EndLoc, Modifier, Locators);
2337 Modifier, Kind, StartLoc, LParenLoc, ModifierKwLoc, KindKwLoc, EndLoc);
2350 InteropVar, InteropInfo, StartLoc, LParenLoc, VarLoc, EndLoc);
2361 LParenLoc, VarLoc, EndLoc);
2373 InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc);
2512 DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);
2560 ForLoc, Element, Collection, RParenLoc);
2578 StartLoc, IdLoc,
Id);
2616 if (RangeStmt->isSingleDecl()) {
2617 if (
VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2618 if (RangeVar->isInvalidDecl())
2621 Expr *RangeExpr = RangeVar->getInit();
2628 diag::err_objc_for_range_init_stmt)
2629 <<
Init->getSourceRange();
2632 ForLoc, LoopVar, RangeExpr, RParenLoc);
2639 ForLoc, CoawaitLoc,
Init, ColonLoc,
Range,
Begin, End, Cond, Inc,
2653 QualifierLoc, NameInfo, Nested);
2715 SS.
Adopt(QualifierLoc);
2827 if (IsOMPArraySection)
2829 Base, LBracketLoc, LowerBound, ColonLocFirst, ColonLocSecond, Length,
2830 Stride, RBracketLoc);
2832 assert(Stride ==
nullptr && !ColonLocSecond.
isValid() &&
2833 "Stride/second colon not allowed for OpenACC");
2836 Base, LBracketLoc, LowerBound, ColonLocFirst, Length, RBracketLoc);
2848 Base, LParenLoc, RParenLoc, Dims, BracketsRanges);
2860 nullptr, IteratorKwLoc, LLoc, RLoc,
Data);
2870 Expr *ExecConfig =
nullptr) {
2872 nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2879 nullptr, Callee, LParenLoc, Args, RParenLoc);
2897 if (!
Member->getDeclName()) {
2901 assert(
Member->getType()->isRecordType() &&
2902 "unnamed member not of record type?");
2915 if (!isArrow &&
Base->isPRValue()) {
2924 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(
Member),
2930 SS.
Adopt(QualifierLoc);
2933 if (
Base->containsErrors())
2947 if (
getSema().isUnevaluatedContext() &&
Base->isImplicitCXXThis() &&
2948 isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(
Member)) {
2949 if (
auto *ThisClass = cast<CXXThisExpr>(
Base)
2952 ->getAsCXXRecordDecl()) {
2953 auto *
Class = cast<CXXRecordDecl>(
Member->getDeclContext());
2956 if (!ThisClass->Equals(
Class) && !ThisClass->isDerivedFrom(
Class))
2964 FirstQualifierInScope,
2965 R, ExplicitTemplateArgs,
3143 Expr *ControllingExpr,
3148 ControllingExpr, Types, Exprs);
3163 ControllingType, Types, Exprs);
3196 case Stmt::CXXStaticCastExprClass:
3197 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
3198 RAngleLoc, LParenLoc,
3199 SubExpr, RParenLoc);
3201 case Stmt::CXXDynamicCastExprClass:
3202 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
3203 RAngleLoc, LParenLoc,
3204 SubExpr, RParenLoc);
3206 case Stmt::CXXReinterpretCastExprClass:
3207 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
3208 RAngleLoc, LParenLoc,
3212 case Stmt::CXXConstCastExprClass:
3213 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
3214 RAngleLoc, LParenLoc,
3215 SubExpr, RParenLoc);
3217 case Stmt::CXXAddrspaceCastExprClass:
3218 return getDerived().RebuildCXXAddrspaceCastExpr(
3219 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
3222 llvm_unreachable(
"Invalid C++ named cast");
3300 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3312 bool ListInitialization) {
3316 if (
auto *PLE = dyn_cast<ParenListExpr>(Sub))
3318 TInfo, LParenLoc,
MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
3319 RParenLoc, ListInitialization);
3322 ListInitialization);
3386 if (
getSema().CheckCXXThisType(ThisLoc, ThisType))
3396 bool IsThrownVariableInScope) {
3406 Expr *RewrittenExpr) {
3408 RewrittenExpr,
getSema().CurContext);
3442 std::optional<Expr *> ArraySize,
3461 bool IsGlobalDelete,
3512 bool IsAddressOfOperand,
3515 SS.
Adopt(QualifierLoc);
3517 if (TemplateArgs || TemplateKWLoc.
isValid())
3519 SS, TemplateKWLoc, NameInfo, TemplateArgs, IsAddressOfOperand);
3522 SS, NameInfo, IsAddressOfOperand, RecoveryTSI);
3544 bool IsElidable,
MultiExprArg Args,
bool HadMultipleCandidates,
3545 bool ListInitialization,
bool StdInitListInitialization,
3551 if (Constructor->isInheritingConstructor())
3552 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3555 if (
getSema().CompleteConstructorCall(FoundCtor,
T, Args,
Loc,
3562 HadMultipleCandidates,
3564 StdInitListInitialization,
3565 RequiresZeroInit, ConstructKind,
3573 bool ConstructsVBase,
3574 bool InheritedFromVBase) {
3576 Loc,
T, Constructor, ConstructsVBase, InheritedFromVBase);
3587 bool ListInitialization) {
3589 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3600 bool ListInitialization) {
3602 RParenLoc, ListInitialization);
3619 SS.
Adopt(QualifierLoc);
3622 OperatorLoc, IsArrow,
3624 FirstQualifierInScope,
3626 TemplateArgs,
nullptr);
3642 SS.
Adopt(QualifierLoc);
3645 OperatorLoc, IsArrow,
3647 FirstQualifierInScope,
3648 R, TemplateArgs,
nullptr);
3663 std::optional<unsigned> Length,
3666 RParenLoc, Length, PartialArgs);
3671 Expr *PackIdExpression,
Expr *IndexExpr,
3673 bool FullySubstituted =
false) {
3675 IndexExpr, RSquareLoc, ExpandedExprs,
3705 NamedConcept, TALI);
3723 LocalParameters, RParenLoc, Requirements,
3777 Expr **Elements,
unsigned NumElements) {
3787 RB,
Base, Key, getterMethod, setterMethod);
3819 ReceiverTypeInfo, ReceiverTypeInfo->
getType(),
3834 Sel, Method, LBracLoc,
3835 SelectorLocs, RBracLoc, Args);
3849 nullptr, SuperType, SuperLoc, Sel, Method, LBracLoc,
3850 SelectorLocs, RBracLoc, Args)
3852 Sel, Method, LBracLoc,
3853 SelectorLocs, RBracLoc, Args);
3862 bool IsArrow,
bool IsFreeIvar) {
3871 if (IsFreeIvar &&
Result.isUsable())
3872 cast<ObjCIvarRefExpr>(
Result.get())->setIsFreeIvar(IsFreeIvar);
3908 PropertyLoc,
Base));
3940 assert(!Lookup.
empty() &&
"No __builtin_shufflevector?");
3949 CK_BuiltinFnToFnPtr).
get();
3975 std::optional<unsigned> NumExpansions) {
3980 EllipsisLoc, NumExpansions);
4002 llvm_unreachable(
"Pack expansion pattern has no parameter packs");
4023 std::optional<unsigned> NumExpansions) {
4036 std::optional<unsigned> NumExpansions) {
4038 EllipsisLoc, RHS, RParenLoc,
4047 Init->containsUnexpandedParameterPack();
4048 else if (PVD->hasUninstantiatedDefaultArg())
4050 PVD->getUninstantiatedDefaultArg()
4051 ->containsUnexpandedParameterPack();
4196 Exprs.push_back(DevNumExpr);
4197 Exprs.insert(Exprs.end(), QueueIdExprs.begin(), QueueIdExprs.end());
4200 Exprs, RParenLoc, EndLoc, Clauses, {});
4224 bool DeducibleTSTContext);
4236template <
typename Derived>
4241 switch (S->getStmtClass()) {
4246#define STMT(Node, Parent) \
4247 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
4248#define VALUESTMT(Node, Parent) \
4249 case Stmt::Node##Class: \
4250 return getDerived().Transform##Node(cast<Node>(S), SDK);
4251#define ABSTRACT_STMT(Node)
4252#define EXPR(Node, Parent)
4253#include "clang/AST/StmtNodes.inc"
4256#define STMT(Node, Parent)
4257#define ABSTRACT_STMT(Stmt)
4258#define EXPR(Node, Parent) case Stmt::Node##Class:
4259#include "clang/AST/StmtNodes.inc"
4261 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
4263 if (SDK == SDK_StmtExprResult)
4264 E = getSema().ActOnStmtExprResult(
E);
4265 return getSema().ActOnExprStmt(
E, SDK == SDK_Discarded);
4272template<
typename Derived>
4277 switch (S->getClauseKind()) {
4280#define GEN_CLANG_CLAUSE_CLASS
4281#define CLAUSE_CLASS(Enum, Str, Class) \
4283 return getDerived().Transform##Class(cast<Class>(S));
4284#include "llvm/Frontend/OpenMP/OMP.inc"
4291template<
typename Derived>
4298#define STMT(Node, Parent) case Stmt::Node##Class: break;
4299#define ABSTRACT_STMT(Stmt)
4300#define EXPR(Node, Parent) \
4301 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4302#include "clang/AST/StmtNodes.inc"
4308template<
typename Derived>
4316 if (
auto *FE = dyn_cast<FullExpr>(
Init))
4317 Init = FE->getSubExpr();
4319 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(
Init)) {
4325 Init = MTE->getSubExpr();
4328 Init = Binder->getSubExpr();
4331 Init = ICE->getSubExprAsWritten();
4334 dyn_cast<CXXStdInitializerListExpr>(
Init))
4335 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4342 return getDerived().TransformExpr(
Init);
4347 return getDerived().RebuildParenListExpr(
Parens.getBegin(), {},
4352 if (isa<ImplicitValueInitExpr>(
Init))
4358 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
4359 return getDerived().TransformExpr(
Init);
4364 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
4371 getSema().currentEvaluationContext().InLifetimeExtendingContext =
4372 getSema().parentEvaluationContext().InLifetimeExtendingContext;
4373 getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit =
4374 getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit;
4376 bool ArgChanged =
false;
4378 true, NewArgs, &ArgChanged))
4383 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
4388 if (
Parens.isInvalid()) {
4391 assert(NewArgs.empty() &&
4392 "no parens or braces but have direct init with arguments?");
4395 return getDerived().RebuildParenListExpr(
Parens.getBegin(), NewArgs,
4399template<
typename Derived>
4405 for (
unsigned I = 0; I != NumInputs; ++I) {
4407 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4415 Expr *Pattern = Expansion->getPattern();
4418 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4419 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4424 bool RetainExpansion =
false;
4425 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4426 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4427 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4430 Expand, RetainExpansion,
4439 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4443 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4444 Expansion->getEllipsisLoc(),
4446 if (Out.isInvalid())
4451 Outputs.push_back(Out.get());
4457 if (ArgChanged) *ArgChanged =
true;
4461 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4463 ExprResult Out = getDerived().TransformExpr(Pattern);
4464 if (Out.isInvalid())
4467 if (Out.get()->containsUnexpandedParameterPack()) {
4468 Out = getDerived().RebuildPackExpansion(
4469 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4470 if (Out.isInvalid())
4474 Outputs.push_back(Out.get());
4479 if (RetainExpansion) {
4480 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4482 ExprResult Out = getDerived().TransformExpr(Pattern);
4483 if (Out.isInvalid())
4486 Out = getDerived().RebuildPackExpansion(
4487 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4488 if (Out.isInvalid())
4491 Outputs.push_back(Out.get());
4498 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4499 : getDerived().TransformExpr(Inputs[I]);
4503 if (
Result.get() != Inputs[I] && ArgChanged)
4506 Outputs.push_back(
Result.get());
4512template <
typename Derived>
4516 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4517 getDerived().TransformDefinition(Var->
getLocation(), Var));
4522 return getSema().ActOnConditionVariable(ConditionVar,
Loc, Kind);
4531 return getSema().ActOnCondition(
nullptr,
Loc, CondExpr.
get(), Kind,
4538template <
typename Derived>
4546 Qualifier = Qualifier.getPrefix())
4562 SS, FirstQualifierInScope,
false))
4569 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4577 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4592 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4601 FirstQualifierInScope, SS);
4611 diag::warn_cxx98_compat_enum_nested_name_spec);
4614 SS.
Adopt(ETL.getQualifierLoc());
4615 TL = ETL.getNamedTypeLoc();
4634 FirstQualifierInScope =
nullptr;
4640 !getDerived().AlwaysRebuild())
4653template<
typename Derived>
4661 switch (Name.getNameKind()) {
4672 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4673 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4674 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4690 NewTInfo = getDerived().TransformType(OldTInfo);
4698 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4714 llvm_unreachable(
"Unknown name kind.");
4717template<
typename Derived>
4724 bool AllowInjectedClassName) {
4726 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4727 assert(Template &&
"qualified template name must refer to a template");
4730 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4735 if (!getDerived().AlwaysRebuild() &&
4737 TransTemplate == Template)
4740 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4748 FirstQualifierInScope =
nullptr;
4751 if (!getDerived().AlwaysRebuild() &&
4759 if (DTN->isIdentifier()) {
4760 return getDerived().RebuildTemplateName(SS,
4762 *DTN->getIdentifier(),
4765 FirstQualifierInScope,
4766 AllowInjectedClassName);
4769 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4770 DTN->getOperator(), NameLoc,
4771 ObjectType, AllowInjectedClassName);
4775 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4777 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4782 return getDerived().RebuildTemplateName(SS,
false,
4787 = Name.getAsSubstTemplateTemplateParmPack()) {
4788 return getDerived().RebuildTemplateName(
4789 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4790 SubstPack->getIndex(), SubstPack->getFinal());
4794 llvm_unreachable(
"overloaded function decl survived to here");
4797template<
typename Derived>
4801 Output = getSema().getTrivialTemplateArgumentLoc(
4802 Arg,
QualType(), getDerived().getBaseLocation());
4805template <
typename Derived>
4813 llvm_unreachable(
"Unexpected TemplateArgument");
4823 QualType NewT = getDerived().TransformType(
T);
4830 ValueDecl *NewD =
D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4831 getDerived().getBaseLocation(),
D))
4836 if (NewT ==
T &&
D == NewD)
4853 llvm_unreachable(
"unexpected template argument kind");
4863 DI = getDerived().TransformType(DI);
4874 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4880 SS.
Adopt(QualifierLoc);
4881 TemplateName Template = getDerived().TransformTemplateName(
4892 llvm_unreachable(
"Caller should expand pack expansions");
4907 ExprResult E = getDerived().TransformExpr(InputExpr);
4922template<
typename Derived,
typename InputIterator>
4930 typedef typename std::iterator_traits<InputIterator>::difference_type
4960 Self.InventTemplateArgumentLoc(*
Iter,
Result);
4968 return X.Iter == Y.Iter;
4973 return X.Iter != Y.Iter;
4977template<
typename Derived>
4978template<
typename InputIterator>
4995 if (TransformTemplateArguments(PackLocIterator(*
this,
4996 In.getArgument().pack_begin()),
4997 PackLocIterator(*
this,
4998 In.getArgument().pack_end()),
5005 if (In.getArgument().isPackExpansion()) {
5009 std::optional<unsigned> OrigNumExpansions;
5011 = getSema().getTemplateArgumentPackExpansionPattern(
5012 In, Ellipsis, OrigNumExpansions);
5015 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5016 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5021 bool RetainExpansion =
false;
5022 std::optional<unsigned> NumExpansions = OrigNumExpansions;
5023 if (getDerived().TryExpandParameterPacks(Ellipsis,
5037 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
5040 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
5042 if (Out.getArgument().isNull())
5051 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5054 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5057 if (Out.getArgument().containsUnexpandedParameterPack()) {
5058 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5060 if (Out.getArgument().isNull())
5069 if (RetainExpansion) {
5070 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5072 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5075 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5077 if (Out.getArgument().isNull())
5087 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
5101template<
typename Derived>
5103 if (getDerived().AlreadyTransformed(
T))
5109 getDerived().getBaseLocation());
5119template<
typename Derived>
5123 getDerived().getBaseEntity());
5124 if (getDerived().AlreadyTransformed(DI->
getType()))
5139template<
typename Derived>
5142 switch (
T.getTypeLocClass()) {
5143#define ABSTRACT_TYPELOC(CLASS, PARENT)
5144#define TYPELOC(CLASS, PARENT) \
5145 case TypeLoc::CLASS: \
5146 return getDerived().Transform##CLASS##Type(TLB, \
5147 T.castAs<CLASS##TypeLoc>());
5148#include "clang/AST/TypeLocNodes.def"
5151 llvm_unreachable(
"unhandled type loc!");
5154template<
typename Derived>
5156 if (!isa<DependentNameType>(
T))
5157 return TransformType(
T);
5159 if (getDerived().AlreadyTransformed(
T))
5162 getDerived().getBaseLocation());
5163 TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
5167template<
typename Derived>
5170 if (!isa<DependentNameType>(DI->
getType()))
5171 return TransformType(DI);
5175 getDerived().getBaseEntity());
5176 if (getDerived().AlreadyTransformed(DI->
getType()))
5196 Result = getDerived().RebuildQualifiedType(
Result, QTL);
5205template<
typename Derived>
5210 TypeLoc UnqualTL =
T.getUnqualifiedLoc();
5211 auto SuppressObjCLifetime =
5212 T.getType().getLocalQualifiers().hasObjCLifetime();
5214 Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
5215 SuppressObjCLifetime);
5216 }
else if (
auto STTP = UnqualTL.
getAs<SubstTemplateTypeParmPackTypeLoc>()) {
5217 Result = getDerived().TransformSubstTemplateTypeParmPackType(
5218 TLB, STTP, SuppressObjCLifetime);
5220 Result = getDerived().TransformType(TLB, UnqualTL);
5239template <
typename Derived>
5249 SemaRef.
Diag(
Loc, diag::err_address_space_mismatch_templ_inst)
5280 else if (
T.getObjCLifetime()) {
5285 if ((AutoTy = dyn_cast<AutoType>(
T)) && AutoTy->
isDeduced()) {
5301 SemaRef.
Diag(
Loc, diag::err_attr_objc_ownership_redundant) <<
T;
5310template<
typename Derived>
5316 if (getDerived().AlreadyTransformed(TL.
getType()))
5320 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
5326template<
typename Derived>
5328TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
5329 QualType ObjectType,
5330 NamedDecl *UnqualLookup,
5332 if (getDerived().AlreadyTransformed(TSInfo->getType()))
5335 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
5339template <
typename Derived>
5340TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
5341 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
5343 QualType
T = TL.getType();
5344 assert(!getDerived().AlreadyTransformed(
T));
5349 if (isa<TemplateSpecializationType>(
T)) {
5350 TemplateSpecializationTypeLoc SpecTL =
5351 TL.castAs<TemplateSpecializationTypeLoc>();
5353 TemplateName Template = getDerived().TransformTemplateName(
5354 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
5355 ObjectType, UnqualLookup,
true);
5356 if (Template.isNull())
5359 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
5361 }
else if (isa<DependentTemplateSpecializationType>(
T)) {
5362 DependentTemplateSpecializationTypeLoc SpecTL =
5363 TL.castAs<DependentTemplateSpecializationTypeLoc>();
5365 TemplateName Template
5366 = getDerived().RebuildTemplateName(SS,
5367 SpecTL.getTemplateKeywordLoc(),
5368 *SpecTL.getTypePtr()->getIdentifier(),
5369 SpecTL.getTemplateNameLoc(),
5370 ObjectType, UnqualLookup,
5372 if (Template.isNull())
5375 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
5381 Result = getDerived().TransformType(TLB, TL);
5390template <
class TyLoc>
static inline
5392 TyLoc NewT = TLB.
push<TyLoc>(
T.getType());
5393 NewT.setNameLoc(
T.getNameLoc());
5397template<
typename Derived>
5398QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
5400 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(
T.getType());
5401 NewT.setBuiltinLoc(
T.getBuiltinLoc());
5402 if (
T.needsExtraLocalData())
5403 NewT.getWrittenBuiltinSpecs() =
T.getWrittenBuiltinSpecs();
5407template<
typename Derived>
5408QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
5414template <
typename Derived>
5415QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
5416 AdjustedTypeLoc TL) {
5418 return getDerived().TransformType(TLB, TL.getOriginalLoc());
5421template<
typename Derived>
5422QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
5423 DecayedTypeLoc TL) {
5424 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
5425 if (OriginalType.isNull())
5428 QualType
Result = TL.getType();
5429 if (getDerived().AlwaysRebuild() ||
5430 OriginalType != TL.getOriginalLoc().getType())
5432 TLB.push<DecayedTypeLoc>(
Result);
5437template <
typename Derived>
5439TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB,
5440 ArrayParameterTypeLoc TL) {
5441 QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc());
5442 if (OriginalType.isNull())
5445 QualType
Result = TL.getType();
5446 if (getDerived().AlwaysRebuild() ||
5447 OriginalType != TL.getElementLoc().getType())
5449 TLB.push<ArrayParameterTypeLoc>(
Result);
5454template<
typename Derived>
5455QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
5456 PointerTypeLoc TL) {
5457 QualType PointeeType
5458 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5459 if (PointeeType.isNull())
5462 QualType
Result = TL.getType();
5463 if (PointeeType->getAs<ObjCObjectType>()) {
5470 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(
Result);
5471 NewT.setStarLoc(TL.getStarLoc());
5475 if (getDerived().AlwaysRebuild() ||
5476 PointeeType != TL.getPointeeLoc().getType()) {
5477 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
5484 TLB.TypeWasModifiedSafely(
Result->getPointeeType());
5486 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(
Result);
5487 NewT.setSigilLoc(TL.getSigilLoc());
5491template<
typename Derived>
5493TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
5494 BlockPointerTypeLoc TL) {
5495 QualType PointeeType
5496 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5497 if (PointeeType.isNull())
5500 QualType
Result = TL.getType();
5501 if (getDerived().AlwaysRebuild() ||
5502 PointeeType != TL.getPointeeLoc().getType()) {
5503 Result = getDerived().RebuildBlockPointerType(PointeeType,
5509 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(
Result);
5510 NewT.setSigilLoc(TL.getSigilLoc());
5518template<
typename Derived>
5526 if (PointeeType.
isNull())
5530 if (getDerived().AlwaysRebuild() ||
5531 PointeeType !=
T->getPointeeTypeAsWritten()) {
5532 Result = getDerived().RebuildReferenceType(PointeeType,
5533 T->isSpelledAsLValue(),
5546 if (isa<LValueReferenceType>(
Result))
5555template<
typename Derived>
5559 return TransformReferenceType(TLB, TL);
5562template<
typename Derived>
5564TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
5565 RValueReferenceTypeLoc TL) {
5566 return TransformReferenceType(TLB, TL);
5569template<
typename Derived>
5571TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
5572 MemberPointerTypeLoc TL) {
5573 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5574 if (PointeeType.isNull())
5577 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
5578 TypeSourceInfo *NewClsTInfo =
nullptr;
5580 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
5585 const MemberPointerType *
T = TL.getTypePtr();
5586 QualType OldClsType = QualType(
T->getClass(), 0);
5587 QualType NewClsType;
5589 NewClsType = NewClsTInfo->getType();
5591 NewClsType = getDerived().TransformType(OldClsType);
5592 if (NewClsType.isNull())
5596 QualType
Result = TL.getType();
5597 if (getDerived().AlwaysRebuild() ||
5599 NewClsType != OldClsType) {
5600 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
5608 const MemberPointerType *MPT =
Result->getAs<MemberPointerType>();
5609 if (MPT && PointeeType != MPT->getPointeeType()) {
5610 assert(isa<AdjustedType>(MPT->getPointeeType()));
5611 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
5614 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(
Result);
5615 NewTL.setSigilLoc(TL.getSigilLoc());
5616 NewTL.setClassTInfo(NewClsTInfo);
5621template<
typename Derived>
5623TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
5624 ConstantArrayTypeLoc TL) {
5625 const ConstantArrayType *
T = TL.getTypePtr();
5626 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5627 if (ElementType.isNull())
5631 Expr *
OldSize = TL.getSizeExpr();
5633 OldSize =
const_cast<Expr*
>(
T->getSizeExpr());
5634 Expr *NewSize =
nullptr;
5638 NewSize = getDerived().TransformExpr(
OldSize).template getAs<Expr>();
5642 QualType
Result = TL.getType();
5643 if (getDerived().AlwaysRebuild() ||
5644 ElementType !=
T->getElementType() ||
5645 (
T->getSizeExpr() && NewSize !=
OldSize)) {
5646 Result = getDerived().RebuildConstantArrayType(ElementType,
5647 T->getSizeModifier(),
5648 T->getSize(), NewSize,
5649 T->getIndexTypeCVRQualifiers(),
5650 TL.getBracketsRange());
5659 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5660 NewTL.setLBracketLoc(TL.getLBracketLoc());
5661 NewTL.setRBracketLoc(TL.getRBracketLoc());
5662 NewTL.setSizeExpr(NewSize);
5667template<
typename Derived>
5668QualType TreeTransform<Derived>::TransformIncompleteArrayType(
5669 TypeLocBuilder &TLB,
5670 IncompleteArrayTypeLoc TL) {
5671 const IncompleteArrayType *
T = TL.getTypePtr();
5672 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5673 if (ElementType.isNull())
5676 QualType
Result = TL.getType();
5677 if (getDerived().AlwaysRebuild() ||
5678 ElementType !=
T->getElementType()) {
5679 Result = getDerived().RebuildIncompleteArrayType(ElementType,
5680 T->getSizeModifier(),
5681 T->getIndexTypeCVRQualifiers(),
5682 TL.getBracketsRange());
5687 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(
Result);
5688 NewTL.setLBracketLoc(TL.getLBracketLoc());
5689 NewTL.setRBracketLoc(TL.getRBracketLoc());
5690 NewTL.setSizeExpr(
nullptr);
5695template<
typename Derived>
5697TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
5698 VariableArrayTypeLoc TL) {
5699 const VariableArrayType *
T = TL.getTypePtr();
5700 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5701 if (ElementType.isNull())
5706 EnterExpressionEvaluationContext Context(
5708 SizeResult = getDerived().TransformExpr(
T->getSizeExpr());
5710 if (SizeResult.isInvalid())
5714 if (SizeResult.isInvalid())
5717 Expr *
Size = SizeResult.get();
5719 QualType
Result = TL.getType();
5720 if (getDerived().AlwaysRebuild() ||
5721 ElementType !=
T->getElementType() ||
5722 Size !=
T->getSizeExpr()) {
5723 Result = getDerived().RebuildVariableArrayType(ElementType,
5724 T->getSizeModifier(),
5726 T->getIndexTypeCVRQualifiers(),
5727 TL.getBracketsRange());
5734 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5735 NewTL.setLBracketLoc(TL.getLBracketLoc());
5736 NewTL.setRBracketLoc(TL.getRBracketLoc());
5737 NewTL.setSizeExpr(Size);
5742template<
typename Derived>
5744TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
5745 DependentSizedArrayTypeLoc TL) {
5746 const DependentSizedArrayType *
T = TL.getTypePtr();
5747 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5748 if (ElementType.isNull())
5756 SemaRef.
ExprEvalContexts.back().InConditionallyConstantEvaluateContext =
true;
5759 Expr *origSize = TL.getSizeExpr();
5760 if (!origSize) origSize =
T->getSizeExpr();
5763 = getDerived().TransformExpr(origSize);
5765 if (sizeResult.isInvalid())
5768 Expr *size = sizeResult.get();
5770 QualType
Result = TL.getType();
5771 if (getDerived().AlwaysRebuild() ||
5772 ElementType !=
T->getElementType() ||
5774 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
5775 T->getSizeModifier(),
5777 T->getIndexTypeCVRQualifiers(),
5778 TL.getBracketsRange());
5785 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5786 NewTL.setLBracketLoc(TL.getLBracketLoc());
5787 NewTL.setRBracketLoc(TL.getRBracketLoc());
5788 NewTL.setSizeExpr(size);
5793template <
typename Derived>
5794QualType TreeTransform<Derived>::TransformDependentVectorType(
5795 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
5796 const DependentVectorType *
T = TL.getTypePtr();
5797 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5798 if (ElementType.isNull())
5806 if (
Size.isInvalid())
5809 QualType
Result = TL.getType();
5810 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType() ||
5811 Size.get() !=
T->getSizeExpr()) {
5812 Result = getDerived().RebuildDependentVectorType(
5813 ElementType,
Size.get(),
T->getAttributeLoc(),
T->getVectorKind());
5819 if (isa<DependentVectorType>(
Result)) {
5820 DependentVectorTypeLoc NewTL =
5821 TLB.push<DependentVectorTypeLoc>(
Result);
5822 NewTL.setNameLoc(TL.getNameLoc());
5824 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(
Result);
5825 NewTL.setNameLoc(TL.getNameLoc());
5831template<
typename Derived>
5832QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
5833 TypeLocBuilder &TLB,
5834 DependentSizedExtVectorTypeLoc TL) {
5835 const DependentSizedExtVectorType *
T = TL.getTypePtr();
5838 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5839 if (ElementType.isNull())
5848 if (
Size.isInvalid())
5851 QualType
Result = TL.getType();
5852 if (getDerived().AlwaysRebuild() ||
5853 ElementType !=
T->getElementType() ||
5854 Size.get() !=
T->getSizeExpr()) {
5855 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
5857 T->getAttributeLoc());
5863 if (isa<DependentSizedExtVectorType>(
Result)) {
5864 DependentSizedExtVectorTypeLoc NewTL
5865 = TLB.push<DependentSizedExtVectorTypeLoc>(
Result);
5866 NewTL.setNameLoc(TL.getNameLoc());
5868 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(
Result);
5869 NewTL.setNameLoc(TL.getNameLoc());
5875template <
typename Derived>
5877TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
5878 ConstantMatrixTypeLoc TL) {
5879 const ConstantMatrixType *
T = TL.getTypePtr();
5880 QualType ElementType = getDerived().TransformType(
T->getElementType());
5881 if (ElementType.isNull())
5884 QualType
Result = TL.getType();
5885 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType()) {
5886 Result = getDerived().RebuildConstantMatrixType(
5887 ElementType,
T->getNumRows(),
T->getNumColumns());
5892 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(
Result);
5893 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5894 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5895 NewTL.setAttrRowOperand(TL.getAttrRowOperand());
5896 NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());
5901template <
typename Derived>
5902QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
5903 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
5904 const DependentSizedMatrixType *
T = TL.getTypePtr();
5906 QualType ElementType = getDerived().TransformType(
T->getElementType());
5907 if (ElementType.isNull()) {
5915 Expr *origRows = TL.getAttrRowOperand();
5917 origRows =
T->getRowExpr();
5918 Expr *origColumns = TL.getAttrColumnOperand();
5920 origColumns =
T->getColumnExpr();
5922 ExprResult rowResult = getDerived().TransformExpr(origRows);
5924 if (rowResult.isInvalid())
5927 ExprResult columnResult = getDerived().TransformExpr(origColumns);
5929 if (columnResult.isInvalid())
5932 Expr *rows = rowResult.get();
5933 Expr *columns = columnResult.get();
5935 QualType
Result = TL.getType();
5936 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType() ||
5937 rows != origRows || columns != origColumns) {
5938 Result = getDerived().RebuildDependentSizedMatrixType(
5939 ElementType, rows, columns,
T->getAttributeLoc());
5947 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(
Result);
5948 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5949 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5950 NewTL.setAttrRowOperand(rows);
5951 NewTL.setAttrColumnOperand(columns);
5955template <
typename Derived>
5956QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
5957 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
5958 const DependentAddressSpaceType *
T = TL.getTypePtr();
5960 QualType pointeeType =
5961 getDerived().TransformType(TLB, TL.getPointeeTypeLoc());
5963 if (pointeeType.isNull())
5970 ExprResult AddrSpace = getDerived().TransformExpr(
T->getAddrSpaceExpr());
5972 if (AddrSpace.isInvalid())
5975 QualType
Result = TL.getType();
5976 if (getDerived().AlwaysRebuild() || pointeeType !=
T->
getPointeeType() ||
5977 AddrSpace.get() !=
T->getAddrSpaceExpr()) {
5978 Result = getDerived().RebuildDependentAddressSpaceType(
5979 pointeeType, AddrSpace.get(),
T->getAttributeLoc());
5985 if (isa<DependentAddressSpaceType>(
Result)) {
5986 DependentAddressSpaceTypeLoc NewTL =
5987 TLB.push<DependentAddressSpaceTypeLoc>(
Result);
5989 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5990 NewTL.setAttrExprOperand(TL.getAttrExprOperand());
5991 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5994 TLB.TypeWasModifiedSafely(
Result);
6000template <
typename Derived>
6001QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
6003 const VectorType *
T = TL.getTypePtr();
6004 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6005 if (ElementType.isNull())
6008 QualType
Result = TL.getType();
6009 if (getDerived().AlwaysRebuild() ||
6010 ElementType !=
T->getElementType()) {
6011 Result = getDerived().RebuildVectorType(ElementType,
T->getNumElements(),
6012 T->getVectorKind());
6017 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(
Result);
6018 NewTL.setNameLoc(TL.getNameLoc());
6023template<
typename Derived>
6024QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
6025 ExtVectorTypeLoc TL) {
6026 const VectorType *
T = TL.getTypePtr();
6027 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6028 if (ElementType.isNull())
6031 QualType
Result = TL.getType();
6032 if (getDerived().AlwaysRebuild() ||
6033 ElementType !=
T->getElementType()) {
6034 Result = getDerived().RebuildExtVectorType(ElementType,
6035 T->getNumElements(),
6041 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(
Result);
6042 NewTL.setNameLoc(TL.getNameLoc());
6047template <
typename Derived>
6050 std::optional<unsigned> NumExpansions,
bool ExpectParameterPack) {
6054 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
6081 NewDI = getDerived().TransformType(OldDI);
6085 if (NewDI == OldDI && indexAdjustment == 0)
6099 transformedLocalDecl(OldParm, {newParm});
6103template <
typename Derived>
6111 unsigned *LastParamTransformed) {
6112 int indexAdjustment = 0;
6114 unsigned NumParams = Params.size();
6115 for (
unsigned i = 0; i != NumParams; ++i) {
6116 if (LastParamTransformed)
6117 *LastParamTransformed = i;
6119 assert(OldParm->getFunctionScopeIndex() == i);
6121 std::optional<unsigned> NumExpansions;
6123 if (OldParm->isParameterPack()) {
6128 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
6134 bool ShouldExpand =
false;
6135 bool RetainExpansion =
false;
6136 std::optional<unsigned> OrigNumExpansions;
6137 if (Unexpanded.size() > 0) {
6139 NumExpansions = OrigNumExpansions;
6140 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
6141 Pattern.getSourceRange(),
6153 "Could not find parameter packs or undeduced auto type!");
6160 getDerived().ExpandingFunctionParameterPack(OldParm);
6161 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6164 = getDerived().TransformFunctionTypeParam(OldParm,
6172 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6173 OutParamTypes.push_back(NewParm->
getType());
6175 PVars->push_back(NewParm);
6180 if (RetainExpansion) {
6181 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6183 = getDerived().TransformFunctionTypeParam(OldParm,
6191 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6192 OutParamTypes.push_back(NewParm->
getType());
6194 PVars->push_back(NewParm);
6210 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
6215 "Parameter pack no longer a parameter pack after "
6218 NewParm = getDerived().TransformFunctionTypeParam(
6219 OldParm, indexAdjustment, std::nullopt,
6227 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6228 OutParamTypes.push_back(NewParm->
getType());
6230 PVars->push_back(NewParm);
6238 bool IsPackExpansion =
false;
6239 std::optional<unsigned> NumExpansions;
6242 = dyn_cast<PackExpansionType>(OldType)) {
6244 QualType Pattern = Expansion->getPattern();
6246 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
6249 bool ShouldExpand =
false;
6250 bool RetainExpansion =
false;
6262 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6264 QualType NewType = getDerived().TransformType(Pattern);
6269 NewType = getSema().getASTContext().getPackExpansionType(
6270 NewType, std::nullopt);
6277 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6278 OutParamTypes.push_back(NewType);
6280 PVars->push_back(
nullptr);
6289 if (RetainExpansion) {
6290 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6291 QualType NewType = getDerived().TransformType(Pattern);
6296 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6297 OutParamTypes.push_back(NewType);
6299 PVars->push_back(
nullptr);
6304 OldType = Expansion->getPattern();
6305 IsPackExpansion =
true;
6307 NewType = getDerived().TransformType(OldType);
6309 NewType = getDerived().TransformType(OldType);
6315 if (IsPackExpansion)
6316 NewType = getSema().Context.getPackExpansionType(NewType,
6320 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6321 OutParamTypes.push_back(NewType);
6323 PVars->push_back(
nullptr);
6328 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
6330 assert(parm->getFunctionScopeIndex() == i);
6337template<
typename Derived>
6342 return getDerived().TransformFunctionProtoType(
6345 return getDerived().TransformExceptionSpec(TL.
getBeginLoc(), ESI,
6346 ExceptionStorage, Changed);
6350template<
typename Derived>
template<
typename Fn>
6353 Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {
6370 if (getDerived().TransformFunctionTypeParams(
6374 ParamTypes, &ParamDecls, ExtParamInfos))
6386 SemaRef, !ThisContext && RD ? RD : ThisContext, ThisTypeQuals);
6388 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
6394 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
6398 if (getDerived().TransformFunctionTypeParams(
6402 ParamTypes, &ParamDecls, ExtParamInfos))
6408 bool EPIChanged =
false;
6413 if (
auto NewExtParamInfos =
6429 std::optional<FunctionEffectSet> NewFX;
6438 ExprResult NewExpr = getDerived().TransformExpr(CondExpr);
6441 std::optional<FunctionEffectMode> Mode =
6461 "FunctionEffectMode::None shouldn't be possible here");
6467 NewFX->insert(NewEC, Errs);
6468 assert(Errs.empty());
6476 if (getDerived().AlwaysRebuild() || ResultType !=
T->
getReturnType() ||
6478 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
6489 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
6495template<
typename Derived>
6505 auto *Method = dyn_cast_if_present<CXXMethodDecl>(ESI.
SourceTemplate);
6507 SemaRef, Method ? Method->getParent() :
nullptr,
6508 Method ? Method->getMethodQualifiers() :
Qualifiers{},
6518 getSema().ActOnNoexceptSpec(NoexceptExpr.
get(), EST);
6541 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
6546 bool Expand =
false;
6547 bool RetainExpansion =
false;
6548 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6551 if (getDerived().TryExpandParameterPacks(
6553 RetainExpansion, NumExpansions))
6561 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6566 Exceptions.push_back(
U);
6572 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6575 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6579 Exceptions.push_back(
U);
6588 Exceptions.push_back(
U);
6598template<
typename Derived>
6608 if (getDerived().AlwaysRebuild() || ResultType !=
T->
getReturnType())
6609 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
6620template <
typename Derived>
6621QualType TreeTransform<Derived>::TransformUnresolvedUsingType(
6622 TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
6623 const UnresolvedUsingType *
T = TL.getTypePtr();
6624 Decl *
D = getDerived().TransformDecl(TL.getNameLoc(),
T->getDecl());
6628 QualType
Result = TL.getType();
6629 if (getDerived().AlwaysRebuild() ||
D !=
T->getDecl()) {
6630 Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(),
D);
6637 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(
Result);
6638 NewTL.setNameLoc(TL.getNameLoc());
6643template <
typename Derived>
6644QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
6646 const UsingType *
T = TL.getTypePtr();
6648 auto *
Found = cast_or_null<UsingShadowDecl>(getDerived().TransformDecl(
6649 TL.getLocalSourceRange().getBegin(),
T->getFoundDecl()));
6653 QualType Underlying = getDerived().TransformType(
T->
desugar());
6654 if (Underlying.isNull())
6657 QualType
Result = TL.getType();
6658 if (getDerived().AlwaysRebuild() ||
Found !=
T->getFoundDecl() ||
6659 Underlying !=
T->getUnderlyingType()) {
6660 Result = getDerived().RebuildUsingType(
Found, Underlying);
6665 TLB.pushTypeSpec(
Result).setNameLoc(TL.getNameLoc());
6669template<
typename Derived>
6670QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
6671 TypedefTypeLoc TL) {
6672 const TypedefType *
T = TL.getTypePtr();
6673 TypedefNameDecl *Typedef
6674 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6679 QualType
Result = TL.getType();
6680 if (getDerived().AlwaysRebuild() ||
6681 Typedef !=
T->getDecl()) {
6682 Result = getDerived().RebuildTypedefType(Typedef);
6687 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(
Result);
6688 NewTL.setNameLoc(TL.getNameLoc());
6693template<
typename Derived>
6694QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
6695 TypeOfExprTypeLoc TL) {
6701 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
6709 QualType
Result = TL.getType();
6711 if (getDerived().AlwaysRebuild() ||
E.get() != TL.getUnderlyingExpr()) {
6713 getDerived().RebuildTypeOfExprType(
E.get(), TL.getTypeofLoc(), Kind);
6718 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(
Result);
6719 NewTL.setTypeofLoc(TL.getTypeofLoc());
6720 NewTL.setLParenLoc(TL.getLParenLoc());
6721 NewTL.setRParenLoc(TL.getRParenLoc());
6726template<
typename Derived>
6727QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
6729 TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();
6730 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
6734 QualType
Result = TL.getType();
6736 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
6737 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
6742 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(
Result);
6743 NewTL.setTypeofLoc(TL.getTypeofLoc());
6744 NewTL.setLParenLoc(TL.getLParenLoc());
6745 NewTL.setRParenLoc(TL.getRParenLoc());
6746 NewTL.setUnmodifiedTInfo(New_Under_TI);
6751template<
typename Derived>
6752QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
6753 DecltypeTypeLoc TL) {
6754 const DecltypeType *
T = TL.getTypePtr();
6761 ExprResult E = getDerived().TransformExpr(
T->getUnderlyingExpr());
6765 E = getSema().ActOnDecltypeExpression(
E.get());
6769 QualType
Result = TL.getType();
6770 if (getDerived().AlwaysRebuild() ||
6771 E.get() !=
T->getUnderlyingExpr()) {
6772 Result = getDerived().RebuildDecltypeType(
E.get(), TL.getDecltypeLoc());
6778 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(
Result);
6779 NewTL.setDecltypeLoc(TL.getDecltypeLoc());
6780 NewTL.setRParenLoc(TL.getRParenLoc());
6784template <
typename Derived>
6786TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,
6787 PackIndexingTypeLoc TL) {
6791 EnterExpressionEvaluationContext ConstantContext(
6794 IndexExpr = getDerived().TransformExpr(TL.getIndexExpr());
6795 if (IndexExpr.isInvalid())
6798 QualType Pattern = TL.getPattern();
6800 const PackIndexingType *PIT = TL.getTypePtr();
6804 bool NotYetExpanded = Types.empty();
6805 bool FullySubstituted =
true;
6807 if (Types.empty() && !PIT->expandsToEmptyPack())
6810 for (QualType
T : Types) {
6812 QualType Transformed = getDerived().TransformType(
T);
6813 if (Transformed.isNull())
6815 SubtitutedTypes.push_back(Transformed);
6820 getSema().collectUnexpandedParameterPacks(
T, Unexpanded);
6821 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
6824 bool ShouldExpand =
true;
6825 bool RetainExpansion =
false;
6826 std::optional<unsigned> OrigNumExpansions;
6827 std::optional<unsigned> NumExpansions = OrigNumExpansions;
6828 if (getDerived().TryExpandParameterPacks(TL.getEllipsisLoc(), SourceRange(),
6829 Unexpanded, ShouldExpand,
6830 RetainExpansion, NumExpansions))
6832 if (!ShouldExpand) {
6833 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6836 TypeSourceInfo *TI =
6838 QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc());
6841 if (NotYetExpanded) {
6842 FullySubstituted =
false;
6843 QualType Out = getDerived().RebuildPackIndexingType(
6844 Pack, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),
6849 PackIndexingTypeLoc
Loc = TLB.push<PackIndexingTypeLoc>(Out);
6850 Loc.setEllipsisLoc(TL.getEllipsisLoc());
6853 SubtitutedTypes.push_back(Pack);
6856 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6857 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
6858 QualType Out = getDerived().TransformType(
T);
6861 SubtitutedTypes.push_back(Out);
6862 FullySubstituted &= !Out->containsUnexpandedParameterPack();
6866 if (RetainExpansion) {
6867 FullySubstituted =
false;
6868 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6869 QualType Out = getDerived().TransformType(
T);
6872 SubtitutedTypes.push_back(Out);
6879 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6880 QualType
Result = getDerived().TransformType(TLB, TL.getPatternLoc());
6882 QualType Out = getDerived().RebuildPackIndexingType(
6883 Result, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),
6884 FullySubstituted, SubtitutedTypes);
6888 PackIndexingTypeLoc
Loc = TLB.push<PackIndexingTypeLoc>(Out);
6889 Loc.setEllipsisLoc(TL.getEllipsisLoc());
6893template<
typename Derived>
6894QualType TreeTransform<Derived>::TransformUnaryTransformType(
6895 TypeLocBuilder &TLB,
6896 UnaryTransformTypeLoc TL) {
6897 QualType
Result = TL.getType();
6898 if (
Result->isDependentType()) {
6899 const UnaryTransformType *
T = TL.getTypePtr();
6901 TypeSourceInfo *NewBaseTSI =
6902 getDerived().TransformType(TL.getUnderlyingTInfo());
6905 QualType NewBase = NewBaseTSI->getType();
6907 Result = getDerived().RebuildUnaryTransformType(NewBase,
6914 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(
Result);
6915 NewTL.setKWLoc(TL.getKWLoc());
6916 NewTL.setParensRange(TL.getParensRange());
6917 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
6921template<
typename Derived>
6922QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
6923 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
6924 const DeducedTemplateSpecializationType *
T = TL.getTypePtr();
6927 TemplateName TemplateName = getDerived().TransformTemplateName(
6928 SS,
T->getTemplateName(), TL.getTemplateNameLoc());
6929 if (TemplateName.isNull())
6932 QualType OldDeduced =
T->getDeducedType();
6933 QualType NewDeduced;
6934 if (!OldDeduced.isNull()) {
6935 NewDeduced = getDerived().TransformType(OldDeduced);
6936 if (NewDeduced.isNull())
6940 QualType
Result = getDerived().RebuildDeducedTemplateSpecializationType(
6941 TemplateName, NewDeduced);
6945 DeducedTemplateSpecializationTypeLoc NewTL =
6946 TLB.push<DeducedTemplateSpecializationTypeLoc>(
Result);
6947 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6952template<
typename Derived>
6953QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
6955 const RecordType *
T = TL.getTypePtr();
6957 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6962 QualType
Result = TL.getType();
6963 if (getDerived().AlwaysRebuild() ||
6970 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(
Result);
6971 NewTL.setNameLoc(TL.getNameLoc());
6976template<
typename Derived>
6977QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
6979 const EnumType *
T = TL.getTypePtr();
6981 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6986 QualType
Result = TL.getType();
6987 if (getDerived().AlwaysRebuild() ||
6988 Enum !=
T->getDecl()) {
6994 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(
Result);
6995 NewTL.setNameLoc(TL.getNameLoc());
7000template<
typename Derived>
7001QualType TreeTransform<Derived>::TransformInjectedClassNameType(
7002 TypeLocBuilder &TLB,
7003 InjectedClassNameTypeLoc TL) {
7004 Decl *
D = getDerived().TransformDecl(TL.getNameLoc(),
7005 TL.getTypePtr()->getDecl());
7006 if (!
D)
return QualType();
7009 TLB.pushTypeSpec(
T).setNameLoc(TL.getNameLoc());
7013template<
typename Derived>
7017 return getDerived().TransformTemplateTypeParmType(
7022template <
typename Derived>
7028template<
typename Derived>
7029QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
7030 TypeLocBuilder &TLB,
7031 SubstTemplateTypeParmTypeLoc TL) {
7032 const SubstTemplateTypeParmType *
T = TL.getTypePtr();
7035 getDerived().TransformDecl(TL.getNameLoc(),
T->getAssociatedDecl());
7040 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
7041 QualType Replacement = getDerived().TransformType(
T->getReplacementType());
7042 if (Replacement.isNull())
7046 Replacement, NewReplaced,
T->getIndex(),
T->getPackIndex());
7049 SubstTemplateTypeParmTypeLoc NewTL
7050 = TLB.push<SubstTemplateTypeParmTypeLoc>(
Result);
7051 NewTL.setNameLoc(TL.getNameLoc());
7056template<
typename Derived>
7060 return getDerived().TransformSubstTemplateTypeParmPackType(
7064template <
typename Derived>
7070template<
typename Derived>
7080 = getDerived().TransformTemplateName(SS,
T->getTemplateName(),
7085 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
7088template<
typename Derived>
7096 if (getDerived().AlwaysRebuild() ||
7098 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
7103 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(
Result);
7111template <
typename Derived>
7112QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
7114 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
7115 if (ValueType.isNull())
7118 QualType
Result = TL.getType();
7119 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
7120 const PipeType *PT =
Result->castAs<PipeType>();
7121 bool isReadPipe = PT->isReadOnly();
7122 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
7127 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(
Result);
7128 NewTL.setKWLoc(TL.getKWLoc());
7133template <
typename Derived>
7134QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
7136 const BitIntType *EIT = TL.getTypePtr();
7137 QualType
Result = TL.getType();
7139 if (getDerived().AlwaysRebuild()) {
7140 Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
7141 EIT->getNumBits(), TL.getNameLoc());
7146 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(
Result);
7147 NewTL.setNameLoc(TL.getNameLoc());
7151template <
typename Derived>
7152QualType TreeTransform<Derived>::TransformDependentBitIntType(
7153 TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
7154 const DependentBitIntType *EIT = TL.getTypePtr();
7158 ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
7161 if (BitsExpr.isInvalid())
7164 QualType
Result = TL.getType();
7166 if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
7167 Result = getDerived().RebuildDependentBitIntType(
7168 EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());
7174 if (isa<DependentBitIntType>(
Result)) {
7175 DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(
Result);
7176 NewTL.setNameLoc(TL.getNameLoc());
7178 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(
Result);
7179 NewTL.setNameLoc(TL.getNameLoc());
7189 template<
typename ArgLocContainer>
7191 ArgLocContainer *Container;
7216 : Container(&Container), Index(Index) { }
7230 return Container->getArgLoc(Index);
7234 return pointer(Container->getArgLoc(Index));
7239 return X.Container == Y.Container &&
X.Index == Y.Index;
7248template<
typename Derived>
7249QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
7251 const AutoType *
T = TL.getTypePtr();
7252 QualType OldDeduced =
T->getDeducedType();
7253 QualType NewDeduced;
7254 if (!OldDeduced.isNull()) {
7255 NewDeduced = getDerived().TransformType(OldDeduced);
7256 if (NewDeduced.isNull())
7260 ConceptDecl *NewCD =
nullptr;
7261 TemplateArgumentListInfo NewTemplateArgs;
7262 NestedNameSpecifierLoc NewNestedNameSpec;
7263 if (
T->isConstrained()) {
7264 assert(TL.getConceptReference());
7265 NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl(
7266 TL.getConceptNameLoc(),
T->getTypeConstraintConcept()));
7268 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7269 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7270 typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
7271 if (getDerived().TransformTemplateArguments(
7272 ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),
7276 if (TL.getNestedNameSpecifierLoc()) {
7278 = getDerived().TransformNestedNameSpecifierLoc(
7279 TL.getNestedNameSpecifierLoc());
7280 if (!NewNestedNameSpec)
7285 QualType
Result = TL.getType();
7286 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
7290 NewArgList.reserve(NewTemplateArgs.size());
7291 for (
const auto &ArgLoc : NewTemplateArgs.arguments())
7292 NewArgList.push_back(ArgLoc.getArgument());
7293 Result = getDerived().RebuildAutoType(NewDeduced,
T->getKeyword(), NewCD,
7299 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(
Result);
7300 NewTL.setNameLoc(TL.getNameLoc());
7301 NewTL.setRParenLoc(TL.getRParenLoc());
7302 NewTL.setConceptReference(
nullptr);
7304 if (
T->isConstrained()) {
7305 DeclarationNameInfo DNI = DeclarationNameInfo(
7306 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(),
7307 TL.getConceptNameLoc(),
7308 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());
7310 SemaRef.
Context, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI,
7311 TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(),
7313 NewTL.setConceptReference(CR);
7319template <
typename Derived>
7321 TypeLocBuilder &TLB,
7322 TemplateSpecializationTypeLoc TL,
7323 TemplateName Template) {
7324 TemplateArgumentListInfo NewTemplateArgs;
7325 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7326 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7327 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
7329 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7330 ArgIterator(TL, TL.getNumArgs()),
7337 getDerived().RebuildTemplateSpecializationType(Template,
7338 TL.getTemplateNameLoc(),
7346 if (isa<DependentTemplateSpecializationType>(
Result)) {
7347 DependentTemplateSpecializationTypeLoc NewTL
7348 = TLB.push<DependentTemplateSpecializationTypeLoc>(
Result);
7349 NewTL.setElaboratedKeywordLoc(SourceLocation());
7350 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
7351 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
7352 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
7353 NewTL.setLAngleLoc(TL.getLAngleLoc());
7354 NewTL.setRAngleLoc(TL.getRAngleLoc());
7355 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
7356 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
7360 TemplateSpecializationTypeLoc NewTL
7361 = TLB.push<TemplateSpecializationTypeLoc>(
Result);
7362 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
7363 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
7364 NewTL.setLAngleLoc(TL.getLAngleLoc());
7365 NewTL.setRAngleLoc(TL.getRAngleLoc());
7366 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
7367 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
7373template <
typename Derived>
7384 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7392 QualType Result = getSema().Context.getDependentTemplateSpecializationType(
7394 DTN->getIdentifier(), NewTemplateArgs.
arguments());
7404 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
7410 = getDerived().RebuildTemplateSpecializationType(Template,
7422 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
7429template<
typename Derived>
7444 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
7445 if (NamedT.isNull())
7454 if (
const TemplateSpecializationType *TST =
7455 NamedT->getAs<TemplateSpecializationType>()) {
7456 TemplateName Template = TST->getTemplateName();
7457 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
7458 Template.getAsTemplateDecl())) {
7460 diag::err_tag_reference_non_tag)
7462 << llvm::to_underlying(
7464 SemaRef.
Diag(TAT->getLocation(), diag::note_declared_at);
7470 if (getDerived().AlwaysRebuild() ||
7472 NamedT !=
T->getNamedType()) {
7475 QualifierLoc, NamedT);
7480 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(
Result);
7482 NewTL.setQualifierLoc(QualifierLoc);
7486template <
typename Derived>
7487QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB,
7488 AttributedTypeLoc TL) {
7490 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
7491 if (modifiedType.isNull())
7495 const Attr *oldAttr = TL.getAttr();
7496 const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) :
nullptr;
7497 if (oldAttr && !newAttr)
7500 QualType result = TL.getType();
7503 if (getDerived().AlwaysRebuild() ||
7504 modifiedType != oldType->getModifiedType()) {
7517 QualType equivalentType = modifiedType;
7518 if (TL.getModifiedLoc().getType() != TL.getEquivalentTypeLoc().getType()) {
7519 TypeLocBuilder AuxiliaryTLB;
7520 AuxiliaryTLB.reserve(TL.getFullDataSize());
7522 getDerived().TransformType(AuxiliaryTLB, TL.getEquivalentTypeLoc());
7523 if (equivalentType.isNull())
7529 if (
auto nullability = oldType->getImmediateNullability()) {
7530 if (!modifiedType->canHaveNullability()) {
7531 SemaRef.
Diag((TL.getAttr() ? TL.getAttr()->getLocation()
7532 : TL.getModifiedLoc().getBeginLoc()),
7533 diag::err_nullability_nonpointer)
7545 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
7546 newTL.setAttr(newAttr);
7550template <
typename Derived>
7551QualType TreeTransform<Derived>::TransformCountAttributedType(
7552 TypeLocBuilder &TLB, CountAttributedTypeLoc TL) {
7553 const CountAttributedType *OldTy = TL.
getTypePtr();
7554 QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());
7555 if (InnerTy.isNull())
7558 Expr *OldCount = TL.getCountExpr();
7559 Expr *NewCount =
nullptr;
7561 ExprResult CountResult = getDerived().TransformExpr(OldCount);
7562 if (CountResult.isInvalid())
7564 NewCount = CountResult.get();
7567 QualType
Result = TL.getType();
7568 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() ||
7569 OldCount != NewCount) {
7572 InnerTy, NewCount, OldTy->isCountInBytes(), OldTy->isOrNull());
7575 TLB.push<CountAttributedTypeLoc>(
Result);
7579template <
typename Derived>
7580QualType TreeTransform<Derived>::TransformBTFTagAttributedType(
7581 TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
7583 llvm_unreachable(
"Unexpected TreeTransform for BTFTagAttributedType");
7586template <
typename Derived>
7587QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType(
7588 TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) {
7590 const HLSLAttributedResourceType *oldType = TL.getTypePtr();
7592 QualType WrappedTy = getDerived().TransformType(TLB, TL.getWrappedLoc());
7593 if (WrappedTy.isNull())
7596 QualType ContainedTy = QualType();
7597 QualType OldContainedTy = oldType->getContainedType();
7598 if (!OldContainedTy.isNull()) {
7599 TypeSourceInfo *oldContainedTSI = TL.getContainedTypeSourceInfo();
7600 if (!oldContainedTSI)
7601 oldContainedTSI = getSema().getASTContext().getTrivialTypeSourceInfo(
7602 OldContainedTy, SourceLocation());
7603 TypeSourceInfo *ContainedTSI = getDerived().TransformType(oldContainedTSI);
7606 ContainedTy = ContainedTSI->getType();
7609 QualType
Result = TL.getType();
7610 if (getDerived().AlwaysRebuild() || WrappedTy != oldType->getWrappedType() ||
7611 ContainedTy != oldType->getContainedType()) {
7613 WrappedTy, ContainedTy, oldType->getAttrs());
7616 TLB.push<HLSLAttributedResourceTypeLoc>(
Result);
7620template<
typename Derived>
7622TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
7624 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7628 QualType
Result = TL.getType();
7629 if (getDerived().AlwaysRebuild() ||
7630 Inner != TL.getInnerLoc().getType()) {
7631 Result = getDerived().RebuildParenType(Inner);
7636 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(
Result);
7637 NewTL.setLParenLoc(TL.getLParenLoc());
7638 NewTL.setRParenLoc(TL.getRParenLoc());
7642template <
typename Derived>
7644TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
7645 MacroQualifiedTypeLoc TL) {
7646 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7650 QualType
Result = TL.getType();
7651 if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
7653 getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
7658 MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(
Result);
7659 NewTL.setExpansionLoc(TL.getExpansionLoc());
7663template<
typename Derived>
7664QualType TreeTransform<Derived>::TransformDependentNameType(
7665 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
7666 return TransformDependentNameType(TLB, TL,
false);
7669template<
typename Derived>
7670QualType TreeTransform<Derived>::TransformDependentNameType(
7671 TypeLocBuilder &TLB, DependentNameTypeLoc TL,
bool DeducedTSTContext) {
7672 const DependentNameType *
T = TL.getTypePtr();
7674 NestedNameSpecifierLoc QualifierLoc
7675 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
7680 = getDerived().RebuildDependentNameType(
T->getKeyword(),
7681 TL.getElaboratedKeywordLoc(),
7689 if (
const ElaboratedType* ElabT =
Result->getAs<ElaboratedType>()) {
7690 QualType NamedT = ElabT->getNamedType();
7691 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
7693 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(
Result);
7694 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7695 NewTL.setQualifierLoc(QualifierLoc);
7697 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(
Result);
7698 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7699 NewTL.setQualifierLoc(QualifierLoc);
7700 NewTL.setNameLoc(TL.getNameLoc());
7705template<
typename Derived>
7708 DependentTemplateSpecializationTypeLoc TL) {
7709 NestedNameSpecifierLoc QualifierLoc;
7710 if (TL.getQualifierLoc()) {
7712 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
7718 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
7721template<
typename Derived>
7734 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7739 QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
7747 QualType NamedT = ElabT->getNamedType();
7756 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7763 }
else if (isa<DependentTemplateSpecializationType>(
Result)) {
7772 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7781 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7787template<
typename Derived>
7796 if (getDerived().AlwaysRebuild() ||
7798 Result = getDerived().RebuildPackExpansionType(Pattern,
7806 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(
Result);
7811template<
typename Derived>
7813TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
7814 ObjCInterfaceTypeLoc TL) {
7816 TLB.pushFullCopy(TL);
7817 return TL.getType();
7820template<
typename Derived>
7822TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
7823 ObjCTypeParamTypeLoc TL) {
7824 const ObjCTypeParamType *
T = TL.getTypePtr();
7825 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
7826 getDerived().TransformDecl(
T->getDecl()->getLocation(),
T->getDecl()));
7830 QualType
Result = TL.getType();
7831 if (getDerived().AlwaysRebuild() ||
7832 OTP !=
T->getDecl()) {
7833 Result = getDerived().RebuildObjCTypeParamType(
7834 OTP, TL.getProtocolLAngleLoc(),
7835 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7836 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
7841 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(
Result);
7842 if (TL.getNumProtocols()) {
7843 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
7844 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
7845 NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
7846 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
7851template<
typename Derived>
7853TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
7854 ObjCObjectTypeLoc TL) {
7856 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
7857 if (BaseType.isNull())
7860 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
7864 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
7865 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
7866 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
7867 QualType TypeArg = TypeArgInfo->getType();
7868 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
7872 const auto *PackExpansion = PackExpansionLoc.getType()
7873 ->castAs<PackExpansionType>();
7877 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
7881 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
7882 bool Expand =
false;
7883 bool RetainExpansion =
false;
7884 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
7885 if (getDerived().TryExpandParameterPacks(
7886 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
7887 Unexpanded, Expand, RetainExpansion, NumExpansions))
7894 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
7896 TypeLocBuilder TypeArgBuilder;
7897 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
7898 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
7900 if (NewPatternType.isNull())
7904 NewPatternType, NumExpansions);
7905 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
7906 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
7907 NewTypeArgInfos.push_back(
7908 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewExpansionType));
7914 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
7915 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
7917 TypeLocBuilder TypeArgBuilder;
7918 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
7920 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
7922 if (NewTypeArg.isNull())
7925 NewTypeArgInfos.push_back(
7926 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewTypeArg));
7932 TypeLocBuilder TypeArgBuilder;
7933 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
7934 QualType NewTypeArg =
7935 getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
7936 if (NewTypeArg.isNull())
7940 if (NewTypeArg == TypeArg) {
7941 NewTypeArgInfos.push_back(TypeArgInfo);
7945 NewTypeArgInfos.push_back(
7946 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewTypeArg));
7950 QualType
Result = TL.getType();
7951 if (getDerived().AlwaysRebuild() || AnyChanged) {
7953 Result = getDerived().RebuildObjCObjectType(
7954 BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
7955 TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
7956 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7957 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
7963 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(
Result);
7964 NewT.setHasBaseTypeAsWritten(
true);
7965 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
7966 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
7967 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
7968 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
7969 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
7970 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
7971 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
7972 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
7976template<
typename Derived>
7978TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
7979 ObjCObjectPointerTypeLoc TL) {
7980 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
7981 if (PointeeType.isNull())
7984 QualType
Result = TL.getType();
7985 if (getDerived().AlwaysRebuild() ||
7986 PointeeType != TL.getPointeeLoc().getType()) {
7987 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
7993 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(
Result);
7994 NewT.setStarLoc(TL.getStarLoc());
8001template<
typename Derived>
8003TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
8007template<
typename Derived>
8010 return getDerived().TransformCompoundStmt(S,
false);
8013template<
typename Derived>
8019 if (S->hasStoredFPFeatures())
8020 getSema().resetFPOptions(
8021 S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts()));
8024 bool SubStmtInvalid =
false;
8025 bool SubStmtChanged =
false;
8027 for (
auto *B : S->body()) {
8029 B, IsStmtExpr && B ==
ExprResult ? SDK_StmtExprResult : SDK_Discarded);
8031 if (
Result.isInvalid()) {
8034 if (isa<DeclStmt>(B))
8038 SubStmtInvalid =
true;
8042 SubStmtChanged = SubStmtChanged ||
Result.get() != B;
8043 Statements.push_back(
Result.getAs<Stmt>());
8049 if (!getDerived().AlwaysRebuild() &&
8053 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
8059template<
typename Derived>
8061TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
8068 LHS = getDerived().TransformExpr(S->getLHS());
8070 if (LHS.isInvalid())
8074 RHS = getDerived().TransformExpr(S->getRHS());
8076 if (RHS.isInvalid())
8083 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
8085 S->getEllipsisLoc(),
8088 if (Case.isInvalid())
8093 getDerived().TransformStmt(S->getSubStmt());
8094 if (SubStmt.isInvalid())
8098 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
8101template <
typename Derived>
8102StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
8105 getDerived().TransformStmt(S->getSubStmt());
8106 if (SubStmt.isInvalid())
8110 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
8114template<
typename Derived>
8116TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
8117 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8118 if (SubStmt.isInvalid())
8121 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
8129 if (LD == S->getDecl())
8130 S->getDecl()->setStmt(
nullptr);
8133 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
8134 cast<LabelDecl>(LD), SourceLocation(),
8138template <
typename Derived>
8147 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
8148#include "clang/Basic/AttrList.inc"
8153template <
typename Derived>
8164 return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R));
8165#include "clang/Basic/AttrList.inc"
8167 return TransformAttr(R);
8170template <
typename Derived>
8173 StmtDiscardKind SDK) {
8174 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8178 bool AttrsChanged =
false;
8182 for (
const auto *I : S->getAttrs()) {
8184 getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.
get(), I);
8185 AttrsChanged |= (I != R);
8190 if (SubStmt.
get() == S->getSubStmt() && !AttrsChanged)
8198 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
8202template<
typename Derived>
8204TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
8207 if (
Init.isInvalid())
8210 Sema::ConditionResult Cond;
8211 if (!S->isConsteval()) {
8213 Cond = getDerived().TransformCondition(
8214 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
8217 if (Cond.isInvalid())
8222 std::optional<bool> ConstexprConditionValue;
8223 if (S->isConstexpr())
8224 ConstexprConditionValue = Cond.getKnownValue();
8228 if (!ConstexprConditionValue || *ConstexprConditionValue) {
8229 EnterExpressionEvaluationContext Ctx(
8232 S->isNonNegatedConsteval());
8234 Then = getDerived().TransformStmt(S->getThen());
8235 if (Then.isInvalid())
8241 Then =
new (getSema().Context)
8242 CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc());
8247 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
8248 EnterExpressionEvaluationContext Ctx(
8251 S->isNegatedConsteval());
8253 Else = getDerived().TransformStmt(S->getElse());
8254 if (Else.isInvalid())
8256 }
else if (S->getElse() && ConstexprConditionValue &&
8257 *ConstexprConditionValue) {
8261 Else =
new (getSema().Context)
8262 CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc());
8265 if (!getDerived().AlwaysRebuild() &&
8266 Init.get() == S->getInit() &&
8267 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8268 Then.get() == S->getThen() &&
8269 Else.get() == S->getElse())
8272 return getDerived().RebuildIfStmt(
8273 S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
8274 S->getRParenLoc(),
Init.get(), Then.get(), S->getElseLoc(), Else.get());
8277template<
typename Derived>
8279TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
8282 if (
Init.isInvalid())
8286 Sema::ConditionResult Cond = getDerived().TransformCondition(
8287 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
8289 if (Cond.isInvalid())
8294 getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
8295 Init.get(), Cond, S->getRParenLoc());
8300 StmtResult Body = getDerived().TransformStmt(S->getBody());
8301 if (Body.isInvalid())
8305 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(),
Switch.get(),
8309template<
typename Derived>
8311TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
8313 Sema::ConditionResult Cond = getDerived().TransformCondition(
8314 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
8316 if (Cond.isInvalid())
8321 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8325 StmtResult Body = getDerived().TransformStmt(S->getBody());
8326 if (Body.isInvalid())
8329 if (!getDerived().AlwaysRebuild() &&
8330 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8331 Body.get() == S->getBody())
8334 return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
8335 Cond, S->getRParenLoc(), Body.get());
8338template<
typename Derived>
8340TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
8343 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8347 StmtResult Body = getDerived().TransformStmt(S->getBody());
8348 if (Body.isInvalid())
8352 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8353 if (Cond.isInvalid())
8356 if (!getDerived().AlwaysRebuild() &&
8357 Cond.get() == S->getCond() &&
8358 Body.get() == S->getBody())
8361 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
8362 S->getWhileLoc(), Cond.get(),
8366template<
typename Derived>
8368TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
8369 if (getSema().getLangOpts().OpenMP)
8370 getSema().OpenMP().startOpenMPLoop();
8374 if (
Init.isInvalid())
8379 if (getSema().getLangOpts().OpenMP &&
Init.isUsable())
8380 getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(),
8384 Sema::ConditionResult Cond = getDerived().TransformCondition(
8385 S->getForLoc(), S->getConditionVariable(), S->getCond(),
8387 if (Cond.isInvalid())
8392 if (
Inc.isInvalid())
8395 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(
Inc.get()));
8396 if (S->getInc() && !FullInc.get())
8401 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8403 S->getBeginLoc(), S->getInit(),
Init.get(), S->getCond(),
8404 Cond.get().second, S->getInc(),
Inc.get());
8407 StmtResult Body = getDerived().TransformStmt(S->getBody());
8408 if (Body.isInvalid())
8413 if (!getDerived().AlwaysRebuild() &&
8414 Init.get() == S->getInit() &&
8415 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8416 Inc.get() == S->getInc() &&
8417 Body.get() == S->getBody())
8420 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
8421 Init.get(), Cond, FullInc,
8422 S->getRParenLoc(), Body.get());
8425template<
typename Derived>
8427TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
8428 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
8434 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
8435 cast<LabelDecl>(LD));
8438template<
typename Derived>
8440TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
8446 if (!getDerived().AlwaysRebuild() &&
8447 Target.get() == S->getTarget())
8450 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
8454template<
typename Derived>
8456TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
8460template<
typename Derived>
8462TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
8466template<
typename Derived>
8468TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
8476 return getDerived().RebuildReturnStmt(S->getReturnLoc(),
Result.get());
8479template<
typename Derived>
8481TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
8482 bool DeclChanged =
false;
8484 LambdaScopeInfo *LSI = getSema().getCurLambda();
8485 for (
auto *
D : S->decls()) {
8490 if (Transformed !=
D)
8494 if (
auto *TD = dyn_cast<TypeDecl>(Transformed))
8495 LSI->ContainsUnexpandedParameterPack |=
8498 .getTypeDeclType(TD)
8500 ->containsUnexpandedParameterPack();
8502 if (
auto *VD = dyn_cast<VarDecl>(Transformed))
8503 LSI->ContainsUnexpandedParameterPack |=
8504 VD->getType()->containsUnexpandedParameterPack();
8507 Decls.push_back(Transformed);
8510 if (!getDerived().AlwaysRebuild() && !DeclChanged)
8513 return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
8516template<
typename Derived>
8518TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
8527 bool ExprsChanged =
false;
8530 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; ++I) {
8531 Names.push_back(S->getOutputIdentifier(I));
8534 Constraints.push_back(S->getOutputConstraintLiteral(I));
8537 Expr *OutputExpr = S->getOutputExpr(I);
8542 ExprsChanged |=
Result.get() != OutputExpr;
8544 Exprs.push_back(
Result.get());
8548 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; ++I) {
8549 Names.push_back(S->getInputIdentifier(I));
8552 Constraints.push_back(S->getInputConstraintLiteral(I));
8555 Expr *InputExpr = S->getInputExpr(I);
8560 ExprsChanged |=
Result.get() != InputExpr;
8562 Exprs.push_back(
Result.get());
8566 for (
unsigned I = 0,
E = S->getNumLabels(); I !=
E; ++I) {
8567 Names.push_back(S->getLabelIdentifier(I));
8572 ExprsChanged |=
Result.get() != S->getLabelExpr(I);
8573 Exprs.push_back(
Result.get());
8575 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
8579 for (
unsigned I = 0,
E = S->getNumClobbers(); I !=
E; ++I)
8580 Clobbers.push_back(S->getClobberStringLiteral(I));
8583 AsmString = S->getAsmString();
8584 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
8585 S->isVolatile(), S->getNumOutputs(),
8586 S->getNumInputs(), Names.data(),
8587 Constraints, Exprs, AsmString.get(),
8588 Clobbers, S->getNumLabels(),
8592template<
typename Derived>
8594TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
8597 bool HadError =
false, HadChange =
false;
8601 TransformedExprs.reserve(SrcExprs.size());
8602 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
8604 if (!
Result.isUsable()) {
8607 HadChange |= (
Result.get() != SrcExprs[i]);
8608 TransformedExprs.push_back(
Result.get());
8613 if (!HadChange && !getDerived().AlwaysRebuild())
8616 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
8617 AsmToks, S->getAsmString(),
8618 S->getNumOutputs(), S->getNumInputs(),
8619 S->getAllConstraints(), S->getClobbers(),
8620 TransformedExprs, S->getEndLoc());
8624template<
typename Derived>
8626TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
8628 auto *FD = cast<FunctionDecl>(SemaRef.
CurContext);
8629 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
8630 ScopeInfo->NeedsCoroutineSuspends &&
8631 ScopeInfo->CoroutineSuspends.first ==
nullptr &&
8632 ScopeInfo->CoroutineSuspends.second ==
nullptr &&
8633 "expected clean scope info");
8637 ScopeInfo->setNeedsCoroutineSuspends(
false);
8650 getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
8651 ScopeInfo->CoroutinePromise = Promise;
8656 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
8657 if (InitSuspend.isInvalid())
8660 getDerived().TransformStmt(S->getFinalSuspendStmt());
8661 if (FinalSuspend.isInvalid() ||
8664 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
8665 assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));
8667 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
8668 if (BodyRes.isInvalid())
8671 CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
8672 if (Builder.isInvalid())
8675 Expr *ReturnObject = S->getReturnValueInit();
8676 assert(ReturnObject &&
"the return object is expected to be valid");
8677 ExprResult Res = getDerived().TransformInitializer(ReturnObject,
8679 if (Res.isInvalid())
8681 Builder.ReturnValue = Res.get();
8686 if (S->hasDependentPromiseType()) {
8689 if (!Promise->getType()->isDependentType()) {
8690 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
8691 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
8692 "these nodes should not have been built yet");
8693 if (!Builder.buildDependentStatements())
8697 if (
auto *OnFallthrough = S->getFallthroughHandler()) {
8698 StmtResult Res = getDerived().TransformStmt(OnFallthrough);
8699 if (Res.isInvalid())
8701 Builder.OnFallthrough = Res.get();
8704 if (
auto *OnException = S->getExceptionHandler()) {
8705 StmtResult Res = getDerived().TransformStmt(OnException);
8706 if (Res.isInvalid())
8708 Builder.OnException = Res.get();
8711 if (
auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
8712 StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
8713 if (Res.isInvalid())
8715 Builder.ReturnStmtOnAllocFailure = Res.get();
8719 assert(S->getAllocate() && S->getDeallocate() &&
8720 "allocation and deallocation calls must already be built");
8721 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
8722 if (AllocRes.isInvalid())
8724 Builder.Allocate = AllocRes.get();
8726 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
8727 if (DeallocRes.isInvalid())
8729 Builder.Deallocate = DeallocRes.get();
8731 if (
auto *ResultDecl = S->getResultDecl()) {
8732 StmtResult Res = getDerived().TransformStmt(ResultDecl);
8733 if (Res.isInvalid())
8735 Builder.ResultDecl = Res.get();
8738 if (
auto *ReturnStmt = S->getReturnStmt()) {
8739 StmtResult Res = getDerived().TransformStmt(ReturnStmt);
8740 if (Res.isInvalid())
8742 Builder.ReturnStmt = Res.get();
8746 return getDerived().RebuildCoroutineBodyStmt(Builder);
8749template<
typename Derived>
8751TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
8759 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(),
Result.get(),
8763template <
typename Derived>
8764ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *
E) {
8776 ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
8777 getSema().getCurScope(),
E->getKeywordLoc());
8781 return getDerived().RebuildCoawaitExpr(
8783 cast<UnresolvedLookupExpr>(Lookup.get()),
E->isImplicit());
8786template <
typename Derived>
8788TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *
E) {
8789 ExprResult OperandResult = getDerived().TransformInitializer(
E->getOperand(),
8791 if (OperandResult.isInvalid())
8794 ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
8795 E->getOperatorCoawaitLookup());
8797 if (LookupResult.isInvalid())
8802 return getDerived().RebuildDependentCoawaitExpr(
8803 E->getKeywordLoc(), OperandResult.get(),
8804 cast<UnresolvedLookupExpr>(LookupResult.get()));
8807template<
typename Derived>
8809TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *
E) {
8817 return getDerived().RebuildCoyieldExpr(
E->getKeywordLoc(),
Result.get());
8822template<
typename Derived>
8824TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
8826 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
8827 if (TryBody.isInvalid())
8831 bool AnyCatchChanged =
false;
8833 for (
unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
8834 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
8835 if (Catch.isInvalid())
8837 if (Catch.get() != S->getCatchStmt(I))
8838 AnyCatchChanged =
true;
8839 CatchStmts.push_back(Catch.get());
8844 if (S->getFinallyStmt()) {
8845 Finally = getDerived().TransformStmt(S->getFinallyStmt());
8846 if (Finally.isInvalid())
8851 if (!getDerived().AlwaysRebuild() &&
8852 TryBody.get() == S->getTryBody() &&
8854 Finally.get() == S->getFinallyStmt())
8858 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
8859 CatchStmts, Finally.get());
8862template<
typename Derived>
8864TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
8866 VarDecl *Var =
nullptr;
8867 if (VarDecl *FromVar = S->getCatchParamDecl()) {
8868 TypeSourceInfo *TSInfo =
nullptr;
8869 if (FromVar->getTypeSourceInfo()) {
8870 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
8877 T = TSInfo->getType();
8879 T = getDerived().TransformType(FromVar->getType());
8884 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo,
T);
8889 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
8890 if (Body.isInvalid())
8893 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
8898template<
typename Derived>
8900TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
8902 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
8903 if (Body.isInvalid())
8907 if (!getDerived().AlwaysRebuild() &&
8908 Body.get() == S->getFinallyBody())
8912 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
8916template<
typename Derived>
8918TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
8920 if (S->getThrowExpr()) {
8921 Operand = getDerived().TransformExpr(S->getThrowExpr());
8926 if (!getDerived().AlwaysRebuild() &&
8927 Operand.get() == S->getThrowExpr())
8930 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(),
Operand.get());
8933template<
typename Derived>
8935TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
8936 ObjCAtSynchronizedStmt *S) {
8942 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
8948 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
8949 if (Body.isInvalid())
8953 if (!getDerived().AlwaysRebuild() &&
8954 Object.get() == S->getSynchExpr() &&
8955 Body.get() == S->getSynchBody())
8959 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
8960 Object.get(), Body.get());
8963template<
typename Derived>
8965TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
8966 ObjCAutoreleasePoolStmt *S) {
8968 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
8969 if (Body.isInvalid())
8973 if (!getDerived().AlwaysRebuild() &&
8974 Body.get() == S->getSubStmt())
8978 return getDerived().RebuildObjCAutoreleasePoolStmt(
8979 S->getAtLoc(), Body.get());
8982template<
typename Derived>
8984TreeTransform<Derived>::TransformObjCForCollectionStmt(
8985 ObjCForCollectionStmt *S) {
8988 getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
8989 if (Element.isInvalid())
8993 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
8994 if (Collection.isInvalid())
8998 StmtResult Body = getDerived().TransformStmt(S->getBody());
8999 if (Body.isInvalid())
9003 if (!getDerived().AlwaysRebuild() &&
9004 Element.get() == S->getElement() &&
9005 Collection.get() == S->getCollection() &&
9006 Body.get() == S->getBody())
9010 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
9017template <
typename Derived>
9018StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
9020 VarDecl *Var =
nullptr;
9021 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
9023 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
9027 Var = getDerived().RebuildExceptionDecl(
9028 ExceptionDecl,
T, ExceptionDecl->getInnerLocStart(),
9029 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
9030 if (!Var || Var->isInvalidDecl())
9035 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
9036 if (Handler.isInvalid())
9039 if (!getDerived().AlwaysRebuild() && !Var &&
9040 Handler.get() == S->getHandlerBlock())
9043 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
9046template <
typename Derived>
9047StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
9049 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9050 if (TryBlock.isInvalid())
9054 bool HandlerChanged =
false;
9056 for (
unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
9057 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
9058 if (Handler.isInvalid())
9061 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
9062 Handlers.push_back(Handler.getAs<Stmt>());
9065 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9069 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
9073template<
typename Derived>
9075TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
9076 EnterExpressionEvaluationContext ForRangeInitContext(
9084 auto &LastRecord = getSema().currentEvaluationContext();
9085 LastRecord.InLifetimeExtendingContext =
true;
9086 LastRecord.RebuildDefaultArgOrDefaultInit =
true;
9089 S->getInit() ? getDerived().TransformStmt(S->getInit()) :
StmtResult();
9090 if (
Init.isInvalid())
9099 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty());
9100 auto ForRangeLifetimeExtendTemps =
9101 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps;
9106 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
9107 if (End.isInvalid())
9110 ExprResult Cond = getDerived().TransformExpr(S->getCond());
9111 if (Cond.isInvalid())
9115 if (Cond.isInvalid())
9121 if (
Inc.isInvalid())
9126 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
9127 if (LoopVar.isInvalid())
9131 if (getDerived().AlwaysRebuild() ||
9132 Init.get() != S->getInit() ||
9133 Range.get() != S->getRangeStmt() ||
9134 Begin.get() != S->getBeginStmt() ||
9135 End.get() != S->getEndStmt() ||
9136 Cond.get() != S->getCond() ||
9137 Inc.get() != S->getInc() ||
9138 LoopVar.get() != S->getLoopVarStmt()) {
9139 NewStmt = getDerived().RebuildCXXForRangeStmt(
9140 S->getForLoc(), S->getCoawaitLoc(),
Init.get(), S->getColonLoc(),
9142 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9143 if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
9146 cast<DeclStmt>(LoopVar.get())->getSingleDecl());
9153 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
9156 StmtResult Body = getDerived().TransformStmt(S->getBody());
9157 if (Body.isInvalid())
9164 if (Body.get() != S->getBody() && NewStmt.get() == S) {
9165 NewStmt = getDerived().RebuildCXXForRangeStmt(
9166 S->getForLoc(), S->getCoawaitLoc(),
Init.get(), S->getColonLoc(),
9168 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9169 if (NewStmt.isInvalid())
9173 if (NewStmt.get() == S)
9176 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
9179template<
typename Derived>
9181TreeTransform<Derived>::TransformMSDependentExistsStmt(
9182 MSDependentExistsStmt *S) {
9184 NestedNameSpecifierLoc QualifierLoc;
9185 if (S->getQualifierLoc()) {
9187 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
9193 DeclarationNameInfo NameInfo = S->getNameInfo();
9194 if (NameInfo.getName()) {
9195 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9196 if (!NameInfo.getName())
9201 if (!getDerived().AlwaysRebuild() &&
9202 QualifierLoc == S->getQualifierLoc() &&
9203 NameInfo.getName() == S->getNameInfo().getName())
9208 SS.Adopt(QualifierLoc);
9210 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
9212 if (S->isIfExists())
9215 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9218 if (S->isIfNotExists())
9221 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9232 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
9233 if (SubStmt.isInvalid())
9241 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
9248template<
typename Derived>
9250TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *
E) {
9251 NestedNameSpecifierLoc QualifierLoc;
9252 if (
E->getQualifierLoc()) {
9254 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
9259 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
9260 getDerived().TransformDecl(
E->getMemberLoc(),
E->getPropertyDecl()));
9265 if (
Base.isInvalid())
9269 MSPropertyRefExpr(
Base.get(), PD,
E->isArrow(),
9271 QualifierLoc,
E->getMemberLoc());
9274template <
typename Derived>
9275ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
9276 MSPropertySubscriptExpr *
E) {
9277 auto BaseRes = getDerived().TransformExpr(
E->getBase());
9278 if (BaseRes.isInvalid())
9280 auto IdxRes = getDerived().TransformExpr(
E->getIdx());
9281 if (IdxRes.isInvalid())
9284 if (!getDerived().AlwaysRebuild() &&
9285 BaseRes.get() ==
E->getBase() &&
9286 IdxRes.get() ==
E->getIdx())
9289 return getDerived().RebuildArraySubscriptExpr(
9290 BaseRes.get(), SourceLocation(), IdxRes.get(),
E->getRBracketLoc());
9293template <
typename Derived>
9294StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
9295 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9296 if (TryBlock.isInvalid())
9299 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
9300 if (Handler.isInvalid())
9303 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9304 Handler.get() == S->getHandler())
9307 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
9308 TryBlock.get(), Handler.get());
9311template <
typename Derived>
9312StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
9314 if (
Block.isInvalid())
9317 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(),
Block.get());
9320template <
typename Derived>
9321StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
9322 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
9323 if (FilterExpr.isInvalid())
9327 if (
Block.isInvalid())
9330 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
9334template <
typename Derived>
9336 if (isa<SEHFinallyStmt>(Handler))
9337 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
9339 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
9342template<
typename Derived>
9352template <
typename Derived>
9354TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) {
9358 return getDerived().TransformStmt(L->getLoopStmt());
9361template <
typename Derived>
9368 TClauses.reserve(Clauses.size());
9372 getDerived().getSema().OpenMP().StartOpenMPClause((*I)->getClauseKind());
9373 OMPClause *Clause = getDerived().TransformOMPClause(*I);
9374 getDerived().getSema().OpenMP().EndOpenMPClause();
9376 TClauses.push_back(Clause);
9378 TClauses.push_back(
nullptr);
9382 if (
D->hasAssociatedStmt() &&
D->getAssociatedStmt()) {
9383 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
9384 D->getDirectiveKind(),
9390 if (
D->getDirectiveKind() == OMPD_atomic ||
9391 D->getDirectiveKind() == OMPD_critical ||
9392 D->getDirectiveKind() == OMPD_section ||
9393 D->getDirectiveKind() == OMPD_master)
9394 CS =
D->getAssociatedStmt();
9396 CS =
D->getRawStmt();
9397 Body = getDerived().TransformStmt(CS);
9399 getSema().getLangOpts().OpenMPIRBuilder)
9400 Body = getDerived().RebuildOMPCanonicalLoop(Body.
get());
9403 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
9408 if (TClauses.size() != Clauses.size()) {
9414 if (
D->getDirectiveKind() == OMPD_critical) {
9415 DirName = cast<OMPCriticalDirective>(
D)->getDirectiveName();
9416 DirName = getDerived().TransformDeclarationNameInfo(DirName);
9419 if (
D->getDirectiveKind() == OMPD_cancellation_point) {
9420 CancelRegion = cast<OMPCancellationPointDirective>(
D)->getCancelRegion();
9421 }
else if (
D->getDirectiveKind() == OMPD_cancel) {
9422 CancelRegion = cast<OMPCancelDirective>(
D)->getCancelRegion();
9425 return getDerived().RebuildOMPExecutableDirective(
9426 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
9435template <
typename Derived>
9442 TClauses.reserve(Clauses.size());
9445 getDerived().getSema().OpenMP().StartOpenMPClause(
C->getClauseKind());
9446 OMPClause *Clause = getDerived().TransformOMPClause(
C);
9447 getDerived().getSema().OpenMP().EndOpenMPClause();
9449 TClauses.push_back(Clause);
9451 TClauses.push_back(
nullptr);
9455 if (
D->hasAssociatedStmt() &&
D->getAssociatedStmt()) {
9456 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
9457 D->getDirectiveKind(),
9462 assert(
D->getDirectiveKind() == OMPD_assume &&
9463 "Unexpected informational directive");
9464 Stmt *CS =
D->getAssociatedStmt();
9465 Body = getDerived().TransformStmt(CS);
9468 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
9472 if (TClauses.size() != Clauses.size())
9477 return getDerived().RebuildOMPInformationalDirective(
9478 D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.
get(),
9482template <
typename Derived>
9487 << getOpenMPDirectiveName(
D->getDirectiveKind());
9491template <
typename Derived>
9493TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *
D) {
9494 DeclarationNameInfo DirName;
9495 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9497 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9498 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9502template <
typename Derived>
9504TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *
D) {
9505 DeclarationNameInfo DirName;
9506 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9508 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9509 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9513template <
typename Derived>
9515TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *
D) {
9516 DeclarationNameInfo DirName;
9517 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9519 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9520 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9524template <
typename Derived>
9526TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *
D) {
9527 DeclarationNameInfo DirName;
9528 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9530 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9531 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9535template <
typename Derived>
9537TreeTransform<Derived>::TransformOMPReverseDirective(OMPReverseDirective *
D) {
9538 DeclarationNameInfo DirName;
9539 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9541 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9542 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9546template <
typename Derived>
9547StmtResult TreeTransform<Derived>::TransformOMPInterchangeDirective(
9548 OMPInterchangeDirective *
D) {
9549 DeclarationNameInfo DirName;
9550 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9552 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9553 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9557template <
typename Derived>
9559TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *
D) {
9560 DeclarationNameInfo DirName;
9561 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9563 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9564 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9568template <
typename Derived>
9570TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *
D) {
9571 DeclarationNameInfo DirName;
9572 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9574 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9575 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9579template <
typename Derived>
9581TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *
D) {
9582 DeclarationNameInfo DirName;
9583 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9585 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9586 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9590template <
typename Derived>
9592TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *
D) {
9593 DeclarationNameInfo DirName;
9594 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9596 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9597 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9601template <
typename Derived>
9603TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *
D) {
9604 DeclarationNameInfo DirName;
9605 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9607 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9608 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9612template <
typename Derived>
9614TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *
D) {
9615 DeclarationNameInfo DirName;
9616 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9618 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9619 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9623template <
typename Derived>
9625TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *
D) {
9626 DeclarationNameInfo DirName;
9627 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9629 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9630 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9634template <
typename Derived>
9636TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *
D) {
9637 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9638 OMPD_critical,
D->getDirectiveName(),
nullptr,
D->
getBeginLoc());
9639 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9640 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9644template <
typename Derived>
9645StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
9646 OMPParallelForDirective *
D) {
9647 DeclarationNameInfo DirName;
9648 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9649 OMPD_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
9650 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9651 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9655template <
typename Derived>
9656StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
9657 OMPParallelForSimdDirective *
D) {
9658 DeclarationNameInfo DirName;
9659 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9660 OMPD_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
9661 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9662 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9666template <
typename Derived>
9667StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
9668 OMPParallelMasterDirective *
D) {
9669 DeclarationNameInfo DirName;
9670 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9671 OMPD_parallel_master, DirName,
nullptr,
D->
getBeginLoc());
9672 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9673 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9677template <
typename Derived>
9678StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective(
9679 OMPParallelMaskedDirective *
D) {
9680 DeclarationNameInfo DirName;
9681 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9682 OMPD_parallel_masked, DirName,
nullptr,
D->
getBeginLoc());
9683 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9684 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9688template <
typename Derived>
9689StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
9690 OMPParallelSectionsDirective *
D) {
9691 DeclarationNameInfo DirName;
9692 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9693 OMPD_parallel_sections, DirName,
nullptr,
D->
getBeginLoc());
9694 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9695 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9699template <
typename Derived>
9701TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *
D) {
9702 DeclarationNameInfo DirName;
9703 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9705 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9706 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9710template <
typename Derived>
9711StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
9712 OMPTaskyieldDirective *
D) {
9713 DeclarationNameInfo DirName;
9714 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9716 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9717 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9721template <
typename Derived>
9723TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *
D) {
9724 DeclarationNameInfo DirName;
9725 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9727 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9728 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9732template <
typename Derived>
9734TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *
D) {
9735 DeclarationNameInfo DirName;
9736 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9738 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9739 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9743template <
typename Derived>
9745TreeTransform<Derived>::TransformOMPAssumeDirective(OMPAssumeDirective *
D) {
9746 DeclarationNameInfo DirName;
9747 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9749 StmtResult Res = getDerived().TransformOMPInformationalDirective(
D);
9750 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9754template <
typename Derived>
9756TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *
D) {
9757 DeclarationNameInfo DirName;
9758 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9760 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9761 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9765template <
typename Derived>
9766StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
9767 OMPTaskgroupDirective *
D) {
9768 DeclarationNameInfo DirName;
9769 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9771 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9772 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9776template <
typename Derived>
9778TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *
D) {
9779 DeclarationNameInfo DirName;
9780 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9782 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9783 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9787template <
typename Derived>
9789TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *
D) {
9790 DeclarationNameInfo DirName;
9791 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9793 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9794 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9798template <
typename Derived>
9800TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *
D) {
9801 DeclarationNameInfo DirName;
9802 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9804 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9805 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9809template <
typename Derived>
9811TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *
D) {
9812 DeclarationNameInfo DirName;
9813 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9815 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9816 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9820template <
typename Derived>
9822TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *
D) {
9823 DeclarationNameInfo DirName;
9824 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9826 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9827 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9831template <
typename Derived>
9833TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *
D) {
9834 DeclarationNameInfo DirName;
9835 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9837 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9838 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9842template <
typename Derived>
9843StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
9844 OMPTargetDataDirective *
D) {
9845 DeclarationNameInfo DirName;
9846 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9848 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9849 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9853template <
typename Derived>
9854StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
9855 OMPTargetEnterDataDirective *
D) {
9856 DeclarationNameInfo DirName;
9857 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9858 OMPD_target_enter_data, DirName,
nullptr,
D->
getBeginLoc());
9859 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9860 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9864template <
typename Derived>
9865StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
9866 OMPTargetExitDataDirective *
D) {
9867 DeclarationNameInfo DirName;
9868 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9869 OMPD_target_exit_data, DirName,
nullptr,
D->
getBeginLoc());
9870 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9871 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9875template <
typename Derived>
9876StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
9877 OMPTargetParallelDirective *
D) {
9878 DeclarationNameInfo DirName;
9879 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9880 OMPD_target_parallel, DirName,
nullptr,
D->
getBeginLoc());
9881 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9882 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9886template <
typename Derived>
9887StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
9888 OMPTargetParallelForDirective *
D) {
9889 DeclarationNameInfo DirName;
9890 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9891 OMPD_target_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
9892 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9893 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9897template <
typename Derived>
9898StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
9899 OMPTargetUpdateDirective *
D) {
9900 DeclarationNameInfo DirName;
9901 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9902 OMPD_target_update, DirName,
nullptr,
D->
getBeginLoc());
9903 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9904 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9908template <
typename Derived>
9910TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *
D) {
9911 DeclarationNameInfo DirName;
9912 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9914 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9915 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9919template <
typename Derived>
9920StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
9921 OMPCancellationPointDirective *
D) {
9922 DeclarationNameInfo DirName;
9923 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9924 OMPD_cancellation_point, DirName,
nullptr,
D->
getBeginLoc());
9925 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9926 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9930template <
typename Derived>
9932TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *
D) {
9933 DeclarationNameInfo DirName;
9934 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9936 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9937 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9941template <
typename Derived>
9943TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *
D) {
9944 DeclarationNameInfo DirName;
9945 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9947 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9948 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9952template <
typename Derived>
9953StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
9954 OMPTaskLoopSimdDirective *
D) {
9955 DeclarationNameInfo DirName;
9956 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9957 OMPD_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
9958 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9959 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9963template <
typename Derived>
9964StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
9965 OMPMasterTaskLoopDirective *
D) {
9966 DeclarationNameInfo DirName;
9967 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9968 OMPD_master_taskloop, DirName,
nullptr,
D->
getBeginLoc());
9969 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9970 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9974template <
typename Derived>
9975StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective(
9976 OMPMaskedTaskLoopDirective *
D) {
9977 DeclarationNameInfo DirName;
9978 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9979 OMPD_masked_taskloop, DirName,
nullptr,
D->
getBeginLoc());
9980 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9981 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9985template <
typename Derived>
9986StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
9987 OMPMasterTaskLoopSimdDirective *
D) {
9988 DeclarationNameInfo DirName;
9989 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9990 OMPD_master_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
9991 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9992 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9996template <
typename Derived>
9997StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
9998 OMPMaskedTaskLoopSimdDirective *
D) {
9999 DeclarationNameInfo DirName;
10000 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10001 OMPD_masked_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
10002 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10003 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10007template <
typename Derived>
10008StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
10009 OMPParallelMasterTaskLoopDirective *
D) {
10010 DeclarationNameInfo DirName;
10011 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10012 OMPD_parallel_master_taskloop, DirName,
nullptr,
D->
getBeginLoc());
10013 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10014 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10018template <
typename Derived>
10019StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective(
10020 OMPParallelMaskedTaskLoopDirective *
D) {
10021 DeclarationNameInfo DirName;
10022 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10023 OMPD_parallel_masked_taskloop, DirName,
nullptr,
D->
getBeginLoc());
10024 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10025 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10029template <
typename Derived>
10031TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
10032 OMPParallelMasterTaskLoopSimdDirective *
D) {
10033 DeclarationNameInfo DirName;
10034 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10035 OMPD_parallel_master_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
10036 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10037 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10041template <
typename Derived>
10043TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective(
10044 OMPParallelMaskedTaskLoopSimdDirective *
D) {
10045 DeclarationNameInfo DirName;
10046 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10047 OMPD_parallel_masked_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
10048 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10049 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10053template <
typename Derived>
10054StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
10055 OMPDistributeDirective *
D) {
10056 DeclarationNameInfo DirName;
10057 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10059 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10060 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10064template <
typename Derived>
10065StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
10066 OMPDistributeParallelForDirective *
D) {
10067 DeclarationNameInfo DirName;
10068 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10069 OMPD_distribute_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
10070 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10071 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10075template <
typename Derived>
10077TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
10078 OMPDistributeParallelForSimdDirective *
D) {
10079 DeclarationNameInfo DirName;
10080 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10081 OMPD_distribute_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
10082 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10083 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10087template <
typename Derived>
10088StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
10089 OMPDistributeSimdDirective *
D) {
10090 DeclarationNameInfo DirName;
10091 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10092 OMPD_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10093 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10094 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10098template <
typename Derived>
10099StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
10100 OMPTargetParallelForSimdDirective *
D) {
10101 DeclarationNameInfo DirName;
10102 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10103 OMPD_target_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
10104 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10105 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10109template <
typename Derived>
10110StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
10111 OMPTargetSimdDirective *
D) {
10112 DeclarationNameInfo DirName;
10113 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10114 OMPD_target_simd, DirName,
nullptr,
D->
getBeginLoc());
10115 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10116 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10120template <
typename Derived>
10121StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
10122 OMPTeamsDistributeDirective *
D) {
10123 DeclarationNameInfo DirName;
10124 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10125 OMPD_teams_distribute, DirName,
nullptr,
D->
getBeginLoc());
10126 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10127 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10131template <
typename Derived>
10132StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
10133 OMPTeamsDistributeSimdDirective *
D) {
10134 DeclarationNameInfo DirName;
10135 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10136 OMPD_teams_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10137 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10138 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10142template <
typename Derived>
10143StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
10144 OMPTeamsDistributeParallelForSimdDirective *
D) {
10145 DeclarationNameInfo DirName;
10146 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10147 OMPD_teams_distribute_parallel_for_simd, DirName,
nullptr,
10149 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10150 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10154template <
typename Derived>
10155StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
10156 OMPTeamsDistributeParallelForDirective *
D) {
10157 DeclarationNameInfo DirName;
10158 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10159 OMPD_teams_distribute_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
10160 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10161 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10165template <
typename Derived>
10166StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
10167 OMPTargetTeamsDirective *
D) {
10168 DeclarationNameInfo DirName;
10169 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10170 OMPD_target_teams, DirName,
nullptr,
D->
getBeginLoc());
10171 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10172 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10176template <
typename Derived>
10177StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
10178 OMPTargetTeamsDistributeDirective *
D) {
10179 DeclarationNameInfo DirName;
10180 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10181 OMPD_target_teams_distribute, DirName,
nullptr,
D->
getBeginLoc());
10182 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10183 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10187template <
typename Derived>
10189TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
10190 OMPTargetTeamsDistributeParallelForDirective *
D) {
10191 DeclarationNameInfo DirName;
10192 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10193 OMPD_target_teams_distribute_parallel_for, DirName,
nullptr,
10195 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10196 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10200template <
typename Derived>
10202 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
10203 OMPTargetTeamsDistributeParallelForSimdDirective *
D) {
10204 DeclarationNameInfo DirName;
10205 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10206 OMPD_target_teams_distribute_parallel_for_simd, DirName,
nullptr,
10208 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10209 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10213template <
typename Derived>
10215TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
10216 OMPTargetTeamsDistributeSimdDirective *
D) {
10217 DeclarationNameInfo DirName;
10218 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10219 OMPD_target_teams_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10220 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10221 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10225template <
typename Derived>
10227TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *
D) {
10228 DeclarationNameInfo DirName;
10229 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10231 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10232 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10236template <
typename Derived>
10238TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *
D) {
10239 DeclarationNameInfo DirName;
10240 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10242 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10243 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10247template <
typename Derived>
10249TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *
D) {
10250 DeclarationNameInfo DirName;
10251 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10253 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10254 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10258template <
typename Derived>
10259StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
10260 OMPGenericLoopDirective *
D) {
10261 DeclarationNameInfo DirName;
10262 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10264 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10265 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10269template <
typename Derived>
10270StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective(
10271 OMPTeamsGenericLoopDirective *
D) {
10272 DeclarationNameInfo DirName;
10273 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10275 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10276 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10280template <
typename Derived>
10281StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective(
10282 OMPTargetTeamsGenericLoopDirective *
D) {
10283 DeclarationNameInfo DirName;
10284 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10285 OMPD_target_teams_loop, DirName,
nullptr,
D->
getBeginLoc());
10286 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10287 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10291template <
typename Derived>
10292StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective(
10293 OMPParallelGenericLoopDirective *
D) {
10294 DeclarationNameInfo DirName;
10295 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10296 OMPD_parallel_loop, DirName,
nullptr,
D->
getBeginLoc());
10297 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10298 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10302template <
typename Derived>
10304TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
10305 OMPTargetParallelGenericLoopDirective *
D) {
10306 DeclarationNameInfo DirName;
10307 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10308 OMPD_target_parallel_loop, DirName,
nullptr,
D->
getBeginLoc());
10309 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10310 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10317template <
typename Derived>
10318OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *
C) {
10319 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10320 if (Cond.isInvalid())
10322 return getDerived().RebuildOMPIfClause(
10323 C->getNameModifier(), Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
10324 C->getNameModifierLoc(),
C->getColonLoc(),
C->getEndLoc());
10327template <
typename Derived>
10328OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *
C) {
10329 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10330 if (Cond.isInvalid())
10332 return getDerived().RebuildOMPFinalClause(Cond.get(),
C->getBeginLoc(),
10333 C->getLParenLoc(),
C->getEndLoc());
10336template <
typename Derived>
10338TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *
C) {
10339 ExprResult NumThreads = getDerived().TransformExpr(
C->getNumThreads());
10340 if (NumThreads.isInvalid())
10342 return getDerived().RebuildOMPNumThreadsClause(
10343 NumThreads.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10346template <
typename Derived>
10348TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *
C) {
10349 ExprResult E = getDerived().TransformExpr(
C->getSafelen());
10352 return getDerived().RebuildOMPSafelenClause(
10353 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10356template <
typename Derived>
10358TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *
C) {
10359 ExprResult E = getDerived().TransformExpr(
C->getAllocator());
10362 return getDerived().RebuildOMPAllocatorClause(
10363 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10366template <
typename Derived>
10368TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *
C) {
10369 ExprResult E = getDerived().TransformExpr(
C->getSimdlen());
10372 return getDerived().RebuildOMPSimdlenClause(
10373 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10376template <
typename Derived>
10377OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *
C) {
10379 TransformedSizes.reserve(
C->getNumSizes());
10381 for (Expr *
E :
C->getSizesRefs()) {
10383 TransformedSizes.push_back(
nullptr);
10392 TransformedSizes.push_back(
T.get());
10395 if (!Changed && !getDerived().AlwaysRebuild())
10397 return RebuildOMPSizesClause(TransformedSizes,
C->getBeginLoc(),
10398 C->getLParenLoc(),
C->getEndLoc());
10401template <
typename Derived>
10403TreeTransform<Derived>::TransformOMPPermutationClause(OMPPermutationClause *
C) {
10405 TransformedArgs.reserve(
C->getNumLoops());
10407 for (Expr *
E :
C->getArgsRefs()) {
10409 TransformedArgs.push_back(
nullptr);
10418 TransformedArgs.push_back(
T.get());
10421 if (!Changed && !getDerived().AlwaysRebuild())
10423 return RebuildOMPPermutationClause(TransformedArgs,
C->getBeginLoc(),
10424 C->getLParenLoc(),
C->getEndLoc());
10427template <
typename Derived>
10428OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *
C) {
10429 if (!getDerived().AlwaysRebuild())
10431 return RebuildOMPFullClause(
C->getBeginLoc(),
C->getEndLoc());
10434template <
typename Derived>
10436TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *
C) {
10437 ExprResult T = getDerived().TransformExpr(
C->getFactor());
10440 Expr *Factor =
T.get();
10441 bool Changed = Factor !=
C->getFactor();
10443 if (!Changed && !getDerived().AlwaysRebuild())
10445 return RebuildOMPPartialClause(Factor,
C->getBeginLoc(),
C->getLParenLoc(),
10449template <
typename Derived>
10451TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *
C) {
10452 ExprResult E = getDerived().TransformExpr(
C->getNumForLoops());
10455 return getDerived().RebuildOMPCollapseClause(
10456 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10459template <
typename Derived>
10461TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *
C) {
10462 return getDerived().RebuildOMPDefaultClause(
10463 C->getDefaultKind(),
C->getDefaultKindKwLoc(),
C->getBeginLoc(),
10464 C->getLParenLoc(),
C->getEndLoc());
10467template <
typename Derived>
10469TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *
C) {
10470 return getDerived().RebuildOMPProcBindClause(
10471 C->getProcBindKind(),
C->getProcBindKindKwLoc(),
C->getBeginLoc(),
10472 C->getLParenLoc(),
C->getEndLoc());
10475template <
typename Derived>
10477TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *
C) {
10478 ExprResult E = getDerived().TransformExpr(
C->getChunkSize());
10481 return getDerived().RebuildOMPScheduleClause(
10482 C->getFirstScheduleModifier(),
C->getSecondScheduleModifier(),
10483 C->getScheduleKind(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
10484 C->getFirstScheduleModifierLoc(),
C->getSecondScheduleModifierLoc(),
10485 C->getScheduleKindLoc(),
C->getCommaLoc(),
C->getEndLoc());
10488template <
typename Derived>
10490TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *
C) {
10492 if (
auto *
Num =
C->getNumForLoops()) {
10493 E = getDerived().TransformExpr(
Num);
10497 return getDerived().RebuildOMPOrderedClause(
C->getBeginLoc(),
C->getEndLoc(),
10498 C->getLParenLoc(),
E.get());
10501template <
typename Derived>
10503TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *
C) {
10505 if (Expr *Evt =
C->getEventHandler()) {
10506 E = getDerived().TransformExpr(Evt);
10510 return getDerived().RebuildOMPDetachClause(
E.get(),
C->getBeginLoc(),
10511 C->getLParenLoc(),
C->getEndLoc());
10514template <
typename Derived>
10516TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *
C) {
10521template <
typename Derived>
10523TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *
C) {
10528template <
typename Derived>
10530TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *
C) {
10535template <
typename Derived>
10536OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *
C) {
10541template <
typename Derived>
10542OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *
C) {
10547template <
typename Derived>
10549TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *
C) {
10554template <
typename Derived>
10556TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *
C) {
10561template <
typename Derived>
10563TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *
C) {
10568template <
typename Derived>
10569OMPClause *TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *
C) {
10574template <
typename Derived>
10576TreeTransform<Derived>::TransformOMPAbsentClause(OMPAbsentClause *
C) {
10580template <
typename Derived>
10581OMPClause *TreeTransform<Derived>::TransformOMPHoldsClause(OMPHoldsClause *
C) {
10582 ExprResult E = getDerived().TransformExpr(
C->getExpr());
10585 return getDerived().RebuildOMPHoldsClause(
E.get(),
C->getBeginLoc(),
10586 C->getLParenLoc(),
C->getEndLoc());
10589template <
typename Derived>
10591TreeTransform<Derived>::TransformOMPContainsClause(OMPContainsClause *
C) {
10595template <
typename Derived>
10597TreeTransform<Derived>::TransformOMPNoOpenMPClause(OMPNoOpenMPClause *
C) {
10600template <
typename Derived>
10601OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPRoutinesClause(
10602 OMPNoOpenMPRoutinesClause *
C) {
10605template <
typename Derived>
10606OMPClause *TreeTransform<Derived>::TransformOMPNoParallelismClause(
10607 OMPNoParallelismClause *
C) {
10611template <
typename Derived>
10613TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *
C) {
10618template <
typename Derived>
10620TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *
C) {
10625template <
typename Derived>
10627TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *
C) {
10632template <
typename Derived>
10634TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *
C) {
10639template <
typename Derived>
10641TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *
C) {
10646template <
typename Derived>
10647OMPClause *TreeTransform<Derived>::TransformOMPWeakClause(OMPWeakClause *
C) {
10652template <
typename Derived>
10654TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *
C) {
10659template <
typename Derived>
10660OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *
C) {
10665template <
typename Derived>
10667TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *
C) {
10672template <
typename Derived>
10673OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *
C) {
10674 ExprResult IVR = getDerived().TransformExpr(
C->getInteropVar());
10675 if (IVR.isInvalid())
10678 OMPInteropInfo InteropInfo(
C->getIsTarget(),
C->getIsTargetSync());
10679 InteropInfo.PreferTypes.reserve(
C->varlist_size() - 1);
10680 for (Expr *
E : llvm::drop_begin(
C->varlist())) {
10681 ExprResult ER = getDerived().TransformExpr(cast<Expr>(
E));
10682 if (ER.isInvalid())
10684 InteropInfo.PreferTypes.push_back(ER.get());
10686 return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo,
10687 C->getBeginLoc(),
C->getLParenLoc(),
10688 C->getVarLoc(),
C->getEndLoc());
10691template <
typename Derived>
10692OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *
C) {
10693 ExprResult ER = getDerived().TransformExpr(
C->getInteropVar());
10694 if (ER.isInvalid())
10696 return getDerived().RebuildOMPUseClause(ER.get(),
C->getBeginLoc(),
10697 C->getLParenLoc(),
C->getVarLoc(),
10701template <
typename Derived>
10703TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *
C) {
10705 if (Expr *IV =
C->getInteropVar()) {
10706 ER = getDerived().TransformExpr(IV);
10707 if (ER.isInvalid())
10710 return getDerived().RebuildOMPDestroyClause(ER.get(),
C->getBeginLoc(),
10711 C->getLParenLoc(),
C->getVarLoc(),
10715template <
typename Derived>
10717TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *
C) {
10718 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10719 if (Cond.isInvalid())
10721 return getDerived().RebuildOMPNovariantsClause(
10722 Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10725template <
typename Derived>
10727TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *
C) {
10728 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10729 if (Cond.isInvalid())
10731 return getDerived().RebuildOMPNocontextClause(
10732 Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10735template <
typename Derived>
10737TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *
C) {
10738 ExprResult ThreadID = getDerived().TransformExpr(
C->getThreadID());
10739 if (ThreadID.isInvalid())
10741 return getDerived().RebuildOMPFilterClause(ThreadID.get(),
C->getBeginLoc(),
10742 C->getLParenLoc(),
C->getEndLoc());
10745template <
typename Derived>
10746OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *
C) {
10747 ExprResult E = getDerived().TransformExpr(
C->getAlignment());
10750 return getDerived().RebuildOMPAlignClause(
E.get(),
C->getBeginLoc(),
10751 C->getLParenLoc(),
C->getEndLoc());
10754template <
typename Derived>
10755OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
10756 OMPUnifiedAddressClause *
C) {
10757 llvm_unreachable(
"unified_address clause cannot appear in dependent context");
10760template <
typename Derived>
10761OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
10762 OMPUnifiedSharedMemoryClause *
C) {
10764 "unified_shared_memory clause cannot appear in dependent context");
10767template <
typename Derived>
10768OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
10769 OMPReverseOffloadClause *
C) {
10770 llvm_unreachable(
"reverse_offload clause cannot appear in dependent context");
10773template <
typename Derived>
10774OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
10775 OMPDynamicAllocatorsClause *
C) {
10777 "dynamic_allocators clause cannot appear in dependent context");
10780template <
typename Derived>
10781OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
10782 OMPAtomicDefaultMemOrderClause *
C) {
10784 "atomic_default_mem_order clause cannot appear in dependent context");
10787template <
typename Derived>
10788OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *
C) {
10789 return getDerived().RebuildOMPAtClause(
C->getAtKind(),
C->getAtKindKwLoc(),
10790 C->getBeginLoc(),
C->getLParenLoc(),
10794template <
typename Derived>
10796TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *
C) {
10797 return getDerived().RebuildOMPSeverityClause(
10798 C->getSeverityKind(),
C->getSeverityKindKwLoc(),
C->getBeginLoc(),
10799 C->getLParenLoc(),
C->getEndLoc());
10802template <
typename Derived>
10804TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *
C) {
10805 ExprResult E = getDerived().TransformExpr(
C->getMessageString());
10808 return getDerived().RebuildOMPMessageClause(
10809 C->getMessageString(),
C->getBeginLoc(),
C->getLParenLoc(),
10813template <
typename Derived>
10815TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *
C) {
10817 Vars.reserve(
C->varlist_size());
10818 for (
auto *VE :
C->varlist()) {
10819 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10820 if (EVar.isInvalid())
10822 Vars.push_back(EVar.get());
10824 return getDerived().RebuildOMPPrivateClause(
10825 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10828template <
typename Derived>
10829OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
10830 OMPFirstprivateClause *
C) {
10832 Vars.reserve(
C->varlist_size());
10833 for (
auto *VE :
C->varlist()) {
10834 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10835 if (EVar.isInvalid())
10837 Vars.push_back(EVar.get());
10839 return getDerived().RebuildOMPFirstprivateClause(
10840 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10843template <
typename Derived>
10845TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *
C) {
10847 Vars.reserve(
C->varlist_size());
10848 for (
auto *VE :
C->varlist()) {
10849 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10850 if (EVar.isInvalid())
10852 Vars.push_back(EVar.get());
10854 return getDerived().RebuildOMPLastprivateClause(
10855 Vars,
C->getKind(),
C->getKindLoc(),
C->getColonLoc(),
C->getBeginLoc(),
10856 C->getLParenLoc(),
C->getEndLoc());
10859template <
typename Derived>
10861TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *
C) {
10863 Vars.reserve(
C->varlist_size());
10864 for (
auto *VE :
C->varlist()) {
10865 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10866 if (EVar.isInvalid())
10868 Vars.push_back(EVar.get());
10870 return getDerived().RebuildOMPSharedClause(Vars,
C->getBeginLoc(),
10871 C->getLParenLoc(),
C->getEndLoc());
10874template <
typename Derived>
10876TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *
C) {
10878 Vars.reserve(
C->varlist_size());
10879 for (
auto *VE :
C->varlist()) {
10880 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10881 if (EVar.isInvalid())
10883 Vars.push_back(EVar.get());
10885 CXXScopeSpec ReductionIdScopeSpec;
10886 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10888 DeclarationNameInfo NameInfo =
C->getNameInfo();
10889 if (NameInfo.getName()) {
10890 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10891 if (!NameInfo.getName())
10897 for (
auto *
E :
C->reduction_ops()) {
10900 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10901 UnresolvedSet<8> Decls;
10902 for (
auto *
D : ULE->decls()) {
10904 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10905 Decls.addDecl(InstD, InstD->getAccess());
10909 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
10910 true, Decls.begin(), Decls.end(),
10913 UnresolvedReductions.push_back(
nullptr);
10915 return getDerived().RebuildOMPReductionClause(
10916 Vars,
C->getModifier(),
C->getBeginLoc(),
C->getLParenLoc(),
10917 C->getModifierLoc(),
C->getColonLoc(),
C->getEndLoc(),
10918 ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10921template <
typename Derived>
10922OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
10923 OMPTaskReductionClause *
C) {
10925 Vars.reserve(
C->varlist_size());
10926 for (
auto *VE :
C->varlist()) {
10927 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10928 if (EVar.isInvalid())
10930 Vars.push_back(EVar.get());
10932 CXXScopeSpec ReductionIdScopeSpec;
10933 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10935 DeclarationNameInfo NameInfo =
C->getNameInfo();
10936 if (NameInfo.getName()) {
10937 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10938 if (!NameInfo.getName())
10944 for (
auto *
E :
C->reduction_ops()) {
10947 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10948 UnresolvedSet<8> Decls;
10949 for (
auto *
D : ULE->decls()) {
10951 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10952 Decls.addDecl(InstD, InstD->getAccess());
10956 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
10957 true, Decls.begin(), Decls.end(),
10960 UnresolvedReductions.push_back(
nullptr);
10962 return getDerived().RebuildOMPTaskReductionClause(
10963 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
10964 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10967template <
typename Derived>
10969TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *
C) {
10971 Vars.reserve(
C->varlist_size());
10972 for (
auto *VE :
C->varlist()) {
10973 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10974 if (EVar.isInvalid())
10976 Vars.push_back(EVar.get());
10978 CXXScopeSpec ReductionIdScopeSpec;
10979 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10981 DeclarationNameInfo NameInfo =
C->getNameInfo();
10982 if (NameInfo.getName()) {
10983 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10984 if (!NameInfo.getName())
10990 for (
auto *
E :
C->reduction_ops()) {
10993 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10994 UnresolvedSet<8> Decls;
10995 for (
auto *
D : ULE->decls()) {
10997 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10998 Decls.addDecl(InstD, InstD->getAccess());
11002 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
11003 true, Decls.begin(), Decls.end(),
11006 UnresolvedReductions.push_back(
nullptr);
11008 return getDerived().RebuildOMPInReductionClause(
11009 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
11010 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
11013template <
typename Derived>
11015TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *
C) {
11017 Vars.reserve(
C->varlist_size());
11018 for (
auto *VE :
C->varlist()) {
11019 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11020 if (EVar.isInvalid())
11022 Vars.push_back(EVar.get());
11024 ExprResult Step = getDerived().TransformExpr(
C->getStep());
11025 if (Step.isInvalid())
11027 return getDerived().RebuildOMPLinearClause(
11028 Vars, Step.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getModifier(),
11029 C->getModifierLoc(),
C->getColonLoc(),
C->getStepModifierLoc(),
11033template <
typename Derived>
11035TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *
C) {
11037 Vars.reserve(
C->varlist_size());
11038 for (
auto *VE :
C->varlist()) {
11039 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11040 if (EVar.isInvalid())
11042 Vars.push_back(EVar.get());
11044 ExprResult Alignment = getDerived().TransformExpr(
C->getAlignment());
11045 if (Alignment.isInvalid())
11047 return getDerived().RebuildOMPAlignedClause(
11048 Vars, Alignment.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11049 C->getColonLoc(),
C->getEndLoc());
11052template <
typename Derived>
11054TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *
C) {
11056 Vars.reserve(
C->varlist_size());
11057 for (
auto *VE :
C->varlist()) {
11058 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11059 if (EVar.isInvalid())
11061 Vars.push_back(EVar.get());
11063 return getDerived().RebuildOMPCopyinClause(Vars,
C->getBeginLoc(),
11064 C->getLParenLoc(),
C->getEndLoc());
11067template <
typename Derived>
11069TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *
C) {
11071 Vars.reserve(
C->varlist_size());
11072 for (
auto *VE :
C->varlist()) {
11073 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11074 if (EVar.isInvalid())
11076 Vars.push_back(EVar.get());
11078 return getDerived().RebuildOMPCopyprivateClause(
11079 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11082template <
typename Derived>
11083OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *
C) {
11085 Vars.reserve(
C->varlist_size());
11086 for (
auto *VE :
C->varlist()) {
11087 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11088 if (EVar.isInvalid())
11090 Vars.push_back(EVar.get());
11092 return getDerived().RebuildOMPFlushClause(Vars,
C->getBeginLoc(),
11093 C->getLParenLoc(),
C->getEndLoc());
11096template <
typename Derived>
11098TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *
C) {
11099 ExprResult E = getDerived().TransformExpr(
C->getDepobj());
11102 return getDerived().RebuildOMPDepobjClause(
E.get(),
C->getBeginLoc(),
11103 C->getLParenLoc(),
C->getEndLoc());
11106template <
typename Derived>
11108TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *
C) {
11110 Expr *DepModifier =
C->getModifier();
11112 ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
11113 if (DepModRes.isInvalid())
11115 DepModifier = DepModRes.
get();
11117 Vars.reserve(
C->varlist_size());
11118 for (
auto *VE :
C->varlist()) {
11119 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11120 if (EVar.isInvalid())
11122 Vars.push_back(EVar.get());
11124 return getDerived().RebuildOMPDependClause(
11125 {
C->getDependencyKind(),
C->getDependencyLoc(),
C->getColonLoc(),
11126 C->getOmpAllMemoryLoc()},
11127 DepModifier, Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11130template <
typename Derived>
11132TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *
C) {
11133 ExprResult E = getDerived().TransformExpr(
C->getDevice());
11136 return getDerived().RebuildOMPDeviceClause(
11137 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11138 C->getModifierLoc(),
C->getEndLoc());
11141template <
typename Derived,
class T>
11148 Vars.reserve(
C->varlist_size());
11149 for (
auto *VE :
C->varlist()) {
11153 Vars.push_back(EVar.
get());
11157 if (
C->getMapperQualifierLoc()) {
11158 QualifierLoc = TT.
getDerived().TransformNestedNameSpecifierLoc(
11159 C->getMapperQualifierLoc());
11163 MapperIdScopeSpec.
Adopt(QualifierLoc);
11164 MapperIdInfo =
C->getMapperIdInfo();
11165 if (MapperIdInfo.
getName()) {
11166 MapperIdInfo = TT.
getDerived().TransformDeclarationNameInfo(MapperIdInfo);
11172 for (
auto *
E :
C->mapperlists()) {
11175 auto *ULE = cast<UnresolvedLookupExpr>(
E);
11177 for (
auto *
D : ULE->decls()) {
11185 MapperIdInfo,
true, Decls.
begin(), Decls.
end(),
11188 UnresolvedMappers.push_back(
nullptr);
11194template <
typename Derived>
11195OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *
C) {
11196 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11198 Expr *IteratorModifier =
C->getIteratorModifier();
11199 if (IteratorModifier) {
11200 ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
11201 if (MapModRes.isInvalid())
11203 IteratorModifier = MapModRes.
get();
11205 CXXScopeSpec MapperIdScopeSpec;
11206 DeclarationNameInfo MapperIdInfo;
11208 if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
11209 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11211 return getDerived().RebuildOMPMapClause(
11212 IteratorModifier,
C->getMapTypeModifiers(),
C->getMapTypeModifiersLoc(),
11213 MapperIdScopeSpec, MapperIdInfo,
C->getMapType(),
C->isImplicitMapType(),
11214 C->getMapLoc(),
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11217template <
typename Derived>
11219TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *
C) {
11220 Expr *Allocator =
C->getAllocator();
11222 ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
11223 if (AllocatorRes.isInvalid())
11225 Allocator = AllocatorRes.get();
11228 Vars.reserve(
C->varlist_size());
11229 for (
auto *VE :
C->varlist()) {
11230 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11231 if (EVar.isInvalid())
11233 Vars.push_back(EVar.get());
11235 return getDerived().RebuildOMPAllocateClause(
11236 Allocator,
C->getAllocatorModifier(), Vars,
C->getBeginLoc(),
11237 C->getLParenLoc(),
C->getColonLoc(),
C->getEndLoc());
11240template <
typename Derived>
11242TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *
C) {
11244 Vars.reserve(
C->varlist_size());
11245 for (
auto *VE :
C->varlist()) {
11246 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11247 if (EVar.isInvalid())
11249 Vars.push_back(EVar.get());
11251 return getDerived().RebuildOMPNumTeamsClause(
11252 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11255template <
typename Derived>
11257TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *
C) {
11259 Vars.reserve(
C->varlist_size());
11260 for (
auto *VE :
C->varlist()) {
11261 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11262 if (EVar.isInvalid())
11264 Vars.push_back(EVar.get());
11266 return getDerived().RebuildOMPThreadLimitClause(
11267 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11270template <
typename Derived>
11272TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *
C) {
11273 ExprResult E = getDerived().TransformExpr(
C->getPriority());
11276 return getDerived().RebuildOMPPriorityClause(
11277 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11280template <
typename Derived>
11282TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *
C) {
11283 ExprResult E = getDerived().TransformExpr(
C->getGrainsize());
11286 return getDerived().RebuildOMPGrainsizeClause(
11287 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11288 C->getModifierLoc(),
C->getEndLoc());
11291template <
typename Derived>
11293TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *
C) {
11294 ExprResult E = getDerived().TransformExpr(
C->getNumTasks());
11297 return getDerived().RebuildOMPNumTasksClause(
11298 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11299 C->getModifierLoc(),
C->getEndLoc());
11302template <
typename Derived>
11303OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *
C) {
11304 ExprResult E = getDerived().TransformExpr(
C->getHint());
11307 return getDerived().RebuildOMPHintClause(
E.get(),
C->getBeginLoc(),
11308 C->getLParenLoc(),
C->getEndLoc());
11311template <
typename Derived>
11312OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
11313 OMPDistScheduleClause *
C) {
11314 ExprResult E = getDerived().TransformExpr(
C->getChunkSize());
11317 return getDerived().RebuildOMPDistScheduleClause(
11318 C->getDistScheduleKind(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11319 C->getDistScheduleKindLoc(),
C->getCommaLoc(),
C->getEndLoc());
11322template <
typename Derived>
11324TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *
C) {
11327 return getDerived().RebuildOMPDefaultmapClause(
C->getDefaultmapModifier(),
11328 C->getDefaultmapKind(),
11331 C->getDefaultmapModifierLoc(),
11332 C->getDefaultmapKindLoc(),
11336template <
typename Derived>
11337OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *
C) {
11338 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11340 CXXScopeSpec MapperIdScopeSpec;
11341 DeclarationNameInfo MapperIdInfo;
11343 if (transformOMPMappableExprListClause<Derived, OMPToClause>(
11344 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11346 return getDerived().RebuildOMPToClause(
11347 C->getMotionModifiers(),
C->getMotionModifiersLoc(), MapperIdScopeSpec,
11348 MapperIdInfo,
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11351template <
typename Derived>
11352OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *
C) {
11353 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11355 CXXScopeSpec MapperIdScopeSpec;
11356 DeclarationNameInfo MapperIdInfo;
11358 if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
11359 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11361 return getDerived().RebuildOMPFromClause(
11362 C->getMotionModifiers(),
C->getMotionModifiersLoc(), MapperIdScopeSpec,
11363 MapperIdInfo,
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11366template <
typename Derived>
11367OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
11368 OMPUseDevicePtrClause *
C) {
11370 Vars.reserve(
C->varlist_size());
11371 for (
auto *VE :
C->varlist()) {
11372 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11373 if (EVar.isInvalid())
11375 Vars.push_back(EVar.get());
11377 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11378 return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
11381template <
typename Derived>
11382OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
11383 OMPUseDeviceAddrClause *
C) {
11385 Vars.reserve(
C->varlist_size());
11386 for (
auto *VE :
C->varlist()) {
11387 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11388 if (EVar.isInvalid())
11390 Vars.push_back(EVar.get());
11392 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11393 return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
11396template <
typename Derived>
11398TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *
C) {
11400 Vars.reserve(
C->varlist_size());
11401 for (
auto *VE :
C->varlist()) {
11402 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11403 if (EVar.isInvalid())
11405 Vars.push_back(EVar.get());
11407 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11408 return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
11411template <
typename Derived>
11412OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
11413 OMPHasDeviceAddrClause *
C) {
11415 Vars.reserve(
C->varlist_size());
11416 for (
auto *VE :
C->varlist()) {
11417 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11418 if (EVar.isInvalid())
11420 Vars.push_back(EVar.get());
11422 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11423 return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
11426template <
typename Derived>
11428TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *
C) {
11430 Vars.reserve(
C->varlist_size());
11431 for (
auto *VE :
C->varlist()) {
11432 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11433 if (EVar.isInvalid())
11435 Vars.push_back(EVar.get());
11437 return getDerived().RebuildOMPNontemporalClause(
11438 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11441template <
typename Derived>
11443TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *
C) {
11445 Vars.reserve(
C->varlist_size());
11446 for (
auto *VE :
C->varlist()) {
11447 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11448 if (EVar.isInvalid())
11450 Vars.push_back(EVar.get());
11452 return getDerived().RebuildOMPInclusiveClause(
11453 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11456template <
typename Derived>
11458TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *
C) {
11460 Vars.reserve(
C->varlist_size());
11461 for (
auto *VE :
C->varlist()) {
11462 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11463 if (EVar.isInvalid())
11465 Vars.push_back(EVar.get());
11467 return getDerived().RebuildOMPExclusiveClause(
11468 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11471template <
typename Derived>
11472OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
11473 OMPUsesAllocatorsClause *
C) {
11475 Data.reserve(
C->getNumberOfAllocators());
11476 for (
unsigned I = 0,
E =
C->getNumberOfAllocators(); I <
E; ++I) {
11477 OMPUsesAllocatorsClause::Data
D =
C->getAllocatorData(I);
11478 ExprResult Allocator = getDerived().TransformExpr(
D.Allocator);
11479 if (Allocator.isInvalid())
11482 if (Expr *AT =
D.AllocatorTraits) {
11483 AllocatorTraits = getDerived().TransformExpr(AT);
11484 if (AllocatorTraits.isInvalid())
11487 SemaOpenMP::UsesAllocatorsData &NewD =
Data.emplace_back();
11488 NewD.Allocator = Allocator.get();
11489 NewD.AllocatorTraits = AllocatorTraits.get();
11490 NewD.LParenLoc =
D.LParenLoc;
11491 NewD.RParenLoc =
D.RParenLoc;
11493 return getDerived().RebuildOMPUsesAllocatorsClause(
11494 Data,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11497template <
typename Derived>
11499TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *
C) {
11501 Locators.reserve(
C->varlist_size());
11503 if (Expr *Modifier =
C->getModifier()) {
11504 ModifierRes = getDerived().TransformExpr(Modifier);
11505 if (ModifierRes.isInvalid())
11508 for (Expr *
E :
C->varlist()) {
11509 ExprResult Locator = getDerived().TransformExpr(
E);
11510 if (Locator.isInvalid())
11512 Locators.push_back(Locator.get());
11514 return getDerived().RebuildOMPAffinityClause(
11515 C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
C->getEndLoc(),
11516 ModifierRes.get(), Locators);
11519template <
typename Derived>
11520OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *
C) {
11521 return getDerived().RebuildOMPOrderClause(
11522 C->getKind(),
C->getKindKwLoc(),
C->getBeginLoc(),
C->getLParenLoc(),
11523 C->getEndLoc(),
C->getModifier(),
C->getModifierKwLoc());
11526template <
typename Derived>
11527OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *
C) {
11528 return getDerived().RebuildOMPBindClause(
11529 C->getBindKind(),
C->getBindKindLoc(),
C->getBeginLoc(),
11530 C->getLParenLoc(),
C->getEndLoc());
11533template <
typename Derived>
11534OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
11535 OMPXDynCGroupMemClause *
C) {
11537 if (
Size.isInvalid())
11539 return getDerived().RebuildOMPXDynCGroupMemClause(
11540 Size.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11543template <
typename Derived>
11545TreeTransform<Derived>::TransformOMPDoacrossClause(OMPDoacrossClause *
C) {
11547 Vars.reserve(
C->varlist_size());
11548 for (
auto *VE :
C->varlist()) {
11549 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11550 if (EVar.isInvalid())
11552 Vars.push_back(EVar.get());
11554 return getDerived().RebuildOMPDoacrossClause(
11555 C->getDependenceType(),
C->getDependenceLoc(),
C->getColonLoc(), Vars,
11556 C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11559template <
typename Derived>
11561TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *
C) {
11563 for (
auto *A :
C->getAttrs())
11564 NewAttrs.push_back(getDerived().TransformAttr(A));
11565 return getDerived().RebuildOMPXAttributeClause(
11566 NewAttrs,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11569template <
typename Derived>
11570OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *
C) {
11571 return getDerived().RebuildOMPXBareClause(
C->getBeginLoc(),
C->getEndLoc());
11578template <
typename Derived>
11579class OpenACCClauseTransform final
11580 :
public OpenACCClauseVisitor<OpenACCClauseTransform<Derived>> {
11581 TreeTransform<Derived> &Self;
11583 SemaOpenACC::OpenACCParsedClause &ParsedClause;
11584 OpenACCClause *NewClause =
nullptr;
11588 for (Expr *CurVar : VarList) {
11589 ExprResult Res = Self.TransformExpr(CurVar);
11591 if (!Res.isUsable())
11594 Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getClauseKind(),
11597 if (Res.isUsable())
11598 InstantiatedVarList.push_back(Res.get());
11601 return InstantiatedVarList;
11605 OpenACCClauseTransform(TreeTransform<Derived> &Self,
11607 SemaOpenACC::OpenACCParsedClause &PC)
11608 : Self(Self), ExistingClauses(ExistingClauses), ParsedClause(PC) {}
11610 OpenACCClause *CreatedClause()
const {
return NewClause; }
11612#define VISIT_CLAUSE(CLAUSE_NAME) \
11613 void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);
11614#include "clang/Basic/OpenACCClauses.def"
11617template <
typename Derived>
11618void OpenACCClauseTransform<Derived>::VisitDefaultClause(
11619 const OpenACCDefaultClause &
C) {
11628template <
typename Derived>
11629void OpenACCClauseTransform<Derived>::VisitIfClause(
const OpenACCIfClause &
C) {
11630 Expr *Cond =
const_cast<Expr *
>(
C.getConditionExpr());
11631 assert(Cond &&
"If constructed with invalid Condition");
11632 Sema::ConditionResult Res =
Self.TransformCondition(
11635 if (Res.isInvalid() || !Res.get().second)
11646template <
typename Derived>
11647void OpenACCClauseTransform<Derived>::VisitSelfClause(
11648 const OpenACCSelfClause &
C) {
11653 for (Expr *CurVar :
C.getVarList()) {
11656 if (!Res.isUsable())
11662 if (Res.isUsable())
11663 InstantiatedVarList.push_back(Res.get());
11675 if (
C.hasConditionExpr()) {
11676 Expr *Cond =
const_cast<Expr *
>(
C.getConditionExpr());
11677 Sema::ConditionResult Res =
11678 Self.TransformCondition(Cond->getExprLoc(),
nullptr, Cond,
11681 if (Res.isInvalid() || !Res.get().second)
11694template <
typename Derived>
11695void OpenACCClauseTransform<Derived>::VisitNumGangsClause(
11696 const OpenACCNumGangsClause &
C) {
11699 for (Expr *CurIntExpr :
C.getIntExprs()) {
11702 if (!Res.isUsable())
11707 C.getBeginLoc(), Res.get());
11708 if (!Res.isUsable())
11711 InstantiatedIntExprs.push_back(Res.get());
11721template <
typename Derived>
11722void OpenACCClauseTransform<Derived>::VisitPrivateClause(
11723 const OpenACCPrivateClause &
C) {
11733template <
typename Derived>
11734void OpenACCClauseTransform<Derived>::VisitHostClause(
11735 const OpenACCHostClause &
C) {
11745template <
typename Derived>
11746void OpenACCClauseTransform<Derived>::VisitDeviceClause(
11747 const OpenACCDeviceClause &
C) {
11757template <
typename Derived>
11758void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause(
11759 const OpenACCFirstPrivateClause &
C) {
11769template <
typename Derived>
11770void OpenACCClauseTransform<Derived>::VisitNoCreateClause(
11771 const OpenACCNoCreateClause &
C) {
11781template <
typename Derived>
11782void OpenACCClauseTransform<Derived>::VisitPresentClause(
11783 const OpenACCPresentClause &
C) {
11793template <
typename Derived>
11794void OpenACCClauseTransform<Derived>::VisitCopyClause(
11795 const OpenACCCopyClause &
C) {
11805template <
typename Derived>
11806void OpenACCClauseTransform<Derived>::VisitCopyInClause(
11807 const OpenACCCopyInClause &
C) {
11818template <
typename Derived>
11819void OpenACCClauseTransform<Derived>::VisitCopyOutClause(
11820 const OpenACCCopyOutClause &
C) {
11822 false,
C.isZero());
11831template <
typename Derived>
11832void OpenACCClauseTransform<Derived>::VisitCreateClause(
11833 const OpenACCCreateClause &
C) {
11835 false,
C.isZero());
11843template <
typename Derived>
11844void OpenACCClauseTransform<Derived>::VisitAttachClause(
11845 const OpenACCAttachClause &
C) {
11849 VarList.erase(std::remove_if(VarList.begin(), VarList.end(), [&](Expr *
E) {
11850 return Self.getSema().OpenACC().CheckVarIsPointerType(
11851 OpenACCClauseKind::Attach, E);
11852 }), VarList.end());
11862template <
typename Derived>
11863void OpenACCClauseTransform<Derived>::VisitDetachClause(
11864 const OpenACCDetachClause &
C) {
11869 std::remove_if(VarList.begin(), VarList.end(),
11871 return Self.getSema().OpenACC().CheckVarIsPointerType(
11872 OpenACCClauseKind::Detach, E);
11884template <
typename Derived>
11885void OpenACCClauseTransform<Derived>::VisitDeleteClause(
11886 const OpenACCDeleteClause &
C) {
11895template <
typename Derived>
11896void OpenACCClauseTransform<Derived>::VisitUseDeviceClause(
11897 const OpenACCUseDeviceClause &
C) {
11906template <
typename Derived>
11907void OpenACCClauseTransform<Derived>::VisitDevicePtrClause(
11908 const OpenACCDevicePtrClause &
C) {
11912 VarList.erase(std::remove_if(VarList.begin(), VarList.end(), [&](Expr *
E) {
11913 return Self.getSema().OpenACC().CheckVarIsPointerType(
11914 OpenACCClauseKind::DevicePtr, E);
11915 }), VarList.end());
11925template <
typename Derived>
11926void OpenACCClauseTransform<Derived>::VisitNumWorkersClause(
11927 const OpenACCNumWorkersClause &
C) {
11928 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11929 assert(IntExpr &&
"num_workers clause constructed with invalid int expr");
11932 if (!Res.isUsable())
11937 C.getBeginLoc(), Res.get());
11938 if (!Res.isUsable())
11948template <
typename Derived>
11949void OpenACCClauseTransform<Derived>::VisitDeviceNumClause (
11950 const OpenACCDeviceNumClause &
C) {
11951 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11952 assert(IntExpr &&
"device_num clause constructed with invalid int expr");
11955 if (!Res.isUsable())
11960 C.getBeginLoc(), Res.get());
11961 if (!Res.isUsable())
11971template <
typename Derived>
11972void OpenACCClauseTransform<Derived>::VisitDefaultAsyncClause(
11973 const OpenACCDefaultAsyncClause &
C) {
11974 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11975 assert(IntExpr &&
"default_async clause constructed with invalid int expr");
11978 if (!Res.isUsable())
11983 C.getBeginLoc(), Res.get());
11984 if (!Res.isUsable())
11994template <
typename Derived>
11995void OpenACCClauseTransform<Derived>::VisitVectorLengthClause(
11996 const OpenACCVectorLengthClause &
C) {
11997 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11998 assert(IntExpr &&
"vector_length clause constructed with invalid int expr");
12001 if (!Res.isUsable())
12006 C.getBeginLoc(), Res.get());
12007 if (!Res.isUsable())
12017template <
typename Derived>
12018void OpenACCClauseTransform<Derived>::VisitAsyncClause(
12019 const OpenACCAsyncClause &
C) {
12020 if (
C.hasIntExpr()) {
12021 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
12022 if (!Res.isUsable())
12027 C.getBeginLoc(), Res.get());
12028 if (!Res.isUsable())
12041template <
typename Derived>
12042void OpenACCClauseTransform<Derived>::VisitWorkerClause(
12043 const OpenACCWorkerClause &
C) {
12044 if (
C.hasIntExpr()) {
12048 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
12049 if (!Res.isUsable())
12054 C.getBeginLoc(), Res.get());
12055 if (!Res.isUsable())
12068template <
typename Derived>
12069void OpenACCClauseTransform<Derived>::VisitVectorClause(
12070 const OpenACCVectorClause &
C) {
12071 if (
C.hasIntExpr()) {
12075 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
12076 if (!Res.isUsable())
12081 C.getBeginLoc(), Res.get());
12082 if (!Res.isUsable())
12095template <
typename Derived>
12096void OpenACCClauseTransform<Derived>::VisitWaitClause(
12097 const OpenACCWaitClause &
C) {
12098 if (!
C.getLParenLoc().isInvalid()) {
12099 Expr *DevNumExpr =
nullptr;
12103 if (
C.getDevNumExpr()) {
12105 if (!Res.isUsable())
12109 C.getBeginLoc(), Res.get());
12110 if (!Res.isUsable())
12113 DevNumExpr = Res.get();
12117 for (Expr *CurQueueIdExpr :
C.getQueueIdExprs()) {
12119 if (!Res.isUsable())
12123 C.getBeginLoc(), Res.get());
12124 if (!Res.isUsable())
12127 InstantiatedQueueIdExprs.push_back(Res.get());
12131 std::move(InstantiatedQueueIdExprs));
12141template <
typename Derived>
12142void OpenACCClauseTransform<Derived>::VisitDeviceTypeClause(
12143 const OpenACCDeviceTypeClause &
C) {
12146 Self.getSema().getASTContext(),
C.getClauseKind(),
12148 C.getArchitectures(), ParsedClause.
getEndLoc());
12151template <
typename Derived>
12152void OpenACCClauseTransform<Derived>::VisitAutoClause(
12153 const OpenACCAutoClause &
C) {
12160template <
typename Derived>
12161void OpenACCClauseTransform<Derived>::VisitIndependentClause(
12162 const OpenACCIndependentClause &
C) {
12168template <
typename Derived>
12169void OpenACCClauseTransform<Derived>::VisitSeqClause(
12170 const OpenACCSeqClause &
C) {
12175template <
typename Derived>
12176void OpenACCClauseTransform<Derived>::VisitFinalizeClause(
12177 const OpenACCFinalizeClause &
C) {
12183template <
typename Derived>
12184void OpenACCClauseTransform<Derived>::VisitIfPresentClause(
12185 const OpenACCIfPresentClause &
C) {
12191template <
typename Derived>
12192void OpenACCClauseTransform<Derived>::VisitReductionClause(
12193 const OpenACCReductionClause &
C) {
12197 for (Expr *Var : TransformedVars) {
12200 if (Res.isUsable())
12201 ValidVars.push_back(Res.get());
12204 NewClause =
Self.getSema().OpenACC().CheckReductionClause(
12207 C.getReductionOp(), ValidVars, ParsedClause.
getEndLoc());
12210template <
typename Derived>
12211void OpenACCClauseTransform<Derived>::VisitCollapseClause(
12212 const OpenACCCollapseClause &
C) {
12213 Expr *LoopCount =
const_cast<Expr *
>(
C.getLoopCount());
12214 assert(LoopCount &&
"collapse clause constructed with invalid loop count");
12218 NewLoopCount =
Self.getSema().OpenACC().ActOnIntExpr(
12220 NewLoopCount.get()->getBeginLoc(), NewLoopCount.get());
12223 Self.getSema().OpenACC().CheckCollapseLoopCount(NewLoopCount.get());
12225 if (!NewLoopCount.isUsable())
12235template <
typename Derived>
12236void OpenACCClauseTransform<Derived>::VisitTileClause(
12237 const OpenACCTileClause &
C) {
12241 for (Expr *
E :
C.getSizeExprs()) {
12244 if (!NewSizeExpr.isUsable())
12247 NewSizeExpr =
Self.getSema().OpenACC().ActOnIntExpr(
12249 NewSizeExpr.get()->getBeginLoc(), NewSizeExpr.get());
12251 NewSizeExpr =
Self.getSema().OpenACC().CheckTileSizeExpr(NewSizeExpr.get());
12253 if (!NewSizeExpr.isUsable())
12255 TransformedExprs.push_back(NewSizeExpr.get());
12264template <
typename Derived>
12265void OpenACCClauseTransform<Derived>::VisitGangClause(
12266 const OpenACCGangClause &
C) {
12270 for (
unsigned I = 0; I <
C.getNumExprs(); ++I) {
12271 ExprResult ER =
Self.TransformExpr(
const_cast<Expr *
>(
C.getExpr(I).second));
12272 if (!ER.isUsable())
12275 ER =
Self.getSema().OpenACC().CheckGangExpr(ExistingClauses,
12277 C.getExpr(I).first, ER.get());
12278 if (!ER.isUsable())
12280 TransformedGangKinds.push_back(
C.getExpr(I).first);
12281 TransformedIntExprs.push_back(ER.get());
12284 NewClause =
Self.getSema().OpenACC().CheckGangClause(
12287 TransformedGangKinds, TransformedIntExprs, ParsedClause.
getEndLoc());
12290template <
typename Derived>
12291OpenACCClause *TreeTransform<Derived>::TransformOpenACCClause(
12295 SemaOpenACC::OpenACCParsedClause ParsedClause(
12296 DirKind, OldClause->getClauseKind(), OldClause->getBeginLoc());
12297 ParsedClause.
setEndLoc(OldClause->getEndLoc());
12299 if (
const auto *WithParms = dyn_cast<OpenACCClauseWithParams>(OldClause))
12302 OpenACCClauseTransform<Derived> Transform{*
this, ExistingClauses,
12304 Transform.Visit(OldClause);
12306 return Transform.CreatedClause();
12309template <
typename Derived>
12311TreeTransform<Derived>::TransformOpenACCClauseList(
12314 for (
const auto *Clause : OldClauses) {
12315 if (OpenACCClause *TransformedClause = getDerived().TransformOpenACCClause(
12316 TransformedClauses, DirKind, Clause))
12317 TransformedClauses.push_back(TransformedClause);
12319 return TransformedClauses;
12322template <
typename Derived>
12323StmtResult TreeTransform<Derived>::TransformOpenACCComputeConstruct(
12324 OpenACCComputeConstruct *
C) {
12325 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12328 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12331 if (getSema().OpenACC().ActOnStartStmtDirective(
12332 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12336 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12337 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12338 C->clauses(), TransformedClauses);
12339 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12340 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12341 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12343 return getDerived().RebuildOpenACCComputeConstruct(
12344 C->getDirectiveKind(),
C->getBeginLoc(),
C->getDirectiveLoc(),
12345 C->getEndLoc(), TransformedClauses, StrBlock);
12348template <
typename Derived>
12350TreeTransform<Derived>::TransformOpenACCLoopConstruct(OpenACCLoopConstruct *
C) {
12352 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12355 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12358 if (getSema().OpenACC().ActOnStartStmtDirective(
12359 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12363 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12364 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12365 C->clauses(), TransformedClauses);
12367 Loop = getSema().OpenACC().ActOnAssociatedStmt(
12368 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses,
Loop);
12370 return getDerived().RebuildOpenACCLoopConstruct(
12371 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12372 TransformedClauses,
Loop);
12375template <
typename Derived>
12376StmtResult TreeTransform<Derived>::TransformOpenACCCombinedConstruct(
12377 OpenACCCombinedConstruct *
C) {
12378 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12381 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12384 if (getSema().OpenACC().ActOnStartStmtDirective(
12385 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12389 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12390 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12391 C->clauses(), TransformedClauses);
12393 Loop = getSema().OpenACC().ActOnAssociatedStmt(
12394 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses,
Loop);
12396 return getDerived().RebuildOpenACCCombinedConstruct(
12397 C->getDirectiveKind(),
C->getBeginLoc(),
C->getDirectiveLoc(),
12398 C->getEndLoc(), TransformedClauses,
Loop);
12401template <
typename Derived>
12403TreeTransform<Derived>::TransformOpenACCDataConstruct(OpenACCDataConstruct *
C) {
12404 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12407 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12409 if (getSema().OpenACC().ActOnStartStmtDirective(
12410 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12413 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12414 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12415 C->clauses(), TransformedClauses);
12416 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12417 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12418 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12420 return getDerived().RebuildOpenACCDataConstruct(
12421 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12422 TransformedClauses, StrBlock);
12425template <
typename Derived>
12426StmtResult TreeTransform<Derived>::TransformOpenACCEnterDataConstruct(
12427 OpenACCEnterDataConstruct *
C) {
12428 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12431 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12433 if (getSema().OpenACC().ActOnStartStmtDirective(
12434 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12437 return getDerived().RebuildOpenACCEnterDataConstruct(
12438 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12439 TransformedClauses);
12442template <
typename Derived>
12443StmtResult TreeTransform<Derived>::TransformOpenACCExitDataConstruct(
12444 OpenACCExitDataConstruct *
C) {
12445 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12448 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12450 if (getSema().OpenACC().ActOnStartStmtDirective(
12451 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12454 return getDerived().RebuildOpenACCExitDataConstruct(
12455 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12456 TransformedClauses);
12459template <
typename Derived>
12460StmtResult TreeTransform<Derived>::TransformOpenACCHostDataConstruct(
12461 OpenACCHostDataConstruct *
C) {
12462 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12465 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12467 if (getSema().OpenACC().ActOnStartStmtDirective(
12468 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12471 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12472 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12473 C->clauses(), TransformedClauses);
12474 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12475 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12476 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12478 return getDerived().RebuildOpenACCHostDataConstruct(
12479 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12480 TransformedClauses, StrBlock);
12483template <
typename Derived>
12485TreeTransform<Derived>::TransformOpenACCInitConstruct(OpenACCInitConstruct *
C) {
12486 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12489 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12491 if (getSema().OpenACC().ActOnStartStmtDirective(
12492 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12495 return getDerived().RebuildOpenACCInitConstruct(
12496 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12497 TransformedClauses);
12500template <
typename Derived>
12501StmtResult TreeTransform<Derived>::TransformOpenACCShutdownConstruct(
12502 OpenACCShutdownConstruct *
C) {
12503 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12506 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12508 if (getSema().OpenACC().ActOnStartStmtDirective(
12509 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12512 return getDerived().RebuildOpenACCShutdownConstruct(
12513 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12514 TransformedClauses);
12516template <
typename Derived>
12518TreeTransform<Derived>::TransformOpenACCSetConstruct(OpenACCSetConstruct *
C) {
12519 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12522 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12524 if (getSema().OpenACC().ActOnStartStmtDirective(
12525 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12528 return getDerived().RebuildOpenACCSetConstruct(
12529 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12530 TransformedClauses);
12533template <
typename Derived>
12534StmtResult TreeTransform<Derived>::TransformOpenACCUpdateConstruct(
12535 OpenACCUpdateConstruct *
C) {
12536 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12539 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12541 if (getSema().OpenACC().ActOnStartStmtDirective(
12542 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12545 return getDerived().RebuildOpenACCUpdateConstruct(
12546 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12547 TransformedClauses);
12550template <
typename Derived>
12552TreeTransform<Derived>::TransformOpenACCWaitConstruct(OpenACCWaitConstruct *
C) {
12553 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12556 if (
C->hasDevNumExpr()) {
12557 DevNumExpr = getDerived().TransformExpr(
C->getDevNumExpr());
12559 if (DevNumExpr.isUsable())
12560 DevNumExpr = getSema().OpenACC().ActOnIntExpr(
12562 C->getBeginLoc(), DevNumExpr.get());
12567 for (Expr *QE :
C->getQueueIdExprs()) {
12568 assert(QE &&
"Null queue id expr?");
12569 ExprResult NewEQ = getDerived().TransformExpr(QE);
12571 if (!NewEQ.isUsable())
12575 C->getBeginLoc(), NewEQ.get());
12576 if (NewEQ.isUsable())
12577 QueueIdExprs.push_back(NewEQ.get());
12581 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12584 if (getSema().OpenACC().ActOnStartStmtDirective(
12585 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12588 return getDerived().RebuildOpenACCWaitConstruct(
12589 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getLParenLoc(),
12590 DevNumExpr.isUsable() ? DevNumExpr.get() :
nullptr,
C->getQueuesLoc(),
12591 QueueIdExprs,
C->getRParenLoc(),
C->getEndLoc(), TransformedClauses);
12594template <
typename Derived>
12595ExprResult TreeTransform<Derived>::TransformOpenACCAsteriskSizeExpr(
12596 OpenACCAsteriskSizeExpr *
E) {
12597 if (getDerived().AlwaysRebuild())
12598 return getDerived().RebuildOpenACCAsteriskSizeExpr(
E->getLocation());
12606template<
typename Derived>
12608TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *
E) {
12609 return TransformExpr(
E->getSubExpr());
12612template <
typename Derived>
12613ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr(
12614 SYCLUniqueStableNameExpr *
E) {
12618 TypeSourceInfo *NewT = getDerived().TransformType(
E->getTypeSourceInfo());
12623 if (!getDerived().AlwaysRebuild() &&
E->getTypeSourceInfo() == NewT)
12626 return getDerived().RebuildSYCLUniqueStableNameExpr(
12627 E->getLocation(),
E->getLParenLocation(),
E->getRParenLocation(), NewT);
12630template<
typename Derived>
12632TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *
E) {
12636 return getDerived().RebuildPredefinedExpr(
E->getLocation(),
12637 E->getIdentKind());
12640template<
typename Derived>
12642TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *
E) {
12643 NestedNameSpecifierLoc QualifierLoc;
12644 if (
E->getQualifierLoc()) {
12646 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
12652 = cast_or_null<ValueDecl>(getDerived().TransformDecl(
E->getLocation(),
12657 NamedDecl *
Found = ND;
12658 if (
E->getFoundDecl() !=
E->getDecl()) {
12659 Found = cast_or_null<NamedDecl>(
12660 getDerived().TransformDecl(
E->getLocation(),
E->getFoundDecl()));
12665 DeclarationNameInfo NameInfo =
E->getNameInfo();
12666 if (NameInfo.getName()) {
12667 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
12668 if (!NameInfo.getName())
12672 if (!getDerived().AlwaysRebuild() &&
12673 !
E->isCapturedByCopyInLambdaWithExplicitObjectParameter() &&
12674 QualifierLoc ==
E->getQualifierLoc() && ND ==
E->getDecl() &&
12675 Found ==
E->getFoundDecl() &&
12676 NameInfo.getName() ==
E->getDecl()->getDeclName() &&
12677 !
E->hasExplicitTemplateArgs()) {
12686 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
12687 if (
E->hasExplicitTemplateArgs()) {
12688 TemplateArgs = &TransArgs;
12689 TransArgs.setLAngleLoc(
E->getLAngleLoc());
12690 TransArgs.setRAngleLoc(
E->getRAngleLoc());
12691 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
12692 E->getNumTemplateArgs(),
12697 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
12698 Found, TemplateArgs);
12701template<
typename Derived>
12703TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *
E) {
12707template <
typename Derived>
12708ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
12709 FixedPointLiteral *
E) {
12713template<
typename Derived>
12715TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *
E) {
12719template<
typename Derived>
12721TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *
E) {
12725template<
typename Derived>
12727TreeTransform<Derived>::TransformStringLiteral(StringLiteral *
E) {
12731template<
typename Derived>
12733TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *
E) {
12737template<
typename Derived>
12739TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *
E) {
12740 return getDerived().TransformCallExpr(
E);
12743template<
typename Derived>
12745TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *
E) {
12747 TypeSourceInfo *ControllingType =
nullptr;
12748 if (
E->isExprPredicate())
12749 ControllingExpr = getDerived().TransformExpr(
E->getControllingExpr());
12751 ControllingType = getDerived().TransformType(
E->getControllingType());
12753 if (ControllingExpr.isInvalid() && !ControllingType)
12759 TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
12761 TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
12764 AssocTypes.push_back(AssocType);
12766 AssocTypes.push_back(
nullptr);
12770 getDerived().TransformExpr(Assoc.getAssociationExpr());
12771 if (AssocExpr.isInvalid())
12773 AssocExprs.push_back(AssocExpr.get());
12776 if (!ControllingType)
12777 return getDerived().RebuildGenericSelectionExpr(
E->getGenericLoc(),
12778 E->getDefaultLoc(),
12780 ControllingExpr.get(),
12783 return getDerived().RebuildGenericSelectionExpr(
12784 E->getGenericLoc(),
E->getDefaultLoc(),
E->getRParenLoc(),
12785 ControllingType, AssocTypes, AssocExprs);
12788template<
typename Derived>
12790TreeTransform<Derived>::TransformParenExpr(ParenExpr *
E) {
12791 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
12792 if (SubExpr.isInvalid())
12795 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getSubExpr())
12798 return getDerived().RebuildParenExpr(SubExpr.get(),
E->getLParen(),
12805template<
typename Derived>
12809 return getDerived().TransformDependentScopeDeclRefExpr(
12810 DRE,
true,
nullptr);
12812 return getDerived().TransformUnresolvedLookupExpr(
12815 return getDerived().TransformExpr(
E);
12818template<
typename Derived>
12822 if (
E->getOpcode() == UO_AddrOf)
12823 SubExpr = TransformAddressOfOperand(
E->getSubExpr());
12825 SubExpr = TransformExpr(
E->getSubExpr());
12829 if (!getDerived().AlwaysRebuild() && SubExpr.
get() ==
E->getSubExpr())
12832 return getDerived().RebuildUnaryOperator(
E->getOperatorLoc(),
12837template<
typename Derived>
12839TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *
E) {
12841 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeSourceInfo());
12851 bool ExprChanged =
false;
12852 typedef Sema::OffsetOfComponent Component;
12854 for (
unsigned I = 0, N =
E->getNumComponents(); I != N; ++I) {
12855 const OffsetOfNode &ON =
E->getComponent(I);
12857 Comp.isBrackets =
true;
12858 Comp.LocStart = ON.getSourceRange().getBegin();
12859 Comp.LocEnd = ON.getSourceRange().getEnd();
12860 switch (ON.getKind()) {
12862 Expr *FromIndex =
E->getIndexExpr(ON.getArrayExprIndex());
12863 ExprResult Index = getDerived().TransformExpr(FromIndex);
12864 if (Index.isInvalid())
12867 ExprChanged = ExprChanged || Index.get() != FromIndex;
12868 Comp.isBrackets =
true;
12869 Comp.U.E = Index.get();
12875 Comp.isBrackets =
false;
12876 Comp.U.IdentInfo = ON.getFieldName();
12877 if (!
Comp.U.IdentInfo)
12887 Components.push_back(Comp);
12891 if (!getDerived().AlwaysRebuild() &&
12892 Type ==
E->getTypeSourceInfo() &&
12897 return getDerived().RebuildOffsetOfExpr(
E->getOperatorLoc(), Type,
12898 Components,
E->getRParenLoc());
12901template<
typename Derived>
12903TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *
E) {
12904 assert((!
E->getSourceExpr() || getDerived().AlreadyTransformed(
E->
getType())) &&
12905 "opaque value expression requires transformation");
12909template<
typename Derived>
12911TreeTransform<Derived>::TransformTypoExpr(TypoExpr *
E) {
12915template <
typename Derived>
12916ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *
E) {
12919 for (Expr *
C :
E->subExpressions()) {
12921 if (NewC.isInvalid())
12923 Children.push_back(NewC.get());
12927 if (!getDerived().AlwaysRebuild() && !Changed)
12933template<
typename Derived>
12935TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *
E) {
12943 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
12944 if (result.isInvalid())
return ExprError();
12949 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
12955template<
typename Derived>
12957TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
12958 UnaryExprOrTypeTraitExpr *
E) {
12959 if (
E->isArgumentType()) {
12960 TypeSourceInfo *OldT =
E->getArgumentTypeInfo();
12962 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
12966 if (!getDerived().AlwaysRebuild() && OldT == NewT)
12969 return getDerived().RebuildUnaryExprOrTypeTrait(NewT,
E->getOperatorLoc(),
12983 TypeSourceInfo *RecoveryTSI =
nullptr;
12985 auto *PE = dyn_cast<ParenExpr>(
E->getArgumentExpr());
12987 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
12988 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
12989 PE, DRE,
false, &RecoveryTSI);
12991 SubExpr = getDerived().TransformExpr(
E->getArgumentExpr());
12994 return getDerived().RebuildUnaryExprOrTypeTrait(
12996 }
else if (SubExpr.isInvalid())
12999 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getArgumentExpr())
13002 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
13003 E->getOperatorLoc(),
13008template<
typename Derived>
13010TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *
E) {
13011 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13012 if (LHS.isInvalid())
13015 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
13016 if (RHS.isInvalid())
13020 if (!getDerived().AlwaysRebuild() &&
13021 LHS.get() ==
E->getLHS() &&
13022 RHS.get() ==
E->getRHS())
13025 return getDerived().RebuildArraySubscriptExpr(
13027 E->getLHS()->
getBeginLoc(), RHS.get(),
E->getRBracketLoc());
13030template <
typename Derived>
13032TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *
E) {
13034 if (
Base.isInvalid())
13037 ExprResult RowIdx = getDerived().TransformExpr(
E->getRowIdx());
13038 if (RowIdx.isInvalid())
13041 ExprResult ColumnIdx = getDerived().TransformExpr(
E->getColumnIdx());
13042 if (ColumnIdx.isInvalid())
13045 if (!getDerived().AlwaysRebuild() &&
Base.get() ==
E->getBase() &&
13046 RowIdx.get() ==
E->getRowIdx() && ColumnIdx.get() ==
E->getColumnIdx())
13049 return getDerived().RebuildMatrixSubscriptExpr(
13050 Base.get(), RowIdx.get(), ColumnIdx.get(),
E->getRBracketLoc());
13053template <
typename Derived>
13055TreeTransform<Derived>::TransformArraySectionExpr(ArraySectionExpr *
E) {
13057 if (
Base.isInvalid())
13061 if (
E->getLowerBound()) {
13062 LowerBound = getDerived().TransformExpr(
E->getLowerBound());
13063 if (LowerBound.isInvalid())
13068 if (
E->getLength()) {
13069 Length = getDerived().TransformExpr(
E->getLength());
13070 if (Length.isInvalid())
13075 if (
E->isOMPArraySection()) {
13076 if (Expr *Str =
E->getStride()) {
13077 Stride = getDerived().TransformExpr(Str);
13078 if (Stride.isInvalid())
13083 if (!getDerived().AlwaysRebuild() &&
Base.get() ==
E->getBase() &&
13084 LowerBound.get() ==
E->getLowerBound() &&
13085 Length.get() ==
E->getLength() &&
13086 (
E->isOpenACCArraySection() || Stride.get() ==
E->getStride()))
13089 return getDerived().RebuildArraySectionExpr(
13091 LowerBound.get(),
E->getColonLocFirst(),
13092 E->isOMPArraySection() ?
E->getColonLocSecond() : SourceLocation{},
13093 Length.get(), Stride.get(),
E->getRBracketLoc());
13096template <
typename Derived>
13098TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *
E) {
13100 if (
Base.isInvalid())
13104 bool ErrorFound =
false;
13105 for (Expr *
Dim :
E->getDimensions()) {
13107 if (DimRes.isInvalid()) {
13111 Dims.push_back(DimRes.get());
13116 return getDerived().RebuildOMPArrayShapingExpr(
Base.get(),
E->getLParenLoc(),
13117 E->getRParenLoc(), Dims,
13118 E->getBracketsRanges());
13121template <
typename Derived>
13123TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *
E) {
13124 unsigned NumIterators =
E->numOfIterators();
13127 bool ErrorFound =
false;
13128 bool NeedToRebuild = getDerived().AlwaysRebuild();
13129 for (
unsigned I = 0; I < NumIterators; ++I) {
13130 auto *
D = cast<VarDecl>(
E->getIteratorDecl(I));
13131 Data[I].DeclIdent =
D->getIdentifier();
13135 "Implicit type must be int.");
13137 TypeSourceInfo *TSI = getDerived().TransformType(
D->getTypeSourceInfo());
13138 QualType
DeclTy = getDerived().TransformType(
D->getType());
13141 OMPIteratorExpr::IteratorRange
Range =
E->getIteratorRange(I);
13145 ErrorFound = ErrorFound ||
13146 !(!
D->getTypeSourceInfo() || (
Data[I].Type.getAsOpaquePtr() &&
13147 !
Data[I].Type.get().isNull())) ||
13152 Data[I].Range.End = End.get();
13153 Data[I].Range.Step = Step.get();
13154 Data[I].AssignLoc =
E->getAssignLoc(I);
13155 Data[I].ColonLoc =
E->getColonLoc(I);
13156 Data[I].SecColonLoc =
E->getSecondColonLoc(I);
13159 (
D->getTypeSourceInfo() &&
Data[I].Type.get().getTypePtrOrNull() !=
13160 D->getType().getTypePtrOrNull()) ||
13166 if (!NeedToRebuild)
13169 ExprResult Res = getDerived().RebuildOMPIteratorExpr(
13170 E->getIteratorKwLoc(),
E->getLParenLoc(),
E->getRParenLoc(),
Data);
13171 if (!Res.isUsable())
13173 auto *IE = cast<OMPIteratorExpr>(Res.get());
13174 for (
unsigned I = 0; I < NumIterators; ++I)
13175 getDerived().transformedLocalDecl(
E->getIteratorDecl(I),
13176 IE->getIteratorDecl(I));
13180template<
typename Derived>
13182TreeTransform<Derived>::TransformCallExpr(CallExpr *
E) {
13189 bool ArgChanged =
false;
13191 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
13195 if (!getDerived().AlwaysRebuild() &&
13196 Callee.get() ==
E->getCallee() &&
13201 SourceLocation FakeLParenLoc
13204 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13205 if (
E->hasStoredFPFeatures()) {
13206 FPOptionsOverride NewOverrides =
E->getFPFeatures();
13207 getSema().CurFPFeatures =
13208 NewOverrides.applyOverrides(getSema().getLangOpts());
13209 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13212 return getDerived().RebuildCallExpr(
Callee.get(), FakeLParenLoc,
13214 E->getRParenLoc());
13217template<
typename Derived>
13219TreeTransform<Derived>::TransformMemberExpr(MemberExpr *
E) {
13221 if (
Base.isInvalid())
13224 NestedNameSpecifierLoc QualifierLoc;
13225 if (
E->hasQualifier()) {
13227 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
13232 SourceLocation TemplateKWLoc =
E->getTemplateKeywordLoc();
13235 = cast_or_null<ValueDecl>(getDerived().TransformDecl(
E->getMemberLoc(),
13236 E->getMemberDecl()));
13240 NamedDecl *FoundDecl =
E->getFoundDecl();
13241 if (FoundDecl ==
E->getMemberDecl()) {
13244 FoundDecl = cast_or_null<NamedDecl>(
13245 getDerived().TransformDecl(
E->getMemberLoc(), FoundDecl));
13250 if (!getDerived().AlwaysRebuild() &&
13251 Base.get() ==
E->getBase() &&
13252 QualifierLoc ==
E->getQualifierLoc() &&
13253 Member ==
E->getMemberDecl() &&
13254 FoundDecl ==
E->getFoundDecl() &&
13255 !
E->hasExplicitTemplateArgs()) {
13259 if (!(isa<CXXThisExpr>(
E->getBase()) &&
13260 getSema().OpenMP().isOpenMPRebuildMemberExpr(
13261 cast<ValueDecl>(
Member)))) {
13269 TemplateArgumentListInfo TransArgs;
13270 if (
E->hasExplicitTemplateArgs()) {
13271 TransArgs.setLAngleLoc(
E->getLAngleLoc());
13272 TransArgs.setRAngleLoc(
E->getRAngleLoc());
13273 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
13274 E->getNumTemplateArgs(),
13280 SourceLocation FakeOperatorLoc =
13287 NamedDecl *FirstQualifierInScope =
nullptr;
13288 DeclarationNameInfo MemberNameInfo =
E->getMemberNameInfo();
13289 if (MemberNameInfo.getName()) {
13290 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
13291 if (!MemberNameInfo.getName())
13295 return getDerived().RebuildMemberExpr(
Base.get(), FakeOperatorLoc,
13302 (
E->hasExplicitTemplateArgs()
13303 ? &TransArgs :
nullptr),
13304 FirstQualifierInScope);
13307template<
typename Derived>
13309TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *
E) {
13310 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13311 if (LHS.isInvalid())
13315 getDerived().TransformInitializer(
E->getRHS(),
false);
13316 if (RHS.isInvalid())
13319 if (!getDerived().AlwaysRebuild() &&
13320 LHS.get() ==
E->getLHS() &&
13321 RHS.get() ==
E->getRHS())
13324 if (
E->isCompoundAssignmentOp())
13326 return getDerived().RebuildBinaryOperator(
13327 E->getOperatorLoc(),
E->getOpcode(), LHS.get(), RHS.get());
13328 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13329 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13330 getSema().CurFPFeatures =
13331 NewOverrides.applyOverrides(getSema().getLangOpts());
13332 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13333 return getDerived().RebuildBinaryOperator(
E->getOperatorLoc(),
E->getOpcode(),
13334 LHS.get(), RHS.get());
13337template <
typename Derived>
13338ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
13339 CXXRewrittenBinaryOperator *
E) {
13340 CXXRewrittenBinaryOperator::DecomposedForm Decomp =
E->getDecomposedForm();
13342 ExprResult LHS = getDerived().TransformExpr(
const_cast<Expr*
>(Decomp.LHS));
13343 if (LHS.isInvalid())
13346 ExprResult RHS = getDerived().TransformExpr(
const_cast<Expr*
>(Decomp.RHS));
13347 if (RHS.isInvalid())
13352 UnresolvedSet<2> UnqualLookups;
13353 bool ChangedAnyLookups =
false;
13354 Expr *PossibleBinOps[] = {
E->getSemanticForm(),
13355 const_cast<Expr *
>(Decomp.InnerBinOp)};
13356 for (Expr *PossibleBinOp : PossibleBinOps) {
13357 auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
13360 auto *
Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
13361 if (!Callee || isa<CXXMethodDecl>(
Callee->getDecl()))
13366 NamedDecl *
Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
13367 E->getOperatorLoc(),
Callee->getFoundDecl()));
13371 ChangedAnyLookups =
true;
13372 UnqualLookups.addDecl(
Found);
13375 if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups &&
13376 LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) {
13382 const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS};
13387 return getDerived().RebuildCXXRewrittenBinaryOperator(
13388 E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
13391template<
typename Derived>
13393TreeTransform<Derived>::TransformCompoundAssignOperator(
13394 CompoundAssignOperator *
E) {
13395 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13396 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13397 getSema().CurFPFeatures =
13398 NewOverrides.applyOverrides(getSema().getLangOpts());
13399 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13400 return getDerived().TransformBinaryOperator(
E);
13403template<
typename Derived>
13405TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
13409 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
13410 if (commonExpr.isInvalid())
13413 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
13414 if (rhs.isInvalid())
13417 if (!getDerived().AlwaysRebuild() &&
13418 commonExpr.get() == e->getCommon() &&
13419 rhs.get() == e->getFalseExpr())
13422 return getDerived().RebuildConditionalOperator(commonExpr.get(),
13423 e->getQuestionLoc(),
13429template<
typename Derived>
13431TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *
E) {
13432 ExprResult Cond = getDerived().TransformExpr(
E->getCond());
13433 if (Cond.isInvalid())
13436 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13437 if (LHS.isInvalid())
13440 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
13441 if (RHS.isInvalid())
13444 if (!getDerived().AlwaysRebuild() &&
13445 Cond.get() ==
E->getCond() &&
13446 LHS.get() ==
E->getLHS() &&
13447 RHS.get() ==
E->getRHS())
13450 return getDerived().RebuildConditionalOperator(Cond.get(),
13451 E->getQuestionLoc(),
13457template<
typename Derived>
13459TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *
E) {
13462 return getDerived().TransformExpr(
E->getSubExprAsWritten());
13465template<
typename Derived>
13467TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *
E) {
13468 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeInfoAsWritten());
13473 = getDerived().TransformExpr(
E->getSubExprAsWritten());
13474 if (SubExpr.isInvalid())
13477 if (!getDerived().AlwaysRebuild() &&
13478 Type ==
E->getTypeInfoAsWritten() &&
13479 SubExpr.get() ==
E->getSubExpr())
13482 return getDerived().RebuildCStyleCastExpr(
E->getLParenLoc(),
13488template<
typename Derived>
13490TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *
E) {
13491 TypeSourceInfo *OldT =
E->getTypeSourceInfo();
13492 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
13497 if (
Init.isInvalid())
13500 if (!getDerived().AlwaysRebuild() &&
13502 Init.get() ==
E->getInitializer())
13509 return getDerived().RebuildCompoundLiteralExpr(
13510 E->getLParenLoc(), NewT,
13514template<
typename Derived>
13516TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *
E) {
13518 if (
Base.isInvalid())
13521 if (!getDerived().AlwaysRebuild() &&
13522 Base.get() ==
E->getBase())
13526 SourceLocation FakeOperatorLoc =
13528 return getDerived().RebuildExtVectorElementExpr(
13529 Base.get(), FakeOperatorLoc,
E->isArrow(),
E->getAccessorLoc(),
13533template<
typename Derived>
13535TreeTransform<Derived>::TransformInitListExpr(InitListExpr *
E) {
13536 if (InitListExpr *Syntactic =
E->getSyntacticForm())
13539 bool InitChanged =
false;
13541 EnterExpressionEvaluationContext Context(
13545 if (getDerived().TransformExprs(
E->getInits(),
E->getNumInits(),
false,
13546 Inits, &InitChanged))
13549 if (!getDerived().AlwaysRebuild() && !InitChanged) {
13556 return getDerived().RebuildInitList(
E->getLBraceLoc(), Inits,
13557 E->getRBraceLoc());
13560template<
typename Derived>
13562TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *
E) {
13567 if (
Init.isInvalid())
13572 bool ExprChanged =
false;
13573 for (
const DesignatedInitExpr::Designator &
D :
E->designators()) {
13574 if (
D.isFieldDesignator()) {
13575 if (
D.getFieldDecl()) {
13576 FieldDecl *
Field = cast_or_null<FieldDecl>(
13577 getDerived().TransformDecl(
D.getFieldLoc(),
D.getFieldDecl()));
13578 if (Field !=
D.getFieldDecl())
13581 ExprChanged =
true;
13582 if (
Field->isAnonymousStructOrUnion())
13588 ExprChanged =
true;
13591 D.getFieldName(),
D.getDotLoc(),
D.getFieldLoc()));
13595 if (
D.isArrayDesignator()) {
13596 ExprResult Index = getDerived().TransformExpr(
E->getArrayIndex(
D));
13597 if (Index.isInvalid())
13600 Desig.AddDesignator(
13603 ExprChanged = ExprChanged ||
Init.get() !=
E->getArrayIndex(
D);
13604 ArrayExprs.push_back(Index.get());
13608 assert(
D.isArrayRangeDesignator() &&
"New kind of designator?");
13610 = getDerived().TransformExpr(
E->getArrayRangeStart(
D));
13611 if (Start.isInvalid())
13614 ExprResult End = getDerived().TransformExpr(
E->getArrayRangeEnd(
D));
13615 if (End.isInvalid())
13619 Start.get(), End.get(),
D.getLBracketLoc(),
D.getEllipsisLoc()));
13621 ExprChanged = ExprChanged || Start.get() !=
E->getArrayRangeStart(
D) ||
13622 End.get() !=
E->getArrayRangeEnd(
D);
13624 ArrayExprs.push_back(Start.get());
13625 ArrayExprs.push_back(End.get());
13628 if (!getDerived().AlwaysRebuild() &&
13629 Init.get() ==
E->getInit() &&
13633 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
13634 E->getEqualOrColonLoc(),
13635 E->usesGNUSyntax(),
Init.get());
13640template<
typename Derived>
13642TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
13643 DesignatedInitUpdateExpr *
E) {
13644 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
13649template<
typename Derived>
13651TreeTransform<Derived>::TransformNoInitExpr(
13653 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
13657template<
typename Derived>
13659TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *
E) {
13660 llvm_unreachable(
"Unexpected ArrayInitLoopExpr outside of initializer");
13664template<
typename Derived>
13666TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *
E) {
13667 llvm_unreachable(
"Unexpected ArrayInitIndexExpr outside of initializer");
13671template<
typename Derived>
13673TreeTransform<Derived>::TransformImplicitValueInitExpr(
13674 ImplicitValueInitExpr *
E) {
13675 TemporaryBase Rebase(*
this,
E->
getBeginLoc(), DeclarationName());
13679 QualType
T = getDerived().TransformType(
E->
getType());
13683 if (!getDerived().AlwaysRebuild() &&
13687 return getDerived().RebuildImplicitValueInitExpr(
T);
13690template<
typename Derived>
13692TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *
E) {
13693 TypeSourceInfo *TInfo = getDerived().TransformType(
E->getWrittenTypeInfo());
13697 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
13698 if (SubExpr.isInvalid())
13701 if (!getDerived().AlwaysRebuild() &&
13702 TInfo ==
E->getWrittenTypeInfo() &&
13703 SubExpr.get() ==
E->getSubExpr())
13706 return getDerived().RebuildVAArgExpr(
E->getBuiltinLoc(), SubExpr.get(),
13707 TInfo,
E->getRParenLoc());
13710template<
typename Derived>
13712TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *
E) {
13713 bool ArgumentChanged =
false;
13715 if (TransformExprs(
E->getExprs(),
E->getNumExprs(),
true, Inits,
13719 return getDerived().RebuildParenListExpr(
E->getLParenLoc(),
13721 E->getRParenLoc());
13729template<
typename Derived>
13731TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *
E) {
13732 Decl *LD = getDerived().TransformDecl(
E->getLabel()->getLocation(),
13737 return getDerived().RebuildAddrLabelExpr(
E->getAmpAmpLoc(),
E->getLabelLoc(),
13738 cast<LabelDecl>(LD));
13741template<
typename Derived>
13743TreeTransform<Derived>::TransformStmtExpr(StmtExpr *
E) {
13746 = getDerived().TransformCompoundStmt(
E->getSubStmt(),
true);
13747 if (SubStmt.isInvalid()) {
13752 unsigned OldDepth =
E->getTemplateDepth();
13753 unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);
13755 if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
13756 SubStmt.get() ==
E->getSubStmt()) {
13762 return getDerived().RebuildStmtExpr(
E->getLParenLoc(), SubStmt.get(),
13763 E->getRParenLoc(), NewDepth);
13766template<
typename Derived>
13768TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *
E) {
13769 ExprResult Cond = getDerived().TransformExpr(
E->getCond());
13770 if (Cond.isInvalid())
13773 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13774 if (LHS.isInvalid())
13777 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
13778 if (RHS.isInvalid())
13781 if (!getDerived().AlwaysRebuild() &&
13782 Cond.get() ==
E->getCond() &&
13783 LHS.get() ==
E->getLHS() &&
13784 RHS.get() ==
E->getRHS())
13787 return getDerived().RebuildChooseExpr(
E->getBuiltinLoc(),
13788 Cond.get(), LHS.get(), RHS.get(),
13789 E->getRParenLoc());
13792template<
typename Derived>
13794TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *
E) {
13798template<
typename Derived>
13800TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *
E) {
13801 switch (
E->getOperator()) {
13805 case OO_Array_Delete:
13806 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
13811 assert(
E->getNumArgs() >= 1 &&
"Object call is missing arguments");
13820 static_cast<Expr *
>(
Object.get())->getEndLoc());
13824 if (getDerived().TransformExprs(
E->getArgs() + 1,
E->getNumArgs() - 1,
true,
13828 if (
E->getOperator() == OO_Subscript)
13829 return getDerived().RebuildCxxSubscriptExpr(
Object.get(), FakeLParenLoc,
13832 return getDerived().RebuildCallExpr(
Object.get(), FakeLParenLoc, Args,
13836#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
13840#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
13841#include "clang/Basic/OperatorKinds.def"
13843 case OO_Conditional:
13844 llvm_unreachable(
"conditional operator is not actually overloadable");
13848 llvm_unreachable(
"not an overloaded operator?");
13852 if (
E->getNumArgs() == 1 &&
E->getOperator() == OO_Amp)
13853 First = getDerived().TransformAddressOfOperand(
E->getArg(0));
13855 First = getDerived().TransformExpr(
E->getArg(0));
13856 if (
First.isInvalid())
13860 if (
E->getNumArgs() == 2) {
13862 getDerived().TransformInitializer(
E->getArg(1),
false);
13863 if (Second.isInvalid())
13867 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13868 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13869 getSema().CurFPFeatures =
13870 NewOverrides.applyOverrides(getSema().getLangOpts());
13871 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13873 Expr *
Callee =
E->getCallee();
13874 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
13875 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
13877 if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R))
13880 return getDerived().RebuildCXXOperatorCallExpr(
13881 E->getOperator(),
E->getOperatorLoc(),
Callee->getBeginLoc(),
13882 ULE->requiresADL(), R.asUnresolvedSet(),
First.get(), Second.get());
13885 UnresolvedSet<1> Functions;
13886 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
13887 Callee = ICE->getSubExprAsWritten();
13888 NamedDecl *DR = cast<DeclRefExpr>(Callee)->getDecl();
13889 ValueDecl *VD = cast_or_null<ValueDecl>(
13890 getDerived().TransformDecl(DR->getLocation(), DR));
13894 if (!isa<CXXMethodDecl>(VD))
13895 Functions.addDecl(VD);
13897 return getDerived().RebuildCXXOperatorCallExpr(
13898 E->getOperator(),
E->getOperatorLoc(),
Callee->getBeginLoc(),
13899 false, Functions,
First.get(), Second.get());
13902template<
typename Derived>
13904TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *
E) {
13905 return getDerived().TransformCallExpr(
E);
13908template <
typename Derived>
13909ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *
E) {
13911 getSema().CurContext !=
E->getParentContext();
13913 if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
13916 return getDerived().RebuildSourceLocExpr(
E->getIdentKind(),
E->
getType(),
13918 getSema().CurContext);
13921template <
typename Derived>
13922ExprResult TreeTransform<Derived>::TransformEmbedExpr(EmbedExpr *
E) {
13926template<
typename Derived>
13928TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *
E) {
13935 ExprResult EC = getDerived().TransformCallExpr(
E->getConfig());
13936 if (EC.isInvalid())
13940 bool ArgChanged =
false;
13942 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
13946 if (!getDerived().AlwaysRebuild() &&
13947 Callee.get() ==
E->getCallee() &&
13952 SourceLocation FakeLParenLoc
13954 return getDerived().RebuildCallExpr(
Callee.get(), FakeLParenLoc,
13956 E->getRParenLoc(), EC.get());
13959template<
typename Derived>
13967 = getDerived().TransformExpr(
E->getSubExprAsWritten());
13971 if (!getDerived().AlwaysRebuild() &&
13972 Type ==
E->getTypeInfoAsWritten() &&
13973 SubExpr.
get() ==
E->getSubExpr())
13975 return getDerived().RebuildCXXNamedCastExpr(
13976 E->getOperatorLoc(),
E->
getStmtClass(),
E->getAngleBrackets().getBegin(),
13977 Type,
E->getAngleBrackets().getEnd(),
13979 E->getAngleBrackets().getEnd(), SubExpr.
get(),
E->getRParenLoc());
13982template<
typename Derived>
13991 if (Sub.isInvalid())
13994 return getDerived().RebuildBuiltinBitCastExpr(BCE->
getBeginLoc(), TSI,
13998template<
typename Derived>
14000TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *
E) {
14001 return getDerived().TransformCXXNamedCastExpr(
E);
14004template<
typename Derived>
14006TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *
E) {
14007 return getDerived().TransformCXXNamedCastExpr(
E);
14010template<
typename Derived>
14012TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
14013 CXXReinterpretCastExpr *
E) {
14014 return getDerived().TransformCXXNamedCastExpr(
E);
14017template<
typename Derived>
14019TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *
E) {
14020 return getDerived().TransformCXXNamedCastExpr(
E);
14023template<
typename Derived>
14025TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *
E) {
14026 return getDerived().TransformCXXNamedCastExpr(
E);
14029template<
typename Derived>
14031TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
14032 CXXFunctionalCastExpr *
E) {
14033 TypeSourceInfo *
Type =
14034 getDerived().TransformTypeWithDeducedTST(
E->getTypeInfoAsWritten());
14039 = getDerived().TransformExpr(
E->getSubExprAsWritten());
14040 if (SubExpr.isInvalid())
14043 if (!getDerived().AlwaysRebuild() &&
14044 Type ==
E->getTypeInfoAsWritten() &&
14045 SubExpr.get() ==
E->getSubExpr())
14048 return getDerived().RebuildCXXFunctionalCastExpr(Type,
14052 E->isListInitialization());
14055template<
typename Derived>
14057TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *
E) {
14058 if (
E->isTypeOperand()) {
14059 TypeSourceInfo *TInfo
14060 = getDerived().TransformType(
E->getTypeOperandSourceInfo());
14064 if (!getDerived().AlwaysRebuild() &&
14065 TInfo ==
E->getTypeOperandSourceInfo())
14075 Expr *Op =
E->getExprOperand();
14078 if (
auto *RecordT = Op->getType()->getAs<RecordType>())
14079 if (cast<CXXRecordDecl>(RecordT->getDecl())->isPolymorphic())
14082 EnterExpressionEvaluationContext
Unevaluated(SemaRef, EvalCtx,
14085 ExprResult SubExpr = getDerived().TransformExpr(Op);
14086 if (SubExpr.isInvalid())
14089 if (!getDerived().AlwaysRebuild() &&
14090 SubExpr.get() ==
E->getExprOperand())
14097template<
typename Derived>
14099TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *
E) {
14100 if (
E->isTypeOperand()) {
14101 TypeSourceInfo *TInfo
14102 = getDerived().TransformType(
E->getTypeOperandSourceInfo());
14106 if (!getDerived().AlwaysRebuild() &&
14107 TInfo ==
E->getTypeOperandSourceInfo())
14117 ExprResult SubExpr = getDerived().TransformExpr(
E->getExprOperand());
14118 if (SubExpr.isInvalid())
14121 if (!getDerived().AlwaysRebuild() &&
14122 SubExpr.get() ==
E->getExprOperand())
14129template<
typename Derived>
14131TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *
E) {
14135template<
typename Derived>
14137TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
14138 CXXNullPtrLiteralExpr *
E) {
14142template<
typename Derived>
14144TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *
E) {
14155 QualType
T = [&]() {
14156 auto &S = getSema();
14157 if (
E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
14160 return getDerived().TransformType(
E->
getType());
14164 if (!getDerived().AlwaysRebuild() &&
T ==
E->
getType()) {
14167 getSema().MarkThisReferenced(
E);
14171 return getDerived().RebuildCXXThisExpr(
E->
getBeginLoc(),
T,
E->isImplicit());
14174template<
typename Derived>
14176TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *
E) {
14177 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
14178 if (SubExpr.isInvalid())
14181 if (!getDerived().AlwaysRebuild() &&
14182 SubExpr.get() ==
E->getSubExpr())
14185 return getDerived().RebuildCXXThrowExpr(
E->getThrowLoc(), SubExpr.get(),
14186 E->isThrownVariableInScope());
14189template<
typename Derived>
14191TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *
E) {
14192 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
14193 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getParam()));
14198 if (
E->hasRewrittenInit()) {
14199 InitRes = getDerived().TransformExpr(
E->getRewrittenExpr());
14200 if (InitRes.isInvalid())
14204 if (!getDerived().AlwaysRebuild() && Param ==
E->getParam() &&
14206 InitRes.get() ==
E->getRewrittenExpr())
14209 return getDerived().RebuildCXXDefaultArgExpr(
E->getUsedLocation(), Param,
14213template<
typename Derived>
14215TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *
E) {
14216 FieldDecl *
Field = cast_or_null<FieldDecl>(
14217 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getField()));
14221 if (!getDerived().AlwaysRebuild() && Field ==
E->getField() &&
14225 return getDerived().RebuildCXXDefaultInitExpr(
E->
getExprLoc(), Field);
14228template<
typename Derived>
14230TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
14231 CXXScalarValueInitExpr *
E) {
14232 TypeSourceInfo *
T = getDerived().TransformType(
E->getTypeSourceInfo());
14236 if (!getDerived().AlwaysRebuild() &&
14237 T ==
E->getTypeSourceInfo())
14240 return getDerived().RebuildCXXScalarValueInitExpr(
T,
14241 T->getTypeLoc().getEndLoc(),
14242 E->getRParenLoc());
14245template<
typename Derived>
14247TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *
E) {
14249 TypeSourceInfo *AllocTypeInfo =
14250 getDerived().TransformTypeWithDeducedTST(
E->getAllocatedTypeSourceInfo());
14251 if (!AllocTypeInfo)
14255 std::optional<Expr *> ArraySize;
14256 if (
E->isArray()) {
14258 if (std::optional<Expr *> OldArraySize =
E->getArraySize()) {
14259 NewArraySize = getDerived().TransformExpr(*OldArraySize);
14260 if (NewArraySize.isInvalid())
14263 ArraySize = NewArraySize.get();
14267 bool ArgumentChanged =
false;
14269 if (getDerived().TransformExprs(
E->getPlacementArgs(),
14270 E->getNumPlacementArgs(),
true,
14271 PlacementArgs, &ArgumentChanged))
14275 Expr *OldInit =
E->getInitializer();
14278 NewInit = getDerived().TransformInitializer(OldInit,
true);
14279 if (NewInit.isInvalid())
14283 FunctionDecl *OperatorNew =
nullptr;
14284 if (
E->getOperatorNew()) {
14285 OperatorNew = cast_or_null<FunctionDecl>(
14286 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getOperatorNew()));
14291 FunctionDecl *OperatorDelete =
nullptr;
14292 if (
E->getOperatorDelete()) {
14293 OperatorDelete = cast_or_null<FunctionDecl>(
14294 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getOperatorDelete()));
14295 if (!OperatorDelete)
14299 if (!getDerived().AlwaysRebuild() &&
14300 AllocTypeInfo ==
E->getAllocatedTypeSourceInfo() &&
14301 ArraySize ==
E->getArraySize() &&
14302 NewInit.get() == OldInit &&
14303 OperatorNew ==
E->getOperatorNew() &&
14304 OperatorDelete ==
E->getOperatorDelete() &&
14305 !ArgumentChanged) {
14310 if (OperatorDelete)
14313 if (
E->isArray() && !
E->getAllocatedType()->isDependentType()) {
14314 QualType ElementType
14316 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
14317 CXXRecordDecl *
Record = cast<CXXRecordDecl>(RecordT->getDecl());
14327 QualType AllocType = AllocTypeInfo->
getType();
14337 }
else if (
const ConstantArrayType *ConsArrayT
14338 = dyn_cast<ConstantArrayType>(ArrayT)) {
14342 AllocType = ConsArrayT->getElementType();
14343 }
else if (
const DependentSizedArrayType *DepArrayT
14344 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
14345 if (DepArrayT->getSizeExpr()) {
14346 ArraySize = DepArrayT->getSizeExpr();
14347 AllocType = DepArrayT->getElementType();
14352 return getDerived().RebuildCXXNewExpr(
14356 AllocTypeInfo, ArraySize,
E->getDirectInitRange(), NewInit.get());
14359template<
typename Derived>
14361TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *
E) {
14367 FunctionDecl *OperatorDelete =
nullptr;
14368 if (
E->getOperatorDelete()) {
14369 OperatorDelete = cast_or_null<FunctionDecl>(
14370 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getOperatorDelete()));
14371 if (!OperatorDelete)
14375 if (!getDerived().AlwaysRebuild() &&
14376 Operand.get() ==
E->getArgument() &&
14377 OperatorDelete ==
E->getOperatorDelete()) {
14380 if (OperatorDelete)
14385 E->getDestroyedType());
14386 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
14387 CXXRecordDecl *
Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
14396 return getDerived().RebuildCXXDeleteExpr(
14400template<
typename Derived>
14402TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
14403 CXXPseudoDestructorExpr *
E) {
14405 if (
Base.isInvalid())
14409 bool MayBePseudoDestructor =
false;
14411 E->getOperatorLoc(),
14412 E->isArrow()? tok::arrow : tok::period,
14414 MayBePseudoDestructor);
14415 if (
Base.isInvalid())
14418 QualType ObjectType = ObjectTypePtr.get();
14419 NestedNameSpecifierLoc QualifierLoc =
E->getQualifierLoc();
14420 if (QualifierLoc) {
14422 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
14427 SS.Adopt(QualifierLoc);
14429 PseudoDestructorTypeStorage Destroyed;
14430 if (
E->getDestroyedTypeInfo()) {
14431 TypeSourceInfo *DestroyedTypeInfo
14432 = getDerived().TransformTypeInObjectScope(
E->getDestroyedTypeInfo(),
14433 ObjectType,
nullptr, SS);
14434 if (!DestroyedTypeInfo)
14436 Destroyed = DestroyedTypeInfo;
14437 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
14440 Destroyed = PseudoDestructorTypeStorage(
E->getDestroyedTypeIdentifier(),
14441 E->getDestroyedTypeLoc());
14445 *
E->getDestroyedTypeIdentifier(),
E->getDestroyedTypeLoc(),
14446 nullptr, SS, ObjectTypePtr,
false);
14452 E->getDestroyedTypeLoc());
14455 TypeSourceInfo *ScopeTypeInfo =
nullptr;
14456 if (
E->getScopeTypeInfo()) {
14457 CXXScopeSpec EmptySS;
14458 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
14459 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
14460 if (!ScopeTypeInfo)
14464 return getDerived().RebuildCXXPseudoDestructorExpr(
Base.get(),
14465 E->getOperatorLoc(),
14469 E->getColonColonLoc(),
14474template <
typename Derived>
14479 bool AllEmptyPacks =
true;
14480 for (
auto *OldD : Old->
decls()) {
14481 Decl *InstD = getDerived().TransformDecl(Old->
getNameLoc(), OldD);
14485 if (isa<UsingShadowDecl>(OldD))
14494 NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
14496 if (
auto *UPD = dyn_cast<UsingPackDecl>(InstD))
14497 Decls = UPD->expansions();
14500 for (
auto *
D : Decls) {
14501 if (
auto *UD = dyn_cast<UsingDecl>(
D)) {
14502 for (
auto *SD : UD->shadows())
14509 AllEmptyPacks &= Decls.empty();
14518 if (AllEmptyPacks && !RequiresADL) {
14519 getSema().Diag(Old->
getNameLoc(), diag::err_using_pack_expansion_empty)
14520 << isa<UnresolvedMemberExpr>(Old) << Old->
getName();
14530 getSema().FilterAcceptableTemplateNames(R,
14537 diag::err_template_kw_refers_to_non_template)
14541 diag::note_template_kw_refers_to_non_template)
14550template <
typename Derived>
14553 return TransformUnresolvedLookupExpr(Old,
false);
14556template <
typename Derived>
14559 bool IsAddressOfOperand) {
14564 if (TransformOverloadExprDecls(Old, Old->
requiresADL(), R))
14571 = getDerived().TransformNestedNameSpecifierLoc(Old->
getQualifierLoc());
14575 SS.
Adopt(QualifierLoc);
14579 CXXRecordDecl *NamingClass
14580 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
14583 if (!NamingClass) {
14588 R.setNamingClass(NamingClass);
14609 SS, TemplateKWLoc, R,
14616 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->
requiresADL());
14619 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
14623template<
typename Derived>
14625TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *
E) {
14626 bool ArgChanged =
false;
14628 for (
unsigned I = 0, N =
E->getNumArgs(); I != N; ++I) {
14629 TypeSourceInfo *From =
E->getArg(I);
14630 TypeLoc FromTL = From->getTypeLoc();
14631 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
14632 TypeLocBuilder TLB;
14633 TLB.reserve(FromTL.getFullDataSize());
14634 QualType To = getDerived().TransformType(TLB, FromTL);
14638 if (To == From->getType())
14639 Args.push_back(From);
14641 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14650 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
14651 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
14657 bool Expand =
true;
14658 bool RetainExpansion =
false;
14659 std::optional<unsigned> OrigNumExpansions =
14660 ExpansionTL.getTypePtr()->getNumExpansions();
14661 std::optional<unsigned> NumExpansions = OrigNumExpansions;
14662 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
14663 PatternTL.getSourceRange(),
14665 Expand, RetainExpansion,
14673 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
14675 TypeLocBuilder TLB;
14676 TLB.reserve(From->getTypeLoc().getFullDataSize());
14678 QualType To = getDerived().TransformType(TLB, PatternTL);
14682 To = getDerived().RebuildPackExpansionType(To,
14683 PatternTL.getSourceRange(),
14684 ExpansionTL.getEllipsisLoc(),
14689 PackExpansionTypeLoc ToExpansionTL
14690 = TLB.push<PackExpansionTypeLoc>(To);
14691 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14692 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14698 for (
unsigned I = 0; I != *NumExpansions; ++I) {
14699 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
14700 TypeLocBuilder TLB;
14701 TLB.reserve(PatternTL.getFullDataSize());
14702 QualType To = getDerived().TransformType(TLB, PatternTL);
14706 if (To->containsUnexpandedParameterPack()) {
14707 To = getDerived().RebuildPackExpansionType(To,
14708 PatternTL.getSourceRange(),
14709 ExpansionTL.getEllipsisLoc(),
14714 PackExpansionTypeLoc ToExpansionTL
14715 = TLB.push<PackExpansionTypeLoc>(To);
14716 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14719 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14722 if (!RetainExpansion)
14727 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
14729 TypeLocBuilder TLB;
14730 TLB.reserve(From->getTypeLoc().getFullDataSize());
14732 QualType To = getDerived().TransformType(TLB, PatternTL);
14736 To = getDerived().RebuildPackExpansionType(To,
14737 PatternTL.getSourceRange(),
14738 ExpansionTL.getEllipsisLoc(),
14743 PackExpansionTypeLoc ToExpansionTL
14744 = TLB.push<PackExpansionTypeLoc>(To);
14745 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14746 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14749 if (!getDerived().AlwaysRebuild() && !ArgChanged)
14752 return getDerived().RebuildTypeTrait(
E->getTrait(),
E->
getBeginLoc(), Args,
14756template<
typename Derived>
14758TreeTransform<Derived>::TransformConceptSpecializationExpr(
14759 ConceptSpecializationExpr *
E) {
14760 const ASTTemplateArgumentListInfo *Old =
E->getTemplateArgsAsWritten();
14761 TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
14762 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
14763 Old->NumTemplateArgs, TransArgs))
14766 return getDerived().RebuildConceptSpecializationExpr(
14767 E->getNestedNameSpecifierLoc(),
E->getTemplateKWLoc(),
14768 E->getConceptNameInfo(),
E->getFoundDecl(),
E->getNamedConcept(),
14772template<
typename Derived>
14774TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *
E) {
14777 Sema::ExtParameterInfoBuilder ExtParamInfos;
14781 EnterExpressionEvaluationContext Ctx(
14786 getSema().Context, getSema().CurContext,
14789 Sema::ContextRAII SavedContext(getSema(), Body,
false);
14791 ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
14792 E->getRequiresKWLoc(),
E->getRBraceLoc(),
E, Body,
14793 E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);
14795 for (ParmVarDecl *Param : TransParams)
14797 Param->setDeclContext(Body);
14803 if (!TypeParamResult.isUnset())
14804 return TypeParamResult;
14807 if (getDerived().TransformRequiresExprRequirements(
E->getRequirements(),
14811 for (concepts::Requirement *Req : TransReqs) {
14812 if (
auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
14813 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
14814 ER->getReturnTypeRequirement()
14815 .getTypeConstraintTemplateParameterList()->getParam(0)
14816 ->setDeclContext(Body);
14821 return getDerived().RebuildRequiresExpr(
14822 E->getRequiresKWLoc(), Body,
E->getLParenLoc(), TransParams,
14823 E->getRParenLoc(), TransReqs,
E->getRBraceLoc());
14826template<
typename Derived>
14832 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
14833 TransReq = getDerived().TransformTypeRequirement(TypeReq);
14834 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
14835 TransReq = getDerived().TransformExprRequirement(ExprReq);
14837 TransReq = getDerived().TransformNestedRequirement(
14838 cast<concepts::NestedRequirement>(Req));
14841 Transformed.push_back(TransReq);
14846template<
typename Derived>
14851 if (getDerived().AlwaysRebuild())
14852 return getDerived().RebuildTypeRequirement(
14859 return getDerived().RebuildTypeRequirement(TransType);
14862template<
typename Derived>
14865 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
14874 TransExpr = TransExprRes.
get();
14877 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
14879 if (RetReq.isEmpty())
14880 TransRetReq.emplace();
14881 else if (RetReq.isSubstitutionFailure())
14882 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
14883 else if (RetReq.isTypeConstraint()) {
14885 RetReq.getTypeConstraintTemplateParameterList();
14887 getDerived().TransformTemplateParameterList(OrigTPL);
14890 TransRetReq.emplace(TPL);
14892 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
14893 if (
Expr *
E = TransExpr.dyn_cast<
Expr *>())
14894 return getDerived().RebuildExprRequirement(
E, Req->
isSimple(),
14896 std::move(*TransRetReq));
14897 return getDerived().RebuildExprRequirement(
14898 cast<concepts::Requirement::SubstitutionDiagnostic *>(TransExpr),
14902template<
typename Derived>
14907 if (getDerived().AlwaysRebuild())
14908 return getDerived().RebuildNestedRequirement(
14916 return getDerived().RebuildNestedRequirement(TransConstraint.
get());
14919template<
typename Derived>
14922 TypeSourceInfo *
T = getDerived().TransformType(
E->getQueriedTypeSourceInfo());
14926 if (!getDerived().AlwaysRebuild() &&
14927 T ==
E->getQueriedTypeSourceInfo())
14934 SubExpr = getDerived().TransformExpr(
E->getDimensionExpression());
14938 if (!getDerived().AlwaysRebuild() && SubExpr.
get() ==
E->getDimensionExpression())
14942 return getDerived().RebuildArrayTypeTrait(
E->getTrait(),
E->
getBeginLoc(),
T,
14946template<
typename Derived>
14948TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *
E) {
14953 SubExpr = getDerived().TransformExpr(
E->getQueriedExpression());
14954 if (SubExpr.isInvalid())
14957 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getQueriedExpression())
14961 return getDerived().RebuildExpressionTrait(
E->getTrait(),
E->
getBeginLoc(),
14965template <
typename Derived>
14969 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
14970 DRE, AddrTaken, RecoveryTSI);
14977 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
14979 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
14983template <
typename Derived>
14986 return TransformDependentScopeDeclRefExpr(
E,
false,
14990template <
typename Derived>
14994 assert(
E->getQualifierLoc());
14996 getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
15006 getDerived().TransformDeclarationNameInfo(
E->getNameInfo());
15010 if (!
E->hasExplicitTemplateArgs()) {
15011 if (!getDerived().AlwaysRebuild() && QualifierLoc ==
E->getQualifierLoc() &&
15014 NameInfo.
getName() ==
E->getDeclName())
15017 return getDerived().RebuildDependentScopeDeclRefExpr(
15018 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
15019 IsAddressOfOperand, RecoveryTSI);
15022 TemplateArgumentListInfo TransArgs(
E->getLAngleLoc(),
E->getRAngleLoc());
15023 if (getDerived().TransformTemplateArguments(
15024 E->getTemplateArgs(),
E->getNumTemplateArgs(), TransArgs))
15027 return getDerived().RebuildDependentScopeDeclRefExpr(
15028 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
15032template<
typename Derived>
15034TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *
E) {
15038 if (getDerived().AllowSkippingCXXConstructExpr() &&
15039 ((
E->getNumArgs() == 1 ||
15040 (
E->getNumArgs() > 1 && getDerived().DropCallArgument(
E->getArg(1)))) &&
15041 (!getDerived().DropCallArgument(
E->getArg(0))) &&
15042 !
E->isListInitialization()))
15043 return getDerived().TransformInitializer(
E->getArg(0),
15046 TemporaryBase Rebase(*
this,
E->
getBeginLoc(), DeclarationName());
15048 QualType
T = getDerived().TransformType(
E->
getType());
15052 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
15053 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
15057 bool ArgumentChanged =
false;
15060 EnterExpressionEvaluationContext Context(
15062 E->isListInitialization());
15063 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
15068 if (!getDerived().AlwaysRebuild() &&
15070 Constructor ==
E->getConstructor() &&
15071 !ArgumentChanged) {
15078 return getDerived().RebuildCXXConstructExpr(
15080 E->hadMultipleCandidates(),
E->isListInitialization(),
15081 E->isStdInitListInitialization(),
E->requiresZeroInitialization(),
15082 E->getConstructionKind(),
E->getParenOrBraceRange());
15085template<
typename Derived>
15086ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
15087 CXXInheritedCtorInitExpr *
E) {
15088 QualType
T = getDerived().TransformType(
E->
getType());
15092 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
15093 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
15097 if (!getDerived().AlwaysRebuild() &&
15099 Constructor ==
E->getConstructor()) {
15106 return getDerived().RebuildCXXInheritedCtorInitExpr(
15107 T,
E->getLocation(), Constructor,
15108 E->constructsVBase(),
E->inheritedFromVBase());
15115template<
typename Derived>
15117TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *
E) {
15118 if (
auto *Dtor =
E->getTemporary()->getDestructor())
15120 const_cast<CXXDestructorDecl *
>(Dtor));
15121 return getDerived().TransformExpr(
E->getSubExpr());
15129template<
typename Derived>
15131TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *
E) {
15132 return getDerived().TransformExpr(
E->getSubExpr());
15135template<
typename Derived>
15137TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
15138 CXXTemporaryObjectExpr *
E) {
15139 TypeSourceInfo *
T =
15140 getDerived().TransformTypeWithDeducedTST(
E->getTypeSourceInfo());
15144 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
15145 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
15149 bool ArgumentChanged =
false;
15151 Args.reserve(
E->getNumArgs());
15153 EnterExpressionEvaluationContext Context(
15155 E->isListInitialization());
15156 if (TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
15160 if (
E->isListInitialization() && !
E->isStdInitListInitialization()) {
15162 if (Res.isInvalid())
15164 Args = {Res.get()};
15168 if (!getDerived().AlwaysRebuild() &&
15169 T ==
E->getTypeSourceInfo() &&
15170 Constructor ==
E->getConstructor() &&
15171 !ArgumentChanged) {
15177 SourceLocation LParenLoc =
T->getTypeLoc().getEndLoc();
15178 return getDerived().RebuildCXXTemporaryObjectExpr(
15179 T, LParenLoc, Args,
E->
getEndLoc(),
E->isListInitialization());
15182template<
typename Derived>
15184TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *
E) {
15187 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
15188 struct TransformedInitCapture {
15190 SourceLocation EllipsisLoc;
15195 InitCaptures.resize(
E->explicit_capture_end() -
E->explicit_capture_begin());
15197 CEnd =
E->capture_end();
15199 if (!
E->isInitCapture(
C))
15202 TransformedInitCapture &
Result = InitCaptures[
C -
E->capture_begin()];
15203 auto *OldVD = cast<VarDecl>(
C->getCapturedVar());
15205 auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
15206 std::optional<unsigned> NumExpansions) {
15207 ExprResult NewExprInitResult = getDerived().TransformInitializer(
15210 if (NewExprInitResult.isInvalid()) {
15211 Result.Expansions.push_back(InitCaptureInfoTy(
ExprError(), QualType()));
15214 Expr *NewExprInit = NewExprInitResult.get();
15216 QualType NewInitCaptureType =
15217 getSema().buildLambdaInitCaptureInitialization(
15218 C->getLocation(),
C->getCaptureKind() ==
LCK_ByRef,
15219 EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
15220 cast<VarDecl>(
C->getCapturedVar())->getInitStyle() !=
15223 Result.Expansions.push_back(
15224 InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
15228 if (OldVD->isParameterPack()) {
15229 PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
15231 .castAs<PackExpansionTypeLoc>();
15237 bool Expand =
true;
15238 bool RetainExpansion =
false;
15239 std::optional<unsigned> OrigNumExpansions =
15240 ExpansionTL.getTypePtr()->getNumExpansions();
15241 std::optional<unsigned> NumExpansions = OrigNumExpansions;
15242 if (getDerived().TryExpandParameterPacks(
15243 ExpansionTL.getEllipsisLoc(),
15244 OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
15245 RetainExpansion, NumExpansions))
15247 assert(!RetainExpansion &&
"Should not need to retain expansion after a "
15248 "capture since it cannot be extended");
15250 for (
unsigned I = 0; I != *NumExpansions; ++I) {
15251 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
15252 SubstInitCapture(SourceLocation(), std::nullopt);
15255 SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
15256 Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
15259 SubstInitCapture(SourceLocation(), std::nullopt);
15263 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
15264 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
15275 DeclContext *DC = getSema().CurContext;
15293 while (DC->isRequiresExprBody())
15294 DC = DC->getParent();
15295 if ((getSema().isUnevaluatedContext() ||
15296 getSema().isConstantEvaluatedContext()) &&
15297 (DC->isFileContext() || !DC->getParent()->isDependentContext()))
15300 CXXRecordDecl *OldClass =
E->getLambdaClass();
15301 CXXRecordDecl *
Class = getSema().createLambdaClosureType(
15302 E->getIntroducerRange(),
nullptr, DependencyKind,
15303 E->getCaptureDefault());
15304 getDerived().transformedLocalDecl(OldClass, {
Class});
15306 CXXMethodDecl *NewCallOperator =
15307 getSema().CreateLambdaCallOperator(
E->getIntroducerRange(),
Class);
15310 getSema().buildLambdaScope(LSI, NewCallOperator,
E->getIntroducerRange(),
15311 E->getCaptureDefault(),
E->getCaptureDefaultLoc(),
15312 E->hasExplicitParameters(),
E->isMutable());
15315 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
15322 CEnd =
E->capture_end();
15326 if (
C->isImplicit())
15330 if (
C->capturesThis()) {
15336 Sema::CXXThisScopeRAII ThisScope(
15338 dyn_cast_if_present<CXXRecordDecl>(
15339 getSema().getFunctionLevelDeclContext()),
15341 getSema().CheckCXXThisCapture(
C->getLocation(),
C->isExplicit(),
15348 if (
C->capturesVLAType())
15352 if (
E->isInitCapture(
C)) {
15353 TransformedInitCapture &NewC = InitCaptures[
C -
E->capture_begin()];
15355 auto *OldVD = cast<VarDecl>(
C->getCapturedVar());
15358 for (InitCaptureInfoTy &Info : NewC.Expansions) {
15360 QualType InitQualType = Info.second;
15361 if (
Init.isInvalid() || InitQualType.isNull()) {
15365 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
15366 OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
15367 OldVD->getIdentifier(), OldVD->getInitStyle(),
Init.get(),
15368 getSema().CurContext);
15373 NewVDs.push_back(NewVD);
15374 getSema().addInitCapture(LSI, NewVD,
C->getCaptureKind() ==
LCK_ByRef);
15379 if (NewC.EllipsisLoc.isInvalid())
15380 LSI->ContainsUnexpandedParameterPack |=
15381 Init.get()->containsUnexpandedParameterPack();
15387 getDerived().transformedLocalDecl(OldVD, NewVDs);
15391 assert(
C->capturesVariable() &&
"unexpected kind of lambda capture");
15399 SourceLocation EllipsisLoc;
15400 if (
C->isPackExpansion()) {
15402 bool ShouldExpand =
false;
15403 bool RetainExpansion =
false;
15404 std::optional<unsigned> NumExpansions;
15405 if (getDerived().TryExpandParameterPacks(
C->getEllipsisLoc(),
15408 ShouldExpand, RetainExpansion,
15414 if (ShouldExpand) {
15418 auto *Pack = cast<VarDecl>(
C->getCapturedVar());
15419 for (
unsigned I = 0; I != *NumExpansions; ++I) {
15420 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
15421 VarDecl *CapturedVar
15422 = cast_or_null<VarDecl>(getDerived().TransformDecl(
C->getLocation(),
15424 if (!CapturedVar) {
15430 getSema().tryCaptureVariable(CapturedVar,
C->getLocation(), Kind);
15438 EllipsisLoc =
C->getEllipsisLoc();
15442 auto *CapturedVar = cast_or_null<ValueDecl>(
15443 getDerived().TransformDecl(
C->getLocation(),
C->getCapturedVar()));
15444 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
15451 if (
auto *VD = dyn_cast<VarDecl>(CapturedVar); VD && !
C->isPackExpansion())
15452 LSI->ContainsUnexpandedParameterPack |= VD->isParameterPack();
15455 getSema().tryCaptureVariable(CapturedVar,
C->getLocation(), Kind,
15458 getSema().finishLambdaExplicitCaptures(LSI);
15462 auto TPL = getDerived().TransformTemplateParameterList(
15463 E->getTemplateParameterList());
15464 LSI->GLTemplateParameterList = TPL;
15466 getSema().AddTemplateParametersToLambdaCallOperator(NewCallOperator,
Class,
15468 LSI->ContainsUnexpandedParameterPack |=
15469 TPL->containsUnexpandedParameterPack();
15472 TypeLocBuilder NewCallOpTLBuilder;
15473 TypeLoc OldCallOpTypeLoc =
15474 E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
15475 QualType NewCallOpType =
15476 getDerived().TransformType(NewCallOpTLBuilder, OldCallOpTypeLoc);
15477 if (NewCallOpType.isNull())
15479 LSI->ContainsUnexpandedParameterPack |=
15480 NewCallOpType->containsUnexpandedParameterPack();
15481 TypeSourceInfo *NewCallOpTSI =
15482 NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType);
15486 auto FPTL = NewCallOpTSI->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>();
15487 assert(FPTL &&
"Not a FunctionProtoType?");
15489 getSema().CompleteLambdaCallOperator(
15490 NewCallOperator,
E->getCallOperator()->getLocation(),
15491 E->getCallOperator()->getInnerLocStart(),
15492 E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI,
15493 E->getCallOperator()->getConstexprKind(),
15494 E->getCallOperator()->getStorageClass(), FPTL.getParams(),
15495 E->hasExplicitResultType());
15497 getDerived().transformAttrs(
E->getCallOperator(), NewCallOperator);
15498 getDerived().transformedLocalDecl(
E->getCallOperator(), {NewCallOperator});
15502 Sema::ContextRAII ManglingContext(getSema(),
Class->getDeclContext());
15504 std::optional<CXXRecordDecl::LambdaNumbering> Numbering;
15505 if (getDerived().ReplacingOriginal()) {
15506 Numbering = OldClass->getLambdaNumbering();
15509 getSema().handleLambdaNumbering(
Class, NewCallOperator, Numbering);
15514 getSema().PushExpressionEvaluationContext(
15515 E->getCallOperator()->isConsteval() ?
15518 getSema().currentEvaluationContext().InImmediateEscalatingFunctionContext =
15519 getSema().getLangOpts().CPlusPlus20 &&
15520 E->getCallOperator()->isImmediateEscalating();
15522 Sema::CodeSynthesisContext
C;
15525 getSema().pushCodeSynthesisContext(
C);
15531 getSema().popCodeSynthesisContext();
15534 FuncScopeCleanup.disable();
15536 if (Body.isInvalid()) {
15537 SavedContext.pop();
15546 auto LSICopy = *LSI;
15547 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
15549 SavedContext.pop();
15584 DependencyKind = getDerived().ComputeLambdaDependency(&LSICopy);
15585 Class->setLambdaDependencyKind(DependencyKind);
15588 Class->setTypeForDecl(
nullptr);
15589 getSema().Context.getTypeDeclType(
Class);
15591 return getDerived().RebuildLambdaExpr(
E->
getBeginLoc(),
15592 Body.get()->getEndLoc(), &LSICopy);
15595template<
typename Derived>
15598 return TransformStmt(S);
15601template<
typename Derived>
15606 CEnd =
E->capture_end();
15610 if (!
C->isImplicit())
15614 if (
C->capturesThis()) {
15615 getSema().CheckCXXThisCapture(
C->getLocation(),
C->isExplicit(),
15622 if (
C->capturesVLAType())
15625 assert(
C->capturesVariable() &&
"unexpected kind of lambda capture");
15626 assert(!
E->isInitCapture(
C) &&
"implicit init-capture?");
15629 VarDecl *CapturedVar = cast_or_null<VarDecl>(
15630 getDerived().TransformDecl(
C->getLocation(),
C->getCapturedVar()));
15635 getSema().tryCaptureVariable(CapturedVar,
C->getLocation());
15641template<
typename Derived>
15646 getDerived().TransformTypeWithDeducedTST(
E->getTypeSourceInfo());
15650 bool ArgumentChanged =
false;
15652 Args.reserve(
E->getNumArgs());
15656 E->isListInitialization());
15657 if (getDerived().TransformExprs(
E->arg_begin(),
E->getNumArgs(),
true, Args,
15662 if (!getDerived().AlwaysRebuild() &&
15663 T ==
E->getTypeSourceInfo() &&
15668 return getDerived().RebuildCXXUnresolvedConstructExpr(
15669 T,
E->getLParenLoc(), Args,
E->getRParenLoc(),
E->isListInitialization());
15672template<
typename Derived>
15674TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
15675 CXXDependentScopeMemberExpr *
E) {
15680 QualType ObjectType;
15681 if (!
E->isImplicitAccess()) {
15682 OldBase =
E->getBase();
15683 Base = getDerived().TransformExpr(OldBase);
15684 if (
Base.isInvalid())
15689 bool MayBePseudoDestructor =
false;
15691 E->getOperatorLoc(),
15692 E->isArrow()? tok::arrow : tok::period,
15694 MayBePseudoDestructor);
15695 if (
Base.isInvalid())
15698 ObjectType = ObjectTy.get();
15699 BaseType = ((Expr*)
Base.get())->getType();
15702 BaseType = getDerived().TransformType(
E->getBaseType());
15708 NamedDecl *FirstQualifierInScope
15709 = getDerived().TransformFirstQualifierInScope(
15710 E->getFirstQualifierFoundInScope(),
15713 NestedNameSpecifierLoc QualifierLoc;
15714 if (
E->getQualifier()) {
15716 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc(),
15718 FirstQualifierInScope);
15723 SourceLocation TemplateKWLoc =
E->getTemplateKeywordLoc();
15729 DeclarationNameInfo NameInfo
15730 = getDerived().TransformDeclarationNameInfo(
E->getMemberNameInfo());
15731 if (!NameInfo.getName())
15734 if (!
E->hasExplicitTemplateArgs()) {
15737 if (!getDerived().AlwaysRebuild() &&
15738 Base.get() == OldBase &&
15739 BaseType ==
E->getBaseType() &&
15740 QualifierLoc ==
E->getQualifierLoc() &&
15741 NameInfo.getName() ==
E->getMember() &&
15742 FirstQualifierInScope ==
E->getFirstQualifierFoundInScope())
15745 return getDerived().RebuildCXXDependentScopeMemberExpr(
Base.get(),
15748 E->getOperatorLoc(),
15751 FirstQualifierInScope,
15756 TemplateArgumentListInfo TransArgs(
E->getLAngleLoc(),
E->getRAngleLoc());
15757 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
15758 E->getNumTemplateArgs(),
15762 return getDerived().RebuildCXXDependentScopeMemberExpr(
Base.get(),
15765 E->getOperatorLoc(),
15768 FirstQualifierInScope,
15773template <
typename Derived>
15774ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
15775 UnresolvedMemberExpr *Old) {
15779 if (!Old->isImplicitAccess()) {
15780 Base = getDerived().TransformExpr(Old->getBase());
15781 if (
Base.isInvalid())
15784 getSema().PerformMemberExprBaseConversion(
Base.get(), Old->isArrow());
15785 if (
Base.isInvalid())
15787 BaseType =
Base.get()->getType();
15789 BaseType = getDerived().TransformType(Old->getBaseType());
15792 NestedNameSpecifierLoc QualifierLoc;
15793 if (Old->getQualifierLoc()) {
15795 getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
15800 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
15805 if (TransformOverloadExprDecls(Old,
false, R))
15809 if (Old->getNamingClass()) {
15810 CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
15811 getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
15815 R.setNamingClass(NamingClass);
15818 TemplateArgumentListInfo TransArgs;
15819 if (Old->hasExplicitTemplateArgs()) {
15820 TransArgs.setLAngleLoc(Old->getLAngleLoc());
15821 TransArgs.setRAngleLoc(Old->getRAngleLoc());
15822 if (getDerived().TransformTemplateArguments(
15823 Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
15831 NamedDecl *FirstQualifierInScope =
nullptr;
15833 return getDerived().RebuildUnresolvedMemberExpr(
15834 Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
15835 TemplateKWLoc, FirstQualifierInScope, R,
15836 (Old->hasExplicitTemplateArgs() ? &TransArgs :
nullptr));
15839template<
typename Derived>
15841TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *
E) {
15844 ExprResult SubExpr = getDerived().TransformExpr(
E->getOperand());
15845 if (SubExpr.isInvalid())
15848 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getOperand())
15851 return getDerived().RebuildCXXNoexceptExpr(
E->
getSourceRange(),SubExpr.get());
15854template<
typename Derived>
15856TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *
E) {
15857 ExprResult Pattern = getDerived().TransformExpr(
E->getPattern());
15858 if (Pattern.isInvalid())
15861 if (!getDerived().AlwaysRebuild() && Pattern.get() ==
E->getPattern())
15864 return getDerived().RebuildPackExpansion(Pattern.get(),
E->getEllipsisLoc(),
15865 E->getNumExpansions());
15868template<
typename Derived>
15870TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *
E) {
15880 TemplateArgument ArgStorage;
15883 if (
E->isPartiallySubstituted()) {
15884 PackArgs =
E->getPartialArguments();
15887 bool ShouldExpand =
false;
15888 bool RetainExpansion =
false;
15889 std::optional<unsigned> NumExpansions;
15890 if (getDerived().TryExpandParameterPacks(
E->getOperatorLoc(),
E->getPackLoc(),
15892 ShouldExpand, RetainExpansion,
15898 if (ShouldExpand) {
15899 auto *Pack =
E->getPack();
15900 if (
auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
15901 ArgStorage = getSema().Context.getPackExpansionType(
15903 }
else if (
auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
15904 ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
15906 auto *VD = cast<ValueDecl>(Pack);
15907 ExprResult DRE = getSema().BuildDeclRefExpr(
15908 VD, VD->getType().getNonLValueExprType(getSema().Context),
15911 if (DRE.isInvalid())
15913 ArgStorage =
new (getSema().Context)
15914 PackExpansionExpr(getSema().Context.DependentTy, DRE.get(),
15915 E->getPackLoc(), std::nullopt);
15917 PackArgs = ArgStorage;
15922 if (!PackArgs.size()) {
15923 auto *Pack = cast_or_null<NamedDecl>(
15924 getDerived().TransformDecl(
E->getPackLoc(),
E->getPack()));
15927 return getDerived().RebuildSizeOfPackExpr(
15928 E->getOperatorLoc(), Pack,
E->getPackLoc(),
E->getRParenLoc(),
15933 std::optional<unsigned>
Result = 0;
15934 for (
const TemplateArgument &Arg : PackArgs) {
15935 if (!Arg.isPackExpansion()) {
15940 TemplateArgumentLoc ArgLoc;
15941 InventTemplateArgumentLoc(Arg, ArgLoc);
15944 SourceLocation Ellipsis;
15945 std::optional<unsigned> OrigNumExpansions;
15946 TemplateArgumentLoc Pattern =
15947 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
15948 OrigNumExpansions);
15951 TemplateArgumentLoc OutPattern;
15952 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15953 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
15958 std::optional<unsigned> NumExpansions =
15959 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
15960 if (!NumExpansions) {
15973 return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(),
E->getPack(),
15975 E->getRParenLoc(), *
Result, {});
15977 TemplateArgumentListInfo TransformedPackArgs(
E->getPackLoc(),
15980 TemporaryBase Rebase(*
this,
E->getPackLoc(), getBaseEntity());
15981 typedef TemplateArgumentLocInventIterator<
15982 Derived,
const TemplateArgument*> PackLocIterator;
15983 if (TransformTemplateArguments(PackLocIterator(*
this, PackArgs.begin()),
15984 PackLocIterator(*
this, PackArgs.end()),
15985 TransformedPackArgs,
true))
15992 bool PartialSubstitution =
false;
15993 for (
auto &
Loc : TransformedPackArgs.arguments()) {
15994 Args.push_back(
Loc.getArgument());
15995 if (
Loc.getArgument().isPackExpansion())
15996 PartialSubstitution =
true;
15999 if (PartialSubstitution)
16000 return getDerived().RebuildSizeOfPackExpr(
16001 E->getOperatorLoc(),
E->getPack(),
E->getPackLoc(),
E->getRParenLoc(),
16002 std::nullopt, Args);
16004 return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(),
E->getPack(),
16005 E->getPackLoc(),
E->getRParenLoc(),
16009template <
typename Derived>
16011TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *
E) {
16018 EnterExpressionEvaluationContext ConstantContext(
16020 IndexExpr = getDerived().TransformExpr(
E->getIndexExpr());
16021 if (IndexExpr.isInvalid())
16026 bool FullySubstituted =
true;
16027 if (!
E->expandsToEmptyPack() &&
E->getExpressions().empty()) {
16028 Expr *Pattern =
E->getPackIdExpression();
16030 getSema().collectUnexpandedParameterPacks(
E->getPackIdExpression(),
16032 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
16036 bool ShouldExpand =
true;
16037 bool RetainExpansion =
false;
16038 std::optional<unsigned> OrigNumExpansions;
16039 std::optional<unsigned> NumExpansions = OrigNumExpansions;
16040 if (getDerived().TryExpandParameterPacks(
16042 ShouldExpand, RetainExpansion, NumExpansions))
16044 if (!ShouldExpand) {
16045 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
16046 ExprResult Pack = getDerived().TransformExpr(Pattern);
16047 if (Pack.isInvalid())
16049 return getDerived().RebuildPackIndexingExpr(
16050 E->getEllipsisLoc(),
E->getRSquareLoc(), Pack.get(), IndexExpr.get(),
16053 for (
unsigned I = 0; I != *NumExpansions; ++I) {
16054 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
16055 ExprResult Out = getDerived().TransformExpr(Pattern);
16056 if (Out.isInvalid())
16058 if (Out.get()->containsUnexpandedParameterPack()) {
16059 Out = getDerived().RebuildPackExpansion(Out.get(),
E->getEllipsisLoc(),
16060 OrigNumExpansions);
16061 if (Out.isInvalid())
16063 FullySubstituted =
false;
16065 ExpandedExprs.push_back(Out.get());
16069 if (RetainExpansion) {
16070 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
16072 ExprResult Out = getDerived().TransformExpr(Pattern);
16073 if (Out.isInvalid())
16076 Out = getDerived().RebuildPackExpansion(Out.get(),
E->getEllipsisLoc(),
16077 OrigNumExpansions);
16078 if (Out.isInvalid())
16080 FullySubstituted =
false;
16081 ExpandedExprs.push_back(Out.get());
16083 }
else if (!
E->expandsToEmptyPack()) {
16084 if (getDerived().TransformExprs(
E->getExpressions().data(),
16085 E->getExpressions().size(),
false,
16090 return getDerived().RebuildPackIndexingExpr(
16091 E->getEllipsisLoc(),
E->getRSquareLoc(),
E->getPackIdExpression(),
16092 IndexExpr.get(), ExpandedExprs, FullySubstituted);
16095template<
typename Derived>
16097TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
16098 SubstNonTypeTemplateParmPackExpr *
E) {
16103template<
typename Derived>
16105TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
16106 SubstNonTypeTemplateParmExpr *
E) {
16111template<
typename Derived>
16113TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *
E) {
16118template<
typename Derived>
16120TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
16121 MaterializeTemporaryExpr *
E) {
16122 return getDerived().TransformExpr(
E->getSubExpr());
16125template<
typename Derived>
16127TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *
E) {
16128 UnresolvedLookupExpr *
Callee =
nullptr;
16129 if (Expr *OldCallee =
E->getCallee()) {
16130 ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
16131 if (CalleeResult.isInvalid())
16133 Callee = cast<UnresolvedLookupExpr>(CalleeResult.get());
16136 Expr *Pattern =
E->getPattern();
16139 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
16140 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
16144 bool Expand =
true;
16145 bool RetainExpansion =
false;
16146 std::optional<unsigned> OrigNumExpansions =
E->getNumExpansions(),
16147 NumExpansions = OrigNumExpansions;
16148 if (getDerived().TryExpandParameterPacks(
E->getEllipsisLoc(),
16151 Expand, RetainExpansion,
16158 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
16161 E->getLHS() ? getDerived().TransformExpr(
E->getLHS()) :
ExprResult();
16162 if (LHS.isInvalid())
16166 E->getRHS() ? getDerived().TransformExpr(
E->getRHS()) :
ExprResult();
16167 if (RHS.isInvalid())
16170 if (!getDerived().AlwaysRebuild() &&
16171 LHS.get() ==
E->getLHS() && RHS.get() ==
E->getRHS())
16174 return getDerived().RebuildCXXFoldExpr(
16176 E->getEllipsisLoc(), RHS.get(),
E->
getEndLoc(), NumExpansions);
16182 if (NumExpansions && SemaRef.
getLangOpts().BracketDepth < NumExpansions) {
16183 SemaRef.
Diag(
E->getEllipsisLoc(),
16184 clang::diag::err_fold_expression_limit_exceeded)
16185 << *NumExpansions << SemaRef.
getLangOpts().BracketDepth
16187 SemaRef.
Diag(
E->getEllipsisLoc(), diag::note_bracket_depth);
16196 bool LeftFold =
E->isLeftFold();
16200 if (!LeftFold && RetainExpansion) {
16201 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
16203 ExprResult Out = getDerived().TransformExpr(Pattern);
16204 if (Out.isInvalid())
16207 Result = getDerived().RebuildCXXFoldExpr(
16214 for (
unsigned I = 0; I != *NumExpansions; ++I) {
16215 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
16216 getSema(), LeftFold ? I : *NumExpansions - I - 1);
16217 ExprResult Out = getDerived().TransformExpr(Pattern);
16218 if (Out.isInvalid())
16221 if (Out.get()->containsUnexpandedParameterPack()) {
16223 Result = getDerived().RebuildCXXFoldExpr(
16225 E->getOperator(),
E->getEllipsisLoc(),
16227 OrigNumExpansions);
16228 }
else if (
Result.isUsable()) {
16230 Expr *LHS = LeftFold ?
Result.get() : Out.get();
16231 Expr *RHS = LeftFold ? Out.get() :
Result.get();
16233 UnresolvedSet<16> Functions;
16234 Functions.append(
Callee->decls_begin(),
Callee->decls_end());
16235 Result = getDerived().RebuildCXXOperatorCallExpr(
16237 E->getEllipsisLoc(),
Callee->getBeginLoc(),
Callee->requiresADL(),
16238 Functions, LHS, RHS);
16240 Result = getDerived().RebuildBinaryOperator(
E->getEllipsisLoc(),
16241 E->getOperator(), LHS, RHS);
16252 if (LeftFold && RetainExpansion) {
16253 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
16255 ExprResult Out = getDerived().TransformExpr(Pattern);
16256 if (Out.isInvalid())
16259 Result = getDerived().RebuildCXXFoldExpr(
16261 E->getEllipsisLoc(), Out.get(),
E->
getEndLoc(), OrigNumExpansions);
16266 if (ParenExpr *PE = dyn_cast_or_null<ParenExpr>(
Result.get()))
16267 PE->setIsProducedByFoldExpansion();
16272 return getDerived().RebuildEmptyCXXFoldExpr(
E->getEllipsisLoc(),
16277template <
typename Derived>
16279TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *
E) {
16282 if (TransformExprs(InitExprs.data(), InitExprs.size(),
true,
16286 return getDerived().RebuildParenListExpr(
E->
getBeginLoc(), TransformedInits,
16290template<
typename Derived>
16292TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
16293 CXXStdInitializerListExpr *
E) {
16294 return getDerived().TransformExpr(
E->getSubExpr());
16297template<
typename Derived>
16299TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *
E) {
16303template<
typename Derived>
16305TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *
E) {
16309template<
typename Derived>
16311TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *
E) {
16312 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
16313 if (SubExpr.isInvalid())
16316 if (!getDerived().AlwaysRebuild() &&
16317 SubExpr.get() ==
E->getSubExpr())
16320 return getDerived().RebuildObjCBoxedExpr(
E->
getSourceRange(), SubExpr.get());
16323template<
typename Derived>
16325TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *
E) {
16328 bool ArgChanged =
false;
16329 if (getDerived().TransformExprs(
E->getElements(),
E->getNumElements(),
16330 false, Elements, &ArgChanged))
16333 if (!getDerived().AlwaysRebuild() && !ArgChanged)
16341template<
typename Derived>
16343TreeTransform<Derived>::TransformObjCDictionaryLiteral(
16344 ObjCDictionaryLiteral *
E) {
16347 bool ArgChanged =
false;
16348 for (
unsigned I = 0, N =
E->getNumElements(); I != N; ++I) {
16349 ObjCDictionaryElement OrigElement =
E->getKeyValueElement(I);
16351 if (OrigElement.isPackExpansion()) {
16354 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
16355 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
16356 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
16360 bool Expand =
true;
16361 bool RetainExpansion =
false;
16362 std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
16363 std::optional<unsigned> NumExpansions = OrigNumExpansions;
16364 SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
16365 OrigElement.Value->getEndLoc());
16366 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
16367 PatternRange, Unexpanded, Expand,
16368 RetainExpansion, NumExpansions))
16375 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
16376 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16377 if (Key.isInvalid())
16380 if (Key.get() != OrigElement.Key)
16384 if (
Value.isInvalid())
16387 if (
Value.get() != OrigElement.Value)
16390 ObjCDictionaryElement Expansion = {
16391 Key.get(),
Value.get(), OrigElement.EllipsisLoc, NumExpansions
16393 Elements.push_back(Expansion);
16403 for (
unsigned I = 0; I != *NumExpansions; ++I) {
16404 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
16405 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16406 if (Key.isInvalid())
16410 if (
Value.isInvalid())
16413 ObjCDictionaryElement Element = {
16414 Key.get(),
Value.get(), SourceLocation(), NumExpansions
16420 if (Key.get()->containsUnexpandedParameterPack() ||
16421 Value.get()->containsUnexpandedParameterPack())
16422 Element.EllipsisLoc = OrigElement.EllipsisLoc;
16424 Elements.push_back(Element);
16434 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16435 if (Key.isInvalid())
16438 if (Key.get() != OrigElement.Key)
16443 = getDerived().TransformExpr(OrigElement.Value);
16444 if (
Value.isInvalid())
16447 if (
Value.get() != OrigElement.Value)
16450 ObjCDictionaryElement Element = {Key.get(),
Value.get(), SourceLocation(),
16452 Elements.push_back(Element);
16455 if (!getDerived().AlwaysRebuild() && !ArgChanged)
16458 return getDerived().RebuildObjCDictionaryLiteral(
E->
getSourceRange(),
16462template<
typename Derived>
16464TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *
E) {
16465 TypeSourceInfo *EncodedTypeInfo
16466 = getDerived().TransformType(
E->getEncodedTypeSourceInfo());
16467 if (!EncodedTypeInfo)
16470 if (!getDerived().AlwaysRebuild() &&
16471 EncodedTypeInfo ==
E->getEncodedTypeSourceInfo())
16474 return getDerived().RebuildObjCEncodeExpr(
E->getAtLoc(),
16476 E->getRParenLoc());
16479template<
typename Derived>
16481TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *
E) {
16486 return getDerived().TransformExpr(
E->getSubExpr());
16489template<
typename Derived>
16491TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *
E) {
16492 TypeSourceInfo *TSInfo
16493 = getDerived().TransformType(
E->getTypeInfoAsWritten());
16501 if (!getDerived().AlwaysRebuild() &&
16502 TSInfo ==
E->getTypeInfoAsWritten() &&
16503 Result.get() ==
E->getSubExpr())
16507 E->getLParenLoc(),
E->getBridgeKind(),
E->getBridgeKeywordLoc(), TSInfo,
16511template <
typename Derived>
16512ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
16513 ObjCAvailabilityCheckExpr *
E) {
16517template<
typename Derived>
16519TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *
E) {
16521 bool ArgChanged =
false;
16523 Args.reserve(
E->getNumArgs());
16524 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
false, Args,
16530 TypeSourceInfo *ReceiverTypeInfo
16531 = getDerived().TransformType(
E->getClassReceiverTypeInfo());
16532 if (!ReceiverTypeInfo)
16536 if (!getDerived().AlwaysRebuild() &&
16537 ReceiverTypeInfo ==
E->getClassReceiverTypeInfo() && !ArgChanged)
16542 E->getSelectorLocs(SelLocs);
16543 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
16546 E->getMethodDecl(),
16553 if (!
E->getMethodDecl())
16558 E->getSelectorLocs(SelLocs);
16559 return getDerived().RebuildObjCMessageExpr(
E->getSuperLoc(),
16562 E->getReceiverType(),
16563 E->getMethodDecl(),
16571 "Only class and instance messages may be instantiated");
16573 = getDerived().TransformExpr(
E->getInstanceReceiver());
16574 if (Receiver.isInvalid())
16578 if (!getDerived().AlwaysRebuild() &&
16579 Receiver.get() ==
E->getInstanceReceiver() && !ArgChanged)
16584 E->getSelectorLocs(SelLocs);
16585 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
16588 E->getMethodDecl(),
16594template<
typename Derived>
16596TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *
E) {
16600template<
typename Derived>
16602TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *
E) {
16606template<
typename Derived>
16608TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *
E) {
16611 if (
Base.isInvalid())
16617 if (!getDerived().AlwaysRebuild() &&
16618 Base.get() ==
E->getBase())
16621 return getDerived().RebuildObjCIvarRefExpr(
Base.get(),
E->getDecl(),
16623 E->isArrow(),
E->isFreeIvar());
16626template<
typename Derived>
16628TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *
E) {
16631 if (!
E->isObjectReceiver())
16636 if (
Base.isInvalid())
16642 if (!getDerived().AlwaysRebuild() &&
16643 Base.get() ==
E->getBase())
16646 if (
E->isExplicitProperty())
16647 return getDerived().RebuildObjCPropertyRefExpr(
Base.get(),
16648 E->getExplicitProperty(),
16651 return getDerived().RebuildObjCPropertyRefExpr(
Base.get(),
16653 E->getImplicitPropertyGetter(),
16654 E->getImplicitPropertySetter(),
16658template<
typename Derived>
16660TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *
E) {
16663 if (
Base.isInvalid())
16667 ExprResult Key = getDerived().TransformExpr(
E->getKeyExpr());
16668 if (Key.isInvalid())
16672 if (!getDerived().AlwaysRebuild() &&
16673 Key.get() ==
E->getKeyExpr() &&
Base.get() ==
E->getBaseExpr())
16676 return getDerived().RebuildObjCSubscriptRefExpr(
E->getRBracket(),
16677 Base.get(), Key.get(),
16678 E->getAtIndexMethodDecl(),
16679 E->setAtIndexMethodDecl());
16682template<
typename Derived>
16684TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *
E) {
16687 if (
Base.isInvalid())
16691 if (!getDerived().AlwaysRebuild() &&
16692 Base.get() ==
E->getBase())
16695 return getDerived().RebuildObjCIsaExpr(
Base.get(),
E->getIsaMemberLoc(),
16700template<
typename Derived>
16702TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *
E) {
16703 bool ArgumentChanged =
false;
16705 SubExprs.reserve(
E->getNumSubExprs());
16706 if (getDerived().TransformExprs(
E->getSubExprs(),
E->getNumSubExprs(),
false,
16707 SubExprs, &ArgumentChanged))
16710 if (!getDerived().AlwaysRebuild() &&
16714 return getDerived().RebuildShuffleVectorExpr(
E->getBuiltinLoc(),
16716 E->getRParenLoc());
16719template<
typename Derived>
16721TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *
E) {
16722 ExprResult SrcExpr = getDerived().TransformExpr(
E->getSrcExpr());
16723 if (SrcExpr.isInvalid())
16726 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeSourceInfo());
16730 if (!getDerived().AlwaysRebuild() &&
16731 Type ==
E->getTypeSourceInfo() &&
16732 SrcExpr.get() ==
E->getSrcExpr())
16735 return getDerived().RebuildConvertVectorExpr(
E->getBuiltinLoc(),
16736 SrcExpr.get(), Type,
16737 E->getRParenLoc());
16740template<
typename Derived>
16742TreeTransform<Derived>::TransformBlockExpr(BlockExpr *
E) {
16743 BlockDecl *oldBlock =
E->getBlockDecl();
16746 BlockScopeInfo *blockScope = SemaRef.
getCurBlock();
16749 blockScope->TheDecl->setBlockMissingReturnType(
16750 oldBlock->blockMissingReturnType());
16755 const FunctionProtoType *exprFunctionType =
E->getFunctionType();
16758 Sema::ExtParameterInfoBuilder extParamInfos;
16759 if (getDerived().TransformFunctionTypeParams(
16760 E->getCaretLocation(), oldBlock->parameters(),
nullptr,
16761 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
16763 getSema().ActOnBlockError(
E->getCaretLocation(),
nullptr);
16767 QualType exprResultType =
16768 getDerived().TransformType(exprFunctionType->getReturnType());
16770 auto epi = exprFunctionType->getExtProtoInfo();
16771 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
16774 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
16778 if (!params.empty())
16779 blockScope->TheDecl->setParams(params);
16781 if (!oldBlock->blockMissingReturnType()) {
16782 blockScope->HasImplicitReturnType =
false;
16783 blockScope->ReturnType = exprResultType;
16787 StmtResult body = getDerived().TransformStmt(
E->getBody());
16788 if (body.isInvalid()) {
16789 getSema().ActOnBlockError(
E->getCaretLocation(),
nullptr);
16797 for (
const auto &I : oldBlock->captures()) {
16798 VarDecl *oldCapture = I.getVariable();
16801 if (oldCapture->isParameterPack())
16804 VarDecl *newCapture =
16805 cast<VarDecl>(getDerived().TransformDecl(
E->getCaretLocation(),
16807 assert(blockScope->CaptureMap.count(newCapture));
16813 assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&
16814 "this pointer isn't captured in the old block");
16822template<
typename Derived>
16824TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *
E) {
16825 ExprResult SrcExpr = getDerived().TransformExpr(
E->getSrcExpr());
16826 if (SrcExpr.isInvalid())
16829 QualType
Type = getDerived().TransformType(
E->
getType());
16832 E->getRParenLoc());
16835template<
typename Derived>
16837TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *
E) {
16838 bool ArgumentChanged =
false;
16840 SubExprs.reserve(
E->getNumSubExprs());
16841 if (getDerived().TransformExprs(
E->getSubExprs(),
E->getNumSubExprs(),
false,
16842 SubExprs, &ArgumentChanged))
16845 if (!getDerived().AlwaysRebuild() &&
16849 return getDerived().RebuildAtomicExpr(
E->getBuiltinLoc(), SubExprs,
16850 E->getOp(),
E->getRParenLoc());
16857template<
typename Derived>
16861 getDerived().getBaseEntity());
16864template<
typename Derived>
16868 getDerived().getBaseEntity());
16871template<
typename Derived>
16874 bool WrittenAsLValue,
16877 Sigil, getDerived().getBaseEntity());
16880template<
typename Derived>
16886 getDerived().getBaseEntity());
16889template<
typename Derived>
16897 Decl, ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
16901template<
typename Derived>
16913 BaseType,
Loc, TypeArgsLAngleLoc, TypeArgs, TypeArgsRAngleLoc,
16914 ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
16919template<
typename Derived>
16926template <
typename Derived>
16929 Expr *SizeExpr,
unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16930 if (SizeExpr || !Size)
16932 IndexTypeQuals, BracketsRange,
16933 getDerived().getBaseEntity());
16941 for (
const auto &
T : Types)
16953 IndexTypeQuals, BracketsRange,
16954 getDerived().getBaseEntity());
16957template <
typename Derived>
16960 Expr *SizeExpr,
unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16961 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
16962 IndexTypeQuals, BracketsRange);
16965template <
typename Derived>
16969 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
16970 IndexTypeQuals, BracketsRange);
16973template <
typename Derived>
16976 unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16977 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
16979 IndexTypeQuals, BracketsRange);
16982template <
typename Derived>
16985 unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16986 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
16988 IndexTypeQuals, BracketsRange);
16991template <
typename Derived>
16998template <
typename Derived>
17000 unsigned NumElements,
17006template <
typename Derived>
17013template<
typename Derived>
17015 unsigned NumElements,
17018 NumElements,
true);
17025template<
typename Derived>
17033template <
typename Derived>
17035 QualType ElementType,
unsigned NumRows,
unsigned NumColumns) {
17040template <
typename Derived>
17048template<
typename Derived>
17054 getDerived().getBaseLocation(),
17055 getDerived().getBaseEntity(),
17059template<
typename Derived>
17064template<
typename Derived>
17067 assert(
D &&
"no decl found");
17071 if (
auto *UPD = dyn_cast<UsingPackDecl>(
D)) {
17075 if (UPD->expansions().empty()) {
17076 getSema().Diag(
Loc, diag::err_using_pack_expansion_empty)
17077 << UPD->isCXXClassMember() << UPD;
17086 for (
auto *
E : UPD->expansions()) {
17092 else if (
T.isNull())
17096 "mismatched resolved types in using pack expansion");
17098 return T.isNull() ? FallbackT :
T;
17099 }
else if (
auto *Using = dyn_cast<UsingDecl>(
D)) {
17100 assert(Using->hasTypename() &&
17101 "UnresolvedUsingTypenameDecl transformed to non-typename using");
17104 assert(++Using->shadow_begin() == Using->shadow_end());
17113 assert(isa<UnresolvedUsingTypenameDecl>(
D) &&
17114 "UnresolvedUsingTypenameDecl transformed to non-using decl");
17116 cast<UnresolvedUsingTypenameDecl>(
D));
17120template <
typename Derived>
17126template<
typename Derived>
17132template <
typename Derived>
17137template <
typename Derived>
17143 FullySubstituted, Expansions);
17146template<
typename Derived>
17153template<
typename Derived>
17161template<
typename Derived>
17167template<
typename Derived>
17175template <
typename Derived>
17186template <
typename Derived>
17192template<
typename Derived>
17201template<
typename Derived>
17209 bool AllowInjectedClassName) {
17213 getSema().ActOnTemplateName(
nullptr, SS, TemplateKWLoc,
17216 AllowInjectedClassName);
17217 return Template.
get();
17220template<
typename Derived>
17227 bool AllowInjectedClassName) {
17230 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
17231 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
17233 getSema().ActOnTemplateName(
17235 false, Template, AllowInjectedClassName);
17236 return Template.
get();
17239template <
typename Derived>
17244 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
17250 Opc,
First, Second);
17265 if (Op == OO_Subscript) {
17266 if (!
First->getType()->isOverloadableType() &&
17268 return getSema().CreateBuiltinArraySubscriptExpr(
First, CalleeLoc, Second,
17270 }
else if (Op == OO_Arrow) {
17273 if (
First->getType()->isDependentType())
17277 }
else if (Second ==
nullptr || isPostIncDec) {
17278 if (!
First->getType()->isOverloadableType() ||
17279 (Op == OO_Amp && getSema().isQualifiedMemberAccess(
First))) {
17286 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc,
First);
17290 !
First->getType()->isOverloadableType() &&
17305 if (!Second || isPostIncDec) {
17315 First, Second, RequiresADL);
17322template<
typename Derived>
17337 ->template getAs<RecordType>())){
17340 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
17341 CCLoc, TildeLoc, Destroyed);
17353 if (!ScopeType->getType()->getAs<
TagType>()) {
17354 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
17355 diag::err_expected_class_or_namespace)
17356 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
17364 return getSema().BuildMemberReferenceExpr(
Base, BaseType,
17365 OperatorLoc, isArrow,
17373template<
typename Derived>
17381 for (
unsigned I = 0; I < NumParams; ++I) {
17382 if (I != ContextParamPos) {
17388 Params.push_back(std::make_pair(StringRef(), QualType()));
17391 getSema().ActOnCapturedRegionStart(
Loc,
nullptr,
17392 S->getCapturedRegionKind(), Params);
17395 Sema::CompoundScopeRAII CompoundScope(getSema());
17396 Body = getDerived().TransformStmt(S->getCapturedStmt());
17399 if (Body.isInvalid()) {
17400 getSema().ActOnCapturedRegionError();
17404 return getSema().ActOnCapturedRegionEnd(Body.get());
17407template <
typename Derived>
17408ExprResult TreeTransform<Derived>::TransformHLSLOutArgExpr(HLSLOutArgExpr *
E) {
17411 return getDerived().TransformExpr(
E->getArgLValue());
static Decl::Kind getKind(const Decl *D)
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
llvm::MachO::Target Target
llvm::MachO::Record Record
This file defines OpenMP AST classes for clauses.
Defines some OpenMP-specific enums and functions.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenACC constructs and clauses.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis for expressions involving.
This file declares semantic analysis for SYCL constructs.
Defines the Objective-C statement AST node classes.
This file defines OpenACC AST classes for statement-level contructs.
This file defines OpenMP AST classes for executable directives and clauses.
static QualType getPointeeType(const MemRegion *R)
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
TranslationUnitDecl * getTranslationUnitDecl() const
unsigned getIntWidth(QualType T) const
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
DeclarationNameTable DeclarationNames
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag=SubstTemplateTypeParmTypeFlag::None) const
Retrieve a substitution-result type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
QualType getMacroQualifiedType(QualType UnderlyingTy, const IdentifierInfo *MacroII) const
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
CanQualType UnsignedLongTy
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CanQualType PseudoObjectTy
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
CanQualType UnsignedInt128Ty
CanQualType UnsignedCharTy
CanQualType UnsignedIntTy
CanQualType UnsignedLongLongTy
CanQualType UnsignedShortTy
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index, bool Final) const
QualType getHLSLAttributedResourceType(QualType Wrapped, QualType Contained, const HLSLAttributedResourceType::Attributes &Attrs)
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
SourceLocation getRParenLoc() const
TypeLoc getValueLoc() const
SourceLocation getKWLoc() const
SourceLocation getLParenLoc() const
Attr - This represents one attribute.
attr::Kind getKind() const
Represents an attribute applied to a statement.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
ConceptDecl * getTypeConstraintConcept() const
AutoTypeKeyword getKeyword() const
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
bool isAssignmentOp() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
void setIsVariadic(bool value)
Represents a C++2a __builtin_bit_cast(T, v) expression.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
Represents binding an expression to a temporary.
CXXCatchStmt - This represents a C++ catch block.
Represents a call to a C++ constructor.
SourceRange getParenOrBraceRange() const
Expr * getArg(unsigned Arg)
Return the specified argument.
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ constructor within a class.
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, Expr *RewrittenExpr, DeclContext *UsedContext)
Represents a call to an inherited base class constructor from an inheriting constructor.
Abstract class common to all of the C++ "named"/"keyword" casts.
Represents a C++ struct/union/class.
unsigned getLambdaDependencyKind() const
An expression "T()" which creates an rvalue of a non-class type T.
Represents a C++ nested-name-specifier or a global scope specifier.
char * location_data() const
Retrieve the data associated with the source-location information.
SourceRange getRange() const
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier '::'.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
unsigned location_size() const
Retrieve the size of the data associated with source-location information.
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into '__super' nested-name-specifier.
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form 'type...
void Adopt(NestedNameSpecifierLoc Other)
Adopt an existing nested-name-specifier (with source-range information).
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
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.
Represents the body of a CapturedStmt, and serves as its DeclContext.
unsigned getNumParams() const
unsigned getContextParamPosition() const
ImplicitParamDecl * getParam(unsigned i) const
This captures a statement into a function.
SourceLocation getBegin() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
Declaration of a C++20 concept.
static ConceptReference * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten)
const TypeClass * getTypePtr() const
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void addDecl(Decl *D)
Add the declaration D into this context.
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Decl - This represents one declaration (or definition), e.g.
SourceLocation getEndLoc() const LLVM_READONLY
bool isInvalidDecl() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
SourceLocation getBeginLoc() const LLVM_READONLY
The name of a declaration.
@ CXXConversionFunctionName
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
A qualified reference to a name whose declaration cannot yet be resolved.
Represents a dependent template name that cannot be resolved prior to template instantiation.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
unsigned getNumArgs() const
SourceLocation getTemplateNameLoc() const
SourceLocation getLAngleLoc() const
void setTemplateKeywordLoc(SourceLocation Loc)
SourceLocation getTemplateKeywordLoc() const
void setElaboratedKeywordLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
SourceLocation getRAngleLoc() const
SourceLocation getElaboratedKeywordLoc() const
void setLAngleLoc(SourceLocation Loc)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateNameLoc(SourceLocation Loc)
Represents a template specialization type whose template cannot be resolved, e.g.
Designation - Represent a full designation, which is a sequence of designators.
static Designator CreateArrayRangeDesignator(Expr *Start, Expr *End, SourceLocation LBracketLoc, SourceLocation EllipsisLoc)
Creates a GNU array-range designator.
static Designator CreateArrayDesignator(Expr *Index, SourceLocation LBracketLoc)
Creates an array designator.
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
bool hasErrorOccurred() const
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
Expr * getCondition() const
SourceLocation getElaboratedKeywordLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
void setElaboratedKeywordLoc(SourceLocation Loc)
TypeLoc getNamedTypeLoc() const
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
RAII object that enters a new expression evaluation context.
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Represents a function declaration or definition.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Represents an abstract function effect, using just an enumeration describing its kind.
StringRef name() const
The description printed in diagnostics, e.g. 'nonblocking'.
Kind oppositeKind() const
Return the opposite kind, for effects which have opposites.
ArrayRef< EffectConditionExpr > conditions() const
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
param_type_iterator param_type_begin() const
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present,...
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
unsigned getNumParams() const
SourceLocation getLocalRangeEnd() const
void setLocalRangeBegin(SourceLocation L)
void setLParenLoc(SourceLocation Loc)
SourceRange getExceptionSpecRange() const
void setParam(unsigned i, ParmVarDecl *VD)
ArrayRef< ParmVarDecl * > getParams() const
void setRParenLoc(SourceLocation Loc)
void setLocalRangeEnd(SourceLocation L)
void setExceptionSpecRange(SourceRange R)
TypeLoc getReturnLoc() const
SourceLocation getLocalRangeBegin() const
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
QualType getReturnType() const
AssociationTy< false > Association
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.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Represents an implicitly-generated value initialization of an object of a given type.
const TypeClass * getTypePtr() const
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'.
Represents the declaration of a label.
Describes the capture of a variable or of this, or of a C++1y init-capture.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
const LambdaCapture * capture_iterator
An iterator that walks over the captures of the lambda, both implicit and explicit.
Represents the results of name lookup.
@ FoundOverloaded
Name lookup found a set of overloaded functions that met the criteria.
@ FoundUnresolvedValue
Name lookup found an unresolvable value declaration and cannot yet complete.
@ Ambiguous
Name lookup results in an ambiguity; use getAmbiguityKind to figure out what kind of ambiguity we hav...
@ NotFound
No entity found met the criteria.
@ NotFoundInCurrentInstantiation
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
@ Found
Name lookup found a single declaration that met the criteria.
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
bool empty() const
Return true if no decls were found.
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
SourceLocation getNameLoc() const
Gets the location of the identifier.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
DeclarationName getLookupName() const
Gets the name to look up.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
This represents a decl that may have a name.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a C++ namespace alias.
Represent a C++ namespace.
A C++ nested-name-specifier augmented with source location information.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
SourceLocation getLocalEndLoc() const
Retrieve the location of the end of this component of the nested-name-specifier.
SourceLocation getEndLoc() const
Retrieve the location of the end of this nested-name-specifier.
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
void * getOpaqueData() const
Retrieve the opaque pointer that refers to source-location data.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getLocalBeginLoc() const
Retrieve the location of the beginning of this component of the nested-name-specifier.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range covering the entirety of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
This is a basic class for representing single OpenMP clause.
This is a basic class for representing single OpenMP executable directive.
This represents clauses with a list of expressions that are mappable.
ObjCIvarDecl - Represents an ObjC instance variable.
@ SuperInstance
The receiver is the instance of the superclass object.
@ Instance
The receiver is an object instance.
@ SuperClass
The receiver is a superclass.
@ Class
The receiver is a class.
ObjCMethodDecl - Represents an instance or class method declaration.
bool isInstanceMethod() const
Represents one property declaration in an Objective-C interface.
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Represents the declaration of an Objective-C type parameter.
@ Array
An index into an array.
@ Identifier
A field in a dependent type, known only by its name.
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
Wrapper for void* pointer.
static OpaquePtr make(QualType P)
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
static OpenACCAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCAttachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCAutoClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
This is the base type for all OpenACC Clauses.
static OpenACCCollapseClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, bool HasForce, Expr *LoopCount, SourceLocation EndLoc)
static OpenACCCopyClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyInClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsReadOnly, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCopyOutClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCCreateClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDefaultAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCDefaultClause * Create(const ASTContext &C, OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
static OpenACCDeleteClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDetachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDeviceClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDeviceNumClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCDevicePtrClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCDeviceTypeClause * Create(const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< DeviceTypeArgument > Archs, SourceLocation EndLoc)
static OpenACCFinalizeClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCFirstPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCHostClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCIfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCIfPresentClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCIndependentClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCNoCreateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCNumGangsClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
static OpenACCNumWorkersClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCPresentClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCSelfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
static OpenACCSeqClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
static OpenACCTileClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > SizeExprs, SourceLocation EndLoc)
static OpenACCUseDeviceClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
static OpenACCVectorClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCVectorLengthClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
static OpenACCWaitClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef< Expr * > QueueIdExprs, SourceLocation EndLoc)
static OpenACCWorkerClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
SourceLocation getNameLoc() const
Gets the location of the name.
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
TemplateArgumentLoc const * getTemplateArgs() const
llvm::iterator_range< decls_iterator > decls() const
unsigned getNumTemplateArgs() const
DeclarationName getName() const
Gets the name looked up.
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
bool hasTemplateKeyword() const
Determines whether the name was preceded by the template keyword.
Represents a C++11 pack expansion that produces a sequence of expressions.
void setEllipsisLoc(SourceLocation Loc)
SourceLocation getEllipsisLoc() const
TypeLoc getPatternLoc() const
Represents a pack expansion of types.
std::optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
ParenExpr - This represents a parenthesized expression, e.g.
SourceLocation getLParen() const
Get the location of the left parentheses '('.
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
unsigned getFunctionScopeDepth() const
void setSigilLoc(SourceLocation Loc)
TypeLoc getPointeeLoc() const
SourceLocation getSigilLoc() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
Stores the type being destroyed by a pseudo-destructor expression.
const IdentifierInfo * getIdentifier() const
SourceLocation getLocation() const
TypeSourceInfo * getTypeSourceInfo() const
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Represents a template name as written in source code.
Wrapper of type source information for a type with non-trivial direct qualifiers.
The collection of all-type qualifiers we support.
void removeObjCLifetime()
static Qualifiers fromCVRMask(unsigned CVR)
bool hasObjCLifetime() const
LangAS getAddressSpace() const
Represents a struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeTypeAsWritten() const
Represents the body of a requires-expression.
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)
Represents a __leave statement.
Smart pointer class that efficiently represents Objective-C method names.
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
VarDecl * BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, bool Invalid=false)
Build a type-check a new Objective-C exception variable declaration.
StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)
StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)
FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.
ExprResult BuildObjCDictionaryLiteral(SourceRange SR, MutableArrayRef< ObjCDictionaryElement > Elements)
ExprResult BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef< SourceLocation > SelectorLocs, SourceLocation RBracLoc, MultiExprArg Args, bool isImplicit=false)
Build an Objective-C instance message expression.
QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError=false)
Build an Objective-C type parameter type.
ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef< SourceLocation > SelectorLocs, SourceLocation RBracLoc, MultiExprArg Args, bool isImplicit=false)
Build an Objective-C class message expression.
StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SynchExpr, Stmt *SynchBody)
ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc, TypeSourceInfo *EncodedTypeInfo, SourceLocation RParenLoc)
ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements)
ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr)
BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the '@' prefixed parenthesized expression.
StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, MultiStmtArg Catch, Stmt *Finally)
StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body)
StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw)
QualType BuildObjCObjectType(QualType BaseType, SourceLocation Loc, SourceLocation TypeArgsLAngleLoc, ArrayRef< TypeSourceInfo * > TypeArgs, SourceLocation TypeArgsRAngleLoc, SourceLocation ProtocolLAngleLoc, ArrayRef< ObjCProtocolDecl * > Protocols, ArrayRef< SourceLocation > ProtocolLocs, SourceLocation ProtocolRAngleLoc, bool FailOnError, bool Rebuilding)
Build an Objective-C object pointer type.
ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand)
ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr)
StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen, Decl *Parm, Stmt *Body)
StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body)
ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr, Expr *IndexExpr, ObjCMethodDecl *getterMethod, ObjCMethodDecl *setterMethod)
Build an ObjC subscript pseudo-object expression, given that that's supported by the runtime.
ArrayRef< Expr * > getIntExprs()
ArrayRef< Expr * > getQueueIdExprs() const
OpenACCDirectiveKind getDirectiveKind() const
SourceLocation getEndLoc() const
void setLParenLoc(SourceLocation EndLoc)
void setConditionDetails(Expr *ConditionExpr)
void setCollapseDetails(bool IsForce, Expr *LoopCount)
OpenACCClauseKind getClauseKind() const
const Expr * getConditionExpr() const
SourceLocation getLParenLoc() const
SourceLocation getBeginLoc() const
void setDefaultDetails(OpenACCDefaultClauseKind DefKind)
SourceLocation getQueuesLoc() const
void setVarListDetails(ArrayRef< Expr * > VarList, bool IsReadOnly, bool IsZero)
Expr * getDevNumExpr() const
ArrayRef< Expr * > getVarList()
unsigned getNumIntExprs() const
void setWaitDetails(Expr *DevNum, SourceLocation QueuesLoc, llvm::SmallVector< Expr * > &&IntExprs)
void setEndLoc(SourceLocation EndLoc)
Expr * getLoopCount() const
void setIntExprDetails(ArrayRef< Expr * > IntExprs)
OpenACCDefaultClauseKind getDefaultClauseKind() const
void ActOnWhileStmt(SourceLocation WhileLoc)
StmtResult ActOnEndStmtDirective(OpenACCDirectiveKind K, SourceLocation StartLoc, SourceLocation DirLoc, SourceLocation LParenLoc, SourceLocation MiscLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc, SourceLocation EndLoc, ArrayRef< OpenACCClause * > Clauses, StmtResult AssocStmt)
Called after the directive has been completely parsed, including the declaration group or associated ...
ExprResult ActOnOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc)
void ActOnDoStmt(SourceLocation DoLoc)
void ActOnRangeForStmtBegin(SourceLocation ForLoc, const Stmt *OldRangeFor, const Stmt *RangeFor)
void ActOnForStmtEnd(SourceLocation ForLoc, StmtResult Body)
void ActOnForStmtBegin(SourceLocation ForLoc, const Stmt *First, const Stmt *Second, const Stmt *Third)
ExprResult ActOnArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, Expr *Length, SourceLocation RBLoc)
Checks and creates an Array Section used in an OpenACC construct/clause.
OMPClause * ActOnOpenMPNocontextClause(Expr *Condition, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'nocontext' clause.
OMPClause * ActOnOpenMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on a well-formed 'ompx_dyn_cgroup_mem' clause.
OMPClause * ActOnOpenMPSafelenClause(Expr *Length, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'safelen' clause.
OMPClause * ActOnOpenMPHoldsClause(Expr *E, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'holds' clause.
OMPClause * ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind, SourceLocation KindLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'default' clause.
OMPClause * ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'filter' clause.
OMPClause * ActOnOpenMPFullClause(SourceLocation StartLoc, SourceLocation EndLoc)
Called on well-form 'full' clauses.
OMPClause * ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'detach' clause.
OMPClause * ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Called on well-formed 'use' clause.
OMPClause * ActOnOpenMPToClause(ArrayRef< OpenMPMotionModifierKind > MotionModifiers, ArrayRef< SourceLocation > MotionModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs, ArrayRef< Expr * > UnresolvedMappers={})
Called on well-formed 'to' clause.
OMPClause * ActOnOpenMPPrivateClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'private' clause.
OMPClause * ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc, SourceLocation LParenLoc=SourceLocation(), Expr *NumForLoops=nullptr)
Called on well-formed 'ordered' clause.
OMPClause * ActOnOpenMPIsDevicePtrClause(ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs)
Called on well-formed 'is_device_ptr' clause.
OMPClause * ActOnOpenMPHasDeviceAddrClause(ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs)
Called on well-formed 'has_device_addr' clause.
OMPClause * ActOnOpenMPPartialClause(Expr *FactorExpr, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-form 'partial' clauses.
OMPClause * ActOnOpenMPLastprivateClause(ArrayRef< Expr * > VarList, OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc, SourceLocation ColonLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'lastprivate' clause.
OMPClause * ActOnOpenMPFirstprivateClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'firstprivate' clause.
OMPClause * ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'priority' clause.
OMPClause * ActOnOpenMPAllocateClause(Expr *Allocator, OpenMPAllocateClauseModifier ACModifier, ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation ColonLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'allocate' clause.
OMPClause * ActOnOpenMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc)
Called on well-formed 'dist_schedule' clause.
OMPClause * ActOnOpenMPPermutationClause(ArrayRef< Expr * > PermExprs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-form 'permutation' clause after parsing its arguments.
OMPClause * ActOnOpenMPNontemporalClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'nontemporal' clause.
OMPClause * ActOnOpenMPFromClause(ArrayRef< OpenMPMotionModifierKind > MotionModifiers, ArrayRef< SourceLocation > MotionModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs, ArrayRef< Expr * > UnresolvedMappers={})
Called on well-formed 'from' clause.
OMPClause * ActOnOpenMPBindClause(OpenMPBindClauseKind Kind, SourceLocation KindLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on a well-formed 'bind' clause.
OMPClause * ActOnOpenMPThreadLimitClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'thread_limit' clause.
OMPClause * ActOnOpenMPSharedClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'shared' clause.
OMPClause * ActOnOpenMPCopyinClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'copyin' clause.
OMPClause * ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Called on well-formed 'destroy' clause.
OMPClause * ActOnOpenMPAffinityClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, Expr *Modifier, ArrayRef< Expr * > Locators)
Called on well-formed 'affinity' clause.
OMPClause * ActOnOpenMPNumTeamsClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'num_teams' clause.
OMPClause * ActOnOpenMPDependClause(const OMPDependClause::DependDataTy &Data, Expr *DepModifier, ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'depend' clause.
OMPClause * ActOnOpenMPDoacrossClause(OpenMPDoacrossClauseModifier DepType, SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'doacross' clause.
OMPClause * ActOnOpenMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier, Expr *Size, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Called on well-formed 'grainsize' clause.
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, Expr *Length, Expr *Stride, SourceLocation RBLoc)
ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc, ArrayRef< OMPIteratorData > Data)
OMPClause * ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< UsesAllocatorsData > Data)
Called on well-formed 'uses_allocators' clause.
OMPClause * ActOnOpenMPAllocatorClause(Expr *Allocator, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'allocator' clause.
OMPClause * ActOnOpenMPInclusiveClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'inclusive' clause.
OMPClause * ActOnOpenMPTaskReductionClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef< Expr * > UnresolvedReductions={})
Called on well-formed 'task_reduction' clause.
OMPClause * ActOnOpenMPOrderClause(OpenMPOrderClauseModifier Modifier, OpenMPOrderClauseKind Kind, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, SourceLocation KindLoc, SourceLocation EndLoc)
Called on well-formed 'order' clause.
OMPClause * ActOnOpenMPReductionClause(ArrayRef< Expr * > VarList, OpenMPReductionClauseModifier Modifier, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef< Expr * > UnresolvedReductions={})
Called on well-formed 'reduction' clause.
OMPClause * ActOnOpenMPSizesClause(ArrayRef< Expr * > SizeExprs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-form 'sizes' clause.
OMPClause * ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier, Expr *Device, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Called on well-formed 'device' clause.
OMPClause * ActOnOpenMPNumThreadsClause(Expr *NumThreads, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'num_threads' clause.
OMPClause * ActOnOpenMPInReductionClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef< Expr * > UnresolvedReductions={})
Called on well-formed 'in_reduction' clause.
OMPClause * ActOnOpenMPFlushClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'flush' pseudo clause.
StmtResult ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, OpenMPDirectiveKind CancelRegion, ArrayRef< OMPClause * > Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc)
OMPClause * ActOnOpenMPMessageClause(Expr *MS, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'message' clause.
OMPClause * ActOnOpenMPScheduleClause(OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2, OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc, SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc)
Called on well-formed 'schedule' clause.
OMPClause * ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'simdlen' clause.
OMPClause * ActOnOpenMPUseDevicePtrClause(ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs)
Called on well-formed 'use_device_ptr' clause.
OMPClause * ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind, SourceLocation KindLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'proc_bind' clause.
OMPClause * ActOnOpenMPXBareClause(SourceLocation StartLoc, SourceLocation EndLoc)
Called on a well-formed 'ompx_bare' clause.
StmtResult ActOnOpenMPInformationalDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, ArrayRef< OMPClause * > Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc)
Process an OpenMP informational directive.
StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt)
Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to an OpenMP loop directive.
OMPClause * ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'hint' clause.
ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc, SourceLocation RParenLoc, ArrayRef< Expr * > Dims, ArrayRef< SourceRange > Brackets)
OMPClause * ActOnOpenMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KindLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'at' clause.
OMPClause * ActOnOpenMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)
Called on well-formed 'init' clause.
OMPClause * ActOnOpenMPUseDeviceAddrClause(ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs)
Called on well-formed 'use_device_addr' clause.
OMPClause * ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'final' clause.
OMPClause * ActOnOpenMPMapClause(Expr *IteratorModifier, ArrayRef< OpenMPMapModifierKind > MapTypeModifiers, ArrayRef< SourceLocation > MapTypeModifiersLoc, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperId, OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef< Expr * > VarList, const OMPVarListLocTy &Locs, bool NoDiagnose=false, ArrayRef< Expr * > UnresolvedMappers={})
Called on well-formed 'map' clause.
OMPClause * ActOnOpenMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier, Expr *NumTasks, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ModifierLoc, SourceLocation EndLoc)
Called on well-formed 'num_tasks' clause.
OMPClause * ActOnOpenMPSeverityClause(OpenMPSeverityClauseKind Kind, SourceLocation KindLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'severity' clause.
OMPClause * ActOnOpenMPLinearClause(ArrayRef< Expr * > VarList, Expr *Step, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind, SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation StepModifierLoc, SourceLocation EndLoc)
Called on well-formed 'linear' clause.
OMPClause * ActOnOpenMPDefaultmapClause(OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, SourceLocation KindLoc, SourceLocation EndLoc)
Called on well-formed 'defaultmap' clause.
OMPClause * ActOnOpenMPAlignedClause(ArrayRef< Expr * > VarList, Expr *Alignment, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc)
Called on well-formed 'aligned' clause.
OMPClause * ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'depobj' pseudo clause.
OMPClause * ActOnOpenMPNovariantsClause(Expr *Condition, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'novariants' clause.
OMPClause * ActOnOpenMPCopyprivateClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'copyprivate' clause.
OMPClause * ActOnOpenMPCollapseClause(Expr *NumForLoops, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'collapse' clause.
OMPClause * ActOnOpenMPAlignClause(Expr *Alignment, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'align' clause.
OMPClause * ActOnOpenMPXAttributeClause(ArrayRef< const Attr * > Attrs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on a well-formed 'ompx_attribute' clause.
OMPClause * ActOnOpenMPExclusiveClause(ArrayRef< Expr * > VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Called on well-formed 'exclusive' clause.
OMPClause * ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Condition, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation NameModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc)
Called on well-formed 'if' clause.
ExprResult checkAssignment(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opcode, Expr *LHS, Expr *RHS)
Expr * recreateSyntacticForm(PseudoObjectExpr *E)
Given a pseudo-object expression, recreate what it looks like syntactically without the attendant Opa...
ExprResult checkRValue(Expr *E)
ExprResult BuildUniqueStableNameExpr(SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, TypeSourceInfo *TSI)
RAII object used to change the argument pack substitution index within a Sema object.
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
A RAII object to enter scope of a compound statement.
A helper class for building up ExtParameterInfos.
const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)
Return a pointer (suitable for setting in an ExtProtoInfo) to the ExtParameterInfo array we've built ...
void set(unsigned index, FunctionProtoType::ExtParameterInfo info)
Set the ExtParameterInfo for the parameter at the given index,.
Records and restores the CurFPFeatures state on entry/exit of compound statements.
Sema - This implements semantic analysis and AST building for C.
QualType BuildParenType(QualType T)
Build a paren type including T.
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
QualType getCurrentThisType()
Try to retrieve the type of the 'this' pointer.
bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range)
CheckSpecifiedExceptionType - Check if the given type is valid in an exception specification.
ExprResult BuildOperatorCoawaitCall(SourceLocation Loc, Expr *E, UnresolvedLookupExpr *Lookup)
Build a call to 'operator co_await' if there is a suitable operator for the given expression.
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo NameInfo, Stmt *Nested)
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
@ LookupTagName
Tag name lookup, which finds the names of enums, classes, structs, and unions.
bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend)
Check that the expression co_await promise.final_suspend() shall not be potentially-throwing.
QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace, SourceLocation AttrLoc)
BuildAddressSpaceAttr - Builds a DependentAddressSpaceType if an expression is uninstantiated.
ExprResult ActOnConstantExpression(ExprResult Res)
StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, ArrayRef< Token > AsmToks, StringRef AsmString, unsigned NumOutputs, unsigned NumInputs, ArrayRef< StringRef > Constraints, ArrayRef< StringRef > Clobbers, ArrayRef< Expr * > Exprs, SourceLocation EndLoc)
StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs)
ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E)
static std::enable_if_t< std::is_base_of_v< Attr, AttrInfo >, SourceLocation > getAttrLoc(const AttrInfo &AL)
A helper function to provide Attribute Location for the Attr types AND the ParsedAttr.
QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc)
StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
@ IER_DoesNotExist
The symbol does not exist.
@ IER_Dependent
The name is a dependent name, so the results will differ from one instantiation to the next.
@ IER_Error
An error occurred.
@ IER_Exists
The symbol exists.
void ActOnStartStmtExpr()
ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc, sema::LambdaScopeInfo *LSI)
Complete a lambda-expression having processed and attached the lambda body.
void ActOnStmtExprError()
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false, ArrayRef< const Expr * > StopAt={})
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
std::optional< FunctionEffectMode > ActOnEffectExpression(Expr *CondExpr, StringRef AttributeName)
Try to parse the conditional expression attached to an effect attribute (e.g.
VarDecl * buildCoroutinePromise(SourceLocation Loc)
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
@ Switch
An integral condition for a 'switch' statement.
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI, Expr *Operand, SourceLocation RParenLoc)
StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, LabelDecl *TheDecl)
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor,...
StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E, bool IsImplicit=false)
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val)
QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc)
Build an ext-vector type.
ExprResult ActOnDesignatedInitializer(Designation &Desig, SourceLocation EqualOrColonLoc, bool GNUSyntax, ExprResult Init)
ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc, unsigned TemplateDepth)
ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound=nullptr)
BuildOverloadedArrowExpr - Build a call to an overloaded operator-> (if one exists),...
ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *Operand, Expr *Awaiter, bool IsImplicit=false)
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:
ExprResult BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a C++ typeid expression with a type operand.
QualType BuildFunctionType(QualType T, MutableArrayRef< QualType > ParamTypes, SourceLocation Loc, DeclarationName Entity, const FunctionProtoType::ExtProtoInfo &EPI)
Build a function type.
ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow)
Perform conversions on the LHS of a member access expression.
DiagnosticsEngine & getDiagnostics() const
concepts::TypeRequirement * BuildTypeRequirement(TypeSourceInfo *Type)
TypeSourceInfo * CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, std::optional< unsigned > NumExpansions)
Construct a pack expansion type from the pattern of the pack expansion.
ExprResult BuildPackIndexingExpr(Expr *PackExpression, SourceLocation EllipsisLoc, Expr *IndexExpr, SourceLocation RSquareLoc, ArrayRef< Expr * > ExpandedExprs={}, bool FullySubstituted=false)
ParsedType getDestructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
ASTContext & getASTContext() const
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, bool RequiresADL, const TemplateArgumentListInfo *TemplateArgs)
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true, bool AllowRewrittenCandidates=true, FunctionDecl *DefaultedFn=nullptr)
Create a binary operation that may resolve to an overloaded operator.
StmtResult ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK)
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull)
ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional< Expr * > ArraySize, SourceRange DirectInitRange, Expr *Initializer)
bool isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name)
Determine whether a tag with a given kind is acceptable as a redeclaration of the given tag declarati...
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
QualType BuildBitIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc)
Build a bit-precise integer type.
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef< TypeSourceInfo * > Types, ArrayRef< Expr * > Exprs)
ControllingExprOrType is either a TypeSourceInfo * or an Expr *.
QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, const DeclSpec *DS=nullptr)
StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *Body)
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
const LangOptions & getLangOpts() const
StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)
ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee, SourceLocation LParenLoc, Expr *LHS, BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, std::optional< unsigned > NumExpansions)
bool isPotentialImplicitMemberAccess(const CXXScopeSpec &SS, LookupResult &R, bool IsAddressOfOperand)
Check whether an expression might be an implicit class member access.
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument.
ExprResult BuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext)
ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc, bool ListInitialization)
ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
__builtin_offsetof(type, a.b[123][456].c)
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
ExprResult TemporaryMaterializationConversion(Expr *E)
If E is a prvalue denoting an unmaterialized temporary, materialize it as an xvalue.
ExprResult ConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
ConvertVectorExpr - Handle __builtin_convertvector.
QualType CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, TypeSourceInfo **TSI, bool DeducedTSTContext)
ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< TypeSourceInfo * > Args, SourceLocation RParenLoc)
DeclContext * getCurLexicalContext() const
ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *Operand, UnresolvedLookupExpr *Lookup)
NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK)
Given a non-tag type declaration, returns an enum useful for indicating what kind of non-tag type thi...
ExprResult BuildExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
bool buildCoroutineParameterMoves(SourceLocation Loc)
ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, SourceLocation RParenLoc, Expr *Op)
ExprResult BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc)
Build a Microsoft __uuidof expression with a type operand.
sema::FunctionScopeInfo * getCurFunction() const
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Expr * BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit)
Build a CXXThisExpr and mark it referenced in the current context.
QualType BuildReferenceType(QualType T, bool LValueRef, SourceLocation Loc, DeclarationName Entity)
Build a reference type.
ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *input, bool RequiresADL=true)
Create a unary operation that may resolve to an overloaded operator.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
VarDecl * BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id)
Perform semantic analysis for the variable declaration that occurs within a C++ catch clause,...
bool BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon=nullptr, bool OnlyNamespace=false)
Build a new nested-name-specifier for "identifier::", as described by ActOnCXXNestedNameSpecifier.
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, SourceLocation RParen)
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, Expr *DestExp)
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, NamedDecl *FoundDecl, CXXConstructorDecl *Constructor, MultiExprArg Exprs, bool HadMultipleCandidates, bool IsListInitialization, bool IsStdInitListInitialization, bool RequiresZeroInit, CXXConstructionKind ConstructKind, SourceRange ParenRange)
BuildCXXConstructExpr - Creates a complete call to a constructor, including handling of its default a...
NonTagKind
Common ways to introduce type names without a tag for use in diagnostics.
@ TryCapture_ExplicitByVal
@ TryCapture_ExplicitByRef
ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
Create a new AsTypeExpr node (bitcast) from the arguments.
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
bool CheckRebuiltStmtAttributes(ArrayRef< const Attr * > Attrs)
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
QualType BuildPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc, bool FullySubstituted=false, ArrayRef< QualType > Expansions={})
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
concepts::ExprRequirement * BuildExprRequirement(Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement)
QualType BuildAtomicType(QualType T, SourceLocation Loc)
QualType CheckTemplateIdType(TemplateName Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs)
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
bool diagnoseConflictingFunctionEffect(const FunctionEffectsRef &FX, const FunctionEffectWithCondition &EC, SourceLocation NewAttrLoc)
Warn and return true if adding a function effect to a set would create a conflict.
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr, bool SkipTrailingRequiresClause=false)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics.
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
ExprResult BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeType, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a pointer type.
StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End, Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})
BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement.
StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen)
StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc)
ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, bool IsAddressOfOperand)
ExprResult BuiltinShuffleVector(CallExpr *TheCall)
BuiltinShuffleVector - Handle __builtin_shufflevector.
@ ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
QualType BuildDecltypeType(Expr *E, bool AsUnevaluated=true)
If AsUnevaluated is false, E is treated as though it were an evaluated context, such as when building...
QualType BuildUnaryTransformType(QualType BaseType, UTTKind UKind, SourceLocation Loc)
StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, BinaryOperatorKind Operator)
ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex, bool IsThrownVarInScope)
QualType BuildArrayType(QualType T, ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity)
Build an array type.
ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field)
QualType BuildReadPipeType(QualType T, SourceLocation Loc)
Build a Read-only Pipe type.
concepts::NestedRequirement * BuildNestedRequirement(Expr *E)
QualType BuildWritePipeType(QualType T, SourceLocation Loc)
Build a Write-only Pipe type.
@ BFRK_Rebuild
Instantiation or recovery rebuild of a for-range statement.
ExprResult CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const DeclarationNameInfo &ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const TemplateArgumentListInfo *TemplateArgs)
void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt)
ActOnCaseStmtBody - This installs a statement as the body of a case.
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
QualType BuildTypeofExprType(Expr *E, TypeOfKind Kind)
ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, TypeSourceInfo *TSInfo, Expr *DimExpr, SourceLocation RParen)
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
ExprResult BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, TypeSourceInfo *Ty, Expr *E, SourceRange AngleBrackets, SourceRange Parens)
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2,...
QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns, SourceLocation AttrLoc)
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member's actual type.
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
ExprResult BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, MultiExprArg ArgExprs, SourceLocation RLoc)
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc.
ExprResult BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder=AtomicArgumentOrder::API)
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
static ConditionResult ConditionError()
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
SemaPseudoObject & PseudoObject()
StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt)
StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef< Stmt * > Handlers)
ActOnCXXTryBlock - Takes a try compound-statement and a number of handlers and creates a try statemen...
StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, Stmt *SubStmt, Scope *CurScope)
ExprResult HandleExprEvaluationContextForTypeof(Expr *E)
StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, SourceLocation DotDotDotLoc, ExprResult RHS, SourceLocation ColonLoc)
QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity)
Build a member pointer type T Class::*.
QualType BuildBlockPointerType(QualType T, SourceLocation Loc, DeclarationName Entity)
Build a block pointer type.
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body)
FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, SourceLocation RBLoc)
StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg Constraints, MultiExprArg Exprs, Expr *AsmString, MultiExprArg Clobbers, unsigned NumLabels, SourceLocation RParenLoc)
static SizeOfPackExpr * Create(ASTContext &Context, SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, std::optional< unsigned > Length=std::nullopt, ArrayRef< TemplateArgument > PartialArgs={})
static bool MayBeDependent(SourceLocIdentKind Kind)
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
A structure for storing an already-substituted template template parameter pack.
Wrapper for substituted template type parameters.
Represents the declaration of a struct/union/class/enum.
A convenient class for passing around template argument information.
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
void addArgument(const TemplateArgumentLoc &Loc)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
const TemplateArgumentLoc * operator->() const
pointer(TemplateArgumentLoc Arg)
Simple iterator that traverses the template arguments in a container that provides a getArgLoc() memb...
TemplateArgumentLoc operator*() const
TemplateArgumentLocContainerIterator operator++(int)
friend bool operator!=(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
TemplateArgumentLocContainerIterator()
TemplateArgumentLoc value_type
TemplateArgumentLocContainerIterator(ArgLocContainer &Container, unsigned Index)
friend bool operator==(const TemplateArgumentLocContainerIterator &X, const TemplateArgumentLocContainerIterator &Y)
TemplateArgumentLocContainerIterator & operator++()
std::input_iterator_tag iterator_category
TemplateArgumentLoc reference
pointer operator->() const
const TemplateArgumentLoc * operator->() const
pointer(TemplateArgumentLoc Arg)
Iterator adaptor that invents template argument location information for each of the template argumen...
TemplateArgumentLocInventIterator & operator++()
pointer operator->() const
std::iterator_traits< InputIterator >::difference_type difference_type
reference operator*() const
TemplateArgumentLocInventIterator operator++(int)
friend bool operator==(const TemplateArgumentLocInventIterator &X, const TemplateArgumentLocInventIterator &Y)
TemplateArgumentLocInventIterator(TreeTransform< Derived > &Self, InputIterator Iter)
friend bool operator!=(const TemplateArgumentLocInventIterator &X, const TemplateArgumentLocInventIterator &Y)
std::input_iterator_tag iterator_category
TemplateArgumentLoc reference
TemplateArgumentLoc value_type
Location wrapper for a TemplateArgument.
const TemplateArgument & getArgument() const
SourceLocation getTemplateNameLoc() const
TypeSourceInfo * getTypeSourceInfo() const
SourceRange getSourceRange() const LLVM_READONLY
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Expr * getSourceExpression() const
Represents a template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a C++ template name within the type system.
bool isNull() const
Determine whether this template name is NULL.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
Stores a list of template parameters for a TemplateDecl and its derived classes.
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
SourceLocation getTemplateNameLoc() const
void setRAngleLoc(SourceLocation Loc)
Represents a type template specialization; the template must be a class template, a type alias templa...
Wrapper for template type parameters.
The top declaration context.
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
void TypeWasModifiedSafely(QualType T)
Tell the TypeLocBuilder that the type it is storing has been modified in some safe way that doesn't a...
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
Base wrapper for a particular "section" of type source info.
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
QualType getType() const
Get the type for which this source info wrapper provides information.
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
unsigned getFullDataSize() const
Returns the size of the type source info data block.
SourceLocation getTemplateKeywordLoc() const
Get the SourceLocation of the template keyword (if any).
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
ElaboratedTypeKeyword getKeyword() const
The base class of the type hierarchy.
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isEnumeralType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
bool isFunctionType() const
bool isObjCObjectPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
Base class for declarations which introduce a typedef-name.
Wrapper for source info for typedefs.
TypedefNameDecl * getTypedefNameDecl() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)
Retrieve the unary opcode that corresponds to the given overloaded operator.
Represents a C++ unqualified-id that has been parsed.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
CXXRecordDecl * getNamingClass()
Gets the 'naming class' (in the sense of C++0x [class.access.base]p5) of the lookup.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, UnresolvedSetIterator Begin, UnresolvedSetIterator End, bool KnownDependent, bool KnownInstantiationDependent)
A set of unresolved declarations.
void addDecl(NamedDecl *D)
A set of unresolved declarations.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
@ CInit
C-style initialization with assignment.
@ CallInit
Call-style initialization (C++98)
StorageClass getStorageClass() const
Returns the storage class as written in the source.
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
A requires-expression requirement which queries the validity and properties of an expression ('simple...
SubstitutionDiagnostic * getExprSubstitutionDiagnostic() const
bool isExprSubstitutionFailure() const
const ReturnTypeRequirement & getReturnTypeRequirement() const
SourceLocation getNoexceptLoc() const
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
const ASTConstraintSatisfaction & getConstraintSatisfaction() const
bool hasInvalidConstraint() const
Expr * getConstraintExpr() const
StringRef getInvalidConstraintEntity()
A static requirement that can be used in a requires-expression to check properties of types and expre...
A requires-expression requirement which queries the existence of a type name or type template special...
bool isSubstitutionFailure() const
SubstitutionDiagnostic * getSubstitutionDiagnostic() const
TypeSourceInfo * getType() const
bool ContainsUnexpandedParameterPack
Whether this contains an unexpanded parameter pack.
CXXRecordDecl * Lambda
The class that describes the lambda.
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
const AstTypeMatcher< FunctionType > functionType
Matches FunctionType nodes.
bool Inc(InterpState &S, CodePtr OpPC)
1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...
bool Comp(InterpState &S, CodePtr OpPC)
1) Pops the value from the stack.
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
ArrayTypeTrait
Names for the array type traits.
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
OpenMPDefaultmapClauseModifier
OpenMP modifiers for 'defaultmap' clause.
OpenMPOrderClauseModifier
OpenMP modifiers for 'order' clause.
IfStatementKind
In an if statement, this denotes whether the statement is a constexpr or consteval if statement.
@ OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
OpenMPAtClauseKind
OpenMP attributes for 'at' clause.
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
@ LCK_ByRef
Capturing by reference.
@ LCK_StarThis
Capturing the *this object by copy.
OpenMPReductionClauseModifier
OpenMP modifiers for 'reduction' clause.
@ Invalid
Represents an invalid clause, for the purposes of parsing.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
TypeOfKind
The kind of 'typeof' expression we're after.
OpenMPScheduleClauseModifier
OpenMP modifiers for 'schedule' clause.
OpenMPDistScheduleClauseKind
OpenMP attributes for 'dist_schedule' clause.
OpenMPDoacrossClauseModifier
OpenMP dependence types for 'doacross' clause.
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
@ Property
The type of a property.
@ Result
The result type of a method or function.
OpenMPBindClauseKind
OpenMP bindings for the 'bind' clause.
ArraySizeModifier
Capture whether this is a normal array (e.g.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
OpenMPLastprivateModifier
OpenMP 'lastprivate' clause modifier.
OpenMPGrainsizeClauseModifier
OpenMPNumTasksClauseModifier
ActionResult< Expr * > ExprResult
TagTypeKind
The kind of a tag type.
bool transformOMPMappableExprListClause(TreeTransform< Derived > &TT, OMPMappableExprListClause< T > *C, llvm::SmallVectorImpl< Expr * > &Vars, CXXScopeSpec &MapperIdScopeSpec, DeclarationNameInfo &MapperIdInfo, llvm::SmallVectorImpl< Expr * > &UnresolvedMappers)
bool isOpenMPLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a directive with an associated loop construct.
std::pair< NullabilityKind, bool > DiagNullabilityKind
A nullability kind paired with a bit indicating whether it used a context-sensitive keyword.
OpenMPSeverityClauseKind
OpenMP attributes for 'severity' clause.
ActionResult< Stmt * > StmtResult
OpenMPDefaultmapClauseKind
OpenMP attributes for 'defaultmap' clause.
OpenMPAllocateClauseModifier
OpenMP modifiers for 'allocate' clause.
OpenMPLinearClauseKind
OpenMP attributes for 'linear' clause.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
OpaquePtr< QualType > ParsedType
An opaque type for threading parsed type information through the parser.
const FunctionProtoType * T
std::pair< llvm::PointerUnion< const TemplateTypeParmType *, NamedDecl * >, SourceLocation > UnexpandedParameterPack
OpenMPDeviceClauseModifier
OpenMP modifiers for 'device' clause.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
OpenMPOrderClauseKind
OpenMP attributes for 'order' clause.
TypeTrait
Names for traits that operate specifically on types.
@ Parens
New-expression has a C++98 paren-delimited initializer.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_Uninstantiated
not instantiated yet
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_Dynamic
throw(T1, T2)
OpenMPScheduleClauseKind
OpenMP attributes for 'schedule' clause.
static QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T)
MutableArrayRef< Expr * > MultiExprArg
OpenMPMapClauseKind
OpenMP mapping kind for 'map' clause.
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
void setNamedTypeInfo(TypeSourceInfo *TInfo)
setNamedTypeInfo - Sets the source type info associated to the name.
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Holds information about the various types of exception specification.
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
This structure contains most locations needed for by an OMPVarListClause.
@ LambdaExpressionSubstitution
We are substituting into a lambda expression.
Keeps information about an identifier in a nested-name-spec.
Location information for a TemplateArgument.