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();
4187 Exprs.push_back(DevNumExpr);
4188 Exprs.insert(Exprs.end(), QueueIdExprs.begin(), QueueIdExprs.end());
4191 Exprs, RParenLoc, EndLoc, Clauses, {});
4215 bool DeducibleTSTContext);
4227template <
typename Derived>
4232 switch (S->getStmtClass()) {
4237#define STMT(Node, Parent) \
4238 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
4239#define VALUESTMT(Node, Parent) \
4240 case Stmt::Node##Class: \
4241 return getDerived().Transform##Node(cast<Node>(S), SDK);
4242#define ABSTRACT_STMT(Node)
4243#define EXPR(Node, Parent)
4244#include "clang/AST/StmtNodes.inc"
4247#define STMT(Node, Parent)
4248#define ABSTRACT_STMT(Stmt)
4249#define EXPR(Node, Parent) case Stmt::Node##Class:
4250#include "clang/AST/StmtNodes.inc"
4252 ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
4254 if (SDK == SDK_StmtExprResult)
4255 E = getSema().ActOnStmtExprResult(
E);
4256 return getSema().ActOnExprStmt(
E, SDK == SDK_Discarded);
4263template<
typename Derived>
4268 switch (S->getClauseKind()) {
4271#define GEN_CLANG_CLAUSE_CLASS
4272#define CLAUSE_CLASS(Enum, Str, Class) \
4274 return getDerived().Transform##Class(cast<Class>(S));
4275#include "llvm/Frontend/OpenMP/OMP.inc"
4282template<
typename Derived>
4289#define STMT(Node, Parent) case Stmt::Node##Class: break;
4290#define ABSTRACT_STMT(Stmt)
4291#define EXPR(Node, Parent) \
4292 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4293#include "clang/AST/StmtNodes.inc"
4299template<
typename Derived>
4307 if (
auto *FE = dyn_cast<FullExpr>(
Init))
4308 Init = FE->getSubExpr();
4310 if (
auto *AIL = dyn_cast<ArrayInitLoopExpr>(
Init)) {
4316 Init = MTE->getSubExpr();
4319 Init = Binder->getSubExpr();
4322 Init = ICE->getSubExprAsWritten();
4325 dyn_cast<CXXStdInitializerListExpr>(
Init))
4326 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4333 return getDerived().TransformExpr(
Init);
4338 return getDerived().RebuildParenListExpr(
Parens.getBegin(), {},
4343 if (isa<ImplicitValueInitExpr>(
Init))
4349 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct))
4350 return getDerived().TransformExpr(
Init);
4355 return TransformInitializer(Construct->
getArg(0), NotCopyInit);
4362 getSema().currentEvaluationContext().InLifetimeExtendingContext =
4363 getSema().parentEvaluationContext().InLifetimeExtendingContext;
4364 getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit =
4365 getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit;
4367 bool ArgChanged =
false;
4369 true, NewArgs, &ArgChanged))
4374 return getDerived().RebuildInitList(Construct->
getBeginLoc(), NewArgs,
4379 if (
Parens.isInvalid()) {
4382 assert(NewArgs.empty() &&
4383 "no parens or braces but have direct init with arguments?");
4386 return getDerived().RebuildParenListExpr(
Parens.getBegin(), NewArgs,
4390template<
typename Derived>
4396 for (
unsigned I = 0; I != NumInputs; ++I) {
4398 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4406 Expr *Pattern = Expansion->getPattern();
4409 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4410 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
4415 bool RetainExpansion =
false;
4416 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4417 std::optional<unsigned> NumExpansions = OrigNumExpansions;
4418 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4421 Expand, RetainExpansion,
4430 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4434 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.
get(),
4435 Expansion->getEllipsisLoc(),
4437 if (Out.isInvalid())
4442 Outputs.push_back(Out.get());
4448 if (ArgChanged) *ArgChanged =
true;
4452 for (
unsigned I = 0; I != *NumExpansions; ++I) {
4454 ExprResult Out = getDerived().TransformExpr(Pattern);
4455 if (Out.isInvalid())
4458 if (Out.get()->containsUnexpandedParameterPack()) {
4459 Out = getDerived().RebuildPackExpansion(
4460 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4461 if (Out.isInvalid())
4465 Outputs.push_back(Out.get());
4470 if (RetainExpansion) {
4471 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4473 ExprResult Out = getDerived().TransformExpr(Pattern);
4474 if (Out.isInvalid())
4477 Out = getDerived().RebuildPackExpansion(
4478 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4479 if (Out.isInvalid())
4482 Outputs.push_back(Out.get());
4489 IsCall ? getDerived().TransformInitializer(Inputs[I],
false)
4490 : getDerived().TransformExpr(Inputs[I]);
4494 if (
Result.get() != Inputs[I] && ArgChanged)
4497 Outputs.push_back(
Result.get());
4503template <
typename Derived>
4507 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4508 getDerived().TransformDefinition(Var->
getLocation(), Var));
4513 return getSema().ActOnConditionVariable(ConditionVar,
Loc, Kind);
4522 return getSema().ActOnCondition(
nullptr,
Loc, CondExpr.
get(), Kind,
4529template <
typename Derived>
4537 Qualifier = Qualifier.getPrefix())
4553 SS, FirstQualifierInScope,
false))
4560 cast_or_null<NamespaceDecl>(getDerived().TransformDecl(
4568 cast_or_null<NamespaceAliasDecl>(getDerived().TransformDecl(
4583 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
4592 FirstQualifierInScope, SS);
4602 diag::warn_cxx98_compat_enum_nested_name_spec);
4605 SS.
Adopt(ETL.getQualifierLoc());
4606 TL = ETL.getNamedTypeLoc();
4625 FirstQualifierInScope =
nullptr;
4631 !getDerived().AlwaysRebuild())
4644template<
typename Derived>
4652 switch (Name.getNameKind()) {
4663 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4664 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4665 getDerived().TransformDecl(NameInfo.
getLoc(), OldTemplate));
4681 NewTInfo = getDerived().TransformType(OldTInfo);
4689 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4705 llvm_unreachable(
"Unknown name kind.");
4708template<
typename Derived>
4715 bool AllowInjectedClassName) {
4717 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4718 assert(Template &&
"qualified template name must refer to a template");
4721 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4726 if (!getDerived().AlwaysRebuild() &&
4728 TransTemplate == Template)
4731 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4739 FirstQualifierInScope =
nullptr;
4742 if (!getDerived().AlwaysRebuild() &&
4750 if (DTN->isIdentifier()) {
4751 return getDerived().RebuildTemplateName(SS,
4753 *DTN->getIdentifier(),
4756 FirstQualifierInScope,
4757 AllowInjectedClassName);
4760 return getDerived().RebuildTemplateName(SS, TemplateKWLoc,
4761 DTN->getOperator(), NameLoc,
4762 ObjectType, AllowInjectedClassName);
4766 if (
TemplateDecl *Template = Name.getAsTemplateDecl()) {
4768 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc,
4773 return getDerived().RebuildTemplateName(SS,
false,
4778 = Name.getAsSubstTemplateTemplateParmPack()) {
4779 return getDerived().RebuildTemplateName(
4780 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4781 SubstPack->getIndex(), SubstPack->getFinal());
4785 llvm_unreachable(
"overloaded function decl survived to here");
4788template<
typename Derived>
4792 Output = getSema().getTrivialTemplateArgumentLoc(
4793 Arg,
QualType(), getDerived().getBaseLocation());
4796template <
typename Derived>
4804 llvm_unreachable(
"Unexpected TemplateArgument");
4814 QualType NewT = getDerived().TransformType(
T);
4821 ValueDecl *NewD =
D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
4822 getDerived().getBaseLocation(),
D))
4827 if (NewT ==
T &&
D == NewD)
4844 llvm_unreachable(
"unexpected template argument kind");
4854 DI = getDerived().TransformType(DI);
4865 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
4871 SS.
Adopt(QualifierLoc);
4872 TemplateName Template = getDerived().TransformTemplateName(
4883 llvm_unreachable(
"Caller should expand pack expansions");
4898 ExprResult E = getDerived().TransformExpr(InputExpr);
4913template<
typename Derived,
typename InputIterator>
4921 typedef typename std::iterator_traits<InputIterator>::difference_type
4951 Self.InventTemplateArgumentLoc(*
Iter,
Result);
4959 return X.Iter == Y.Iter;
4964 return X.Iter != Y.Iter;
4968template<
typename Derived>
4969template<
typename InputIterator>
4986 if (TransformTemplateArguments(PackLocIterator(*
this,
4987 In.getArgument().pack_begin()),
4988 PackLocIterator(*
this,
4989 In.getArgument().pack_end()),
4996 if (In.getArgument().isPackExpansion()) {
5000 std::optional<unsigned> OrigNumExpansions;
5002 = getSema().getTemplateArgumentPackExpansionPattern(
5003 In, Ellipsis, OrigNumExpansions);
5006 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5007 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
5012 bool RetainExpansion =
false;
5013 std::optional<unsigned> NumExpansions = OrigNumExpansions;
5014 if (getDerived().TryExpandParameterPacks(Ellipsis,
5028 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
5031 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis,
5033 if (Out.getArgument().isNull())
5042 for (
unsigned I = 0; I != *NumExpansions; ++I) {
5045 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5048 if (Out.getArgument().containsUnexpandedParameterPack()) {
5049 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5051 if (Out.getArgument().isNull())
5060 if (RetainExpansion) {
5061 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5063 if (getDerived().TransformTemplateArgument(Pattern, Out, Uneval))
5066 Out = getDerived().RebuildPackExpansion(Out, Ellipsis,
5068 if (Out.getArgument().isNull())
5078 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
5092template<
typename Derived>
5094 if (getDerived().AlreadyTransformed(
T))
5100 getDerived().getBaseLocation());
5110template<
typename Derived>
5114 getDerived().getBaseEntity());
5115 if (getDerived().AlreadyTransformed(DI->
getType()))
5130template<
typename Derived>
5133 switch (
T.getTypeLocClass()) {
5134#define ABSTRACT_TYPELOC(CLASS, PARENT)
5135#define TYPELOC(CLASS, PARENT) \
5136 case TypeLoc::CLASS: \
5137 return getDerived().Transform##CLASS##Type(TLB, \
5138 T.castAs<CLASS##TypeLoc>());
5139#include "clang/AST/TypeLocNodes.def"
5142 llvm_unreachable(
"unhandled type loc!");
5145template<
typename Derived>
5147 if (!isa<DependentNameType>(
T))
5148 return TransformType(
T);
5150 if (getDerived().AlreadyTransformed(
T))
5153 getDerived().getBaseLocation());
5154 TypeSourceInfo *NewDI = getDerived().TransformTypeWithDeducedTST(DI);
5158template<
typename Derived>
5161 if (!isa<DependentNameType>(DI->
getType()))
5162 return TransformType(DI);
5166 getDerived().getBaseEntity());
5167 if (getDerived().AlreadyTransformed(DI->
getType()))
5187 Result = getDerived().RebuildQualifiedType(
Result, QTL);
5196template<
typename Derived>
5201 TypeLoc UnqualTL =
T.getUnqualifiedLoc();
5202 auto SuppressObjCLifetime =
5203 T.getType().getLocalQualifiers().hasObjCLifetime();
5205 Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
5206 SuppressObjCLifetime);
5207 }
else if (
auto STTP = UnqualTL.
getAs<SubstTemplateTypeParmPackTypeLoc>()) {
5208 Result = getDerived().TransformSubstTemplateTypeParmPackType(
5209 TLB, STTP, SuppressObjCLifetime);
5211 Result = getDerived().TransformType(TLB, UnqualTL);
5230template <
typename Derived>
5240 SemaRef.
Diag(
Loc, diag::err_address_space_mismatch_templ_inst)
5271 else if (
T.getObjCLifetime()) {
5276 if ((AutoTy = dyn_cast<AutoType>(
T)) && AutoTy->
isDeduced()) {
5292 SemaRef.
Diag(
Loc, diag::err_attr_objc_ownership_redundant) <<
T;
5301template<
typename Derived>
5307 if (getDerived().AlreadyTransformed(TL.
getType()))
5311 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS);
5317template<
typename Derived>
5319TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
5320 QualType ObjectType,
5321 NamedDecl *UnqualLookup,
5323 if (getDerived().AlreadyTransformed(TSInfo->getType()))
5326 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
5330template <
typename Derived>
5331TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope(
5332 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup,
5334 QualType
T = TL.getType();
5335 assert(!getDerived().AlreadyTransformed(
T));
5340 if (isa<TemplateSpecializationType>(
T)) {
5341 TemplateSpecializationTypeLoc SpecTL =
5342 TL.castAs<TemplateSpecializationTypeLoc>();
5344 TemplateName Template = getDerived().TransformTemplateName(
5345 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
5346 ObjectType, UnqualLookup,
true);
5347 if (Template.isNull())
5350 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
5352 }
else if (isa<DependentTemplateSpecializationType>(
T)) {
5353 DependentTemplateSpecializationTypeLoc SpecTL =
5354 TL.castAs<DependentTemplateSpecializationTypeLoc>();
5356 TemplateName Template
5357 = getDerived().RebuildTemplateName(SS,
5358 SpecTL.getTemplateKeywordLoc(),
5359 *SpecTL.getTypePtr()->getIdentifier(),
5360 SpecTL.getTemplateNameLoc(),
5361 ObjectType, UnqualLookup,
5363 if (Template.isNull())
5366 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
5372 Result = getDerived().TransformType(TLB, TL);
5381template <
class TyLoc>
static inline
5383 TyLoc NewT = TLB.
push<TyLoc>(
T.getType());
5384 NewT.setNameLoc(
T.getNameLoc());
5388template<
typename Derived>
5389QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
5391 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(
T.getType());
5392 NewT.setBuiltinLoc(
T.getBuiltinLoc());
5393 if (
T.needsExtraLocalData())
5394 NewT.getWrittenBuiltinSpecs() =
T.getWrittenBuiltinSpecs();
5398template<
typename Derived>
5399QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
5405template <
typename Derived>
5406QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
5407 AdjustedTypeLoc TL) {
5409 return getDerived().TransformType(TLB, TL.getOriginalLoc());
5412template<
typename Derived>
5413QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
5414 DecayedTypeLoc TL) {
5415 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
5416 if (OriginalType.isNull())
5419 QualType
Result = TL.getType();
5420 if (getDerived().AlwaysRebuild() ||
5421 OriginalType != TL.getOriginalLoc().getType())
5423 TLB.push<DecayedTypeLoc>(
Result);
5428template <
typename Derived>
5430TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB,
5431 ArrayParameterTypeLoc TL) {
5432 QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc());
5433 if (OriginalType.isNull())
5436 QualType
Result = TL.getType();
5437 if (getDerived().AlwaysRebuild() ||
5438 OriginalType != TL.getElementLoc().getType())
5440 TLB.push<ArrayParameterTypeLoc>(
Result);
5445template<
typename Derived>
5446QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
5447 PointerTypeLoc TL) {
5448 QualType PointeeType
5449 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5450 if (PointeeType.isNull())
5453 QualType
Result = TL.getType();
5454 if (PointeeType->getAs<ObjCObjectType>()) {
5461 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(
Result);
5462 NewT.setStarLoc(TL.getStarLoc());
5466 if (getDerived().AlwaysRebuild() ||
5467 PointeeType != TL.getPointeeLoc().getType()) {
5468 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
5475 TLB.TypeWasModifiedSafely(
Result->getPointeeType());
5477 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(
Result);
5478 NewT.setSigilLoc(TL.getSigilLoc());
5482template<
typename Derived>
5484TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
5485 BlockPointerTypeLoc TL) {
5486 QualType PointeeType
5487 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5488 if (PointeeType.isNull())
5491 QualType
Result = TL.getType();
5492 if (getDerived().AlwaysRebuild() ||
5493 PointeeType != TL.getPointeeLoc().getType()) {
5494 Result = getDerived().RebuildBlockPointerType(PointeeType,
5500 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(
Result);
5501 NewT.setSigilLoc(TL.getSigilLoc());
5509template<
typename Derived>
5517 if (PointeeType.
isNull())
5521 if (getDerived().AlwaysRebuild() ||
5522 PointeeType !=
T->getPointeeTypeAsWritten()) {
5523 Result = getDerived().RebuildReferenceType(PointeeType,
5524 T->isSpelledAsLValue(),
5537 if (isa<LValueReferenceType>(
Result))
5546template<
typename Derived>
5550 return TransformReferenceType(TLB, TL);
5553template<
typename Derived>
5555TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
5556 RValueReferenceTypeLoc TL) {
5557 return TransformReferenceType(TLB, TL);
5560template<
typename Derived>
5562TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
5563 MemberPointerTypeLoc TL) {
5564 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5565 if (PointeeType.isNull())
5568 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo();
5569 TypeSourceInfo *NewClsTInfo =
nullptr;
5571 NewClsTInfo = getDerived().TransformType(OldClsTInfo);
5576 const MemberPointerType *
T = TL.getTypePtr();
5577 QualType OldClsType = QualType(
T->getClass(), 0);
5578 QualType NewClsType;
5580 NewClsType = NewClsTInfo->getType();
5582 NewClsType = getDerived().TransformType(OldClsType);
5583 if (NewClsType.isNull())
5587 QualType
Result = TL.getType();
5588 if (getDerived().AlwaysRebuild() ||
5590 NewClsType != OldClsType) {
5591 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType,
5599 const MemberPointerType *MPT =
Result->getAs<MemberPointerType>();
5600 if (MPT && PointeeType != MPT->getPointeeType()) {
5601 assert(isa<AdjustedType>(MPT->getPointeeType()));
5602 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
5605 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(
Result);
5606 NewTL.setSigilLoc(TL.getSigilLoc());
5607 NewTL.setClassTInfo(NewClsTInfo);
5612template<
typename Derived>
5614TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
5615 ConstantArrayTypeLoc TL) {
5616 const ConstantArrayType *
T = TL.getTypePtr();
5617 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5618 if (ElementType.isNull())
5622 Expr *
OldSize = TL.getSizeExpr();
5624 OldSize =
const_cast<Expr*
>(
T->getSizeExpr());
5625 Expr *NewSize =
nullptr;
5629 NewSize = getDerived().TransformExpr(
OldSize).template getAs<Expr>();
5633 QualType
Result = TL.getType();
5634 if (getDerived().AlwaysRebuild() ||
5635 ElementType !=
T->getElementType() ||
5636 (
T->getSizeExpr() && NewSize !=
OldSize)) {
5637 Result = getDerived().RebuildConstantArrayType(ElementType,
5638 T->getSizeModifier(),
5639 T->getSize(), NewSize,
5640 T->getIndexTypeCVRQualifiers(),
5641 TL.getBracketsRange());
5650 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5651 NewTL.setLBracketLoc(TL.getLBracketLoc());
5652 NewTL.setRBracketLoc(TL.getRBracketLoc());
5653 NewTL.setSizeExpr(NewSize);
5658template<
typename Derived>
5659QualType TreeTransform<Derived>::TransformIncompleteArrayType(
5660 TypeLocBuilder &TLB,
5661 IncompleteArrayTypeLoc TL) {
5662 const IncompleteArrayType *
T = TL.getTypePtr();
5663 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5664 if (ElementType.isNull())
5667 QualType
Result = TL.getType();
5668 if (getDerived().AlwaysRebuild() ||
5669 ElementType !=
T->getElementType()) {
5670 Result = getDerived().RebuildIncompleteArrayType(ElementType,
5671 T->getSizeModifier(),
5672 T->getIndexTypeCVRQualifiers(),
5673 TL.getBracketsRange());
5678 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(
Result);
5679 NewTL.setLBracketLoc(TL.getLBracketLoc());
5680 NewTL.setRBracketLoc(TL.getRBracketLoc());
5681 NewTL.setSizeExpr(
nullptr);
5686template<
typename Derived>
5688TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
5689 VariableArrayTypeLoc TL) {
5690 const VariableArrayType *
T = TL.getTypePtr();
5691 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5692 if (ElementType.isNull())
5697 EnterExpressionEvaluationContext Context(
5699 SizeResult = getDerived().TransformExpr(
T->getSizeExpr());
5701 if (SizeResult.isInvalid())
5705 if (SizeResult.isInvalid())
5708 Expr *
Size = SizeResult.get();
5710 QualType
Result = TL.getType();
5711 if (getDerived().AlwaysRebuild() ||
5712 ElementType !=
T->getElementType() ||
5713 Size !=
T->getSizeExpr()) {
5714 Result = getDerived().RebuildVariableArrayType(ElementType,
5715 T->getSizeModifier(),
5717 T->getIndexTypeCVRQualifiers(),
5718 TL.getBracketsRange());
5725 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5726 NewTL.setLBracketLoc(TL.getLBracketLoc());
5727 NewTL.setRBracketLoc(TL.getRBracketLoc());
5728 NewTL.setSizeExpr(Size);
5733template<
typename Derived>
5735TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
5736 DependentSizedArrayTypeLoc TL) {
5737 const DependentSizedArrayType *
T = TL.getTypePtr();
5738 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5739 if (ElementType.isNull())
5747 SemaRef.
ExprEvalContexts.back().InConditionallyConstantEvaluateContext =
true;
5750 Expr *origSize = TL.getSizeExpr();
5751 if (!origSize) origSize =
T->getSizeExpr();
5754 = getDerived().TransformExpr(origSize);
5756 if (sizeResult.isInvalid())
5759 Expr *size = sizeResult.get();
5761 QualType
Result = TL.getType();
5762 if (getDerived().AlwaysRebuild() ||
5763 ElementType !=
T->getElementType() ||
5765 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
5766 T->getSizeModifier(),
5768 T->getIndexTypeCVRQualifiers(),
5769 TL.getBracketsRange());
5776 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(
Result);
5777 NewTL.setLBracketLoc(TL.getLBracketLoc());
5778 NewTL.setRBracketLoc(TL.getRBracketLoc());
5779 NewTL.setSizeExpr(size);
5784template <
typename Derived>
5785QualType TreeTransform<Derived>::TransformDependentVectorType(
5786 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
5787 const DependentVectorType *
T = TL.getTypePtr();
5788 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5789 if (ElementType.isNull())
5797 if (
Size.isInvalid())
5800 QualType
Result = TL.getType();
5801 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType() ||
5802 Size.get() !=
T->getSizeExpr()) {
5803 Result = getDerived().RebuildDependentVectorType(
5804 ElementType,
Size.get(),
T->getAttributeLoc(),
T->getVectorKind());
5810 if (isa<DependentVectorType>(
Result)) {
5811 DependentVectorTypeLoc NewTL =
5812 TLB.push<DependentVectorTypeLoc>(
Result);
5813 NewTL.setNameLoc(TL.getNameLoc());
5815 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(
Result);
5816 NewTL.setNameLoc(TL.getNameLoc());
5822template<
typename Derived>
5823QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
5824 TypeLocBuilder &TLB,
5825 DependentSizedExtVectorTypeLoc TL) {
5826 const DependentSizedExtVectorType *
T = TL.getTypePtr();
5829 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5830 if (ElementType.isNull())
5839 if (
Size.isInvalid())
5842 QualType
Result = TL.getType();
5843 if (getDerived().AlwaysRebuild() ||
5844 ElementType !=
T->getElementType() ||
5845 Size.get() !=
T->getSizeExpr()) {
5846 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType,
5848 T->getAttributeLoc());
5854 if (isa<DependentSizedExtVectorType>(
Result)) {
5855 DependentSizedExtVectorTypeLoc NewTL
5856 = TLB.push<DependentSizedExtVectorTypeLoc>(
Result);
5857 NewTL.setNameLoc(TL.getNameLoc());
5859 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(
Result);
5860 NewTL.setNameLoc(TL.getNameLoc());
5866template <
typename Derived>
5868TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
5869 ConstantMatrixTypeLoc TL) {
5870 const ConstantMatrixType *
T = TL.getTypePtr();
5871 QualType ElementType = getDerived().TransformType(
T->getElementType());
5872 if (ElementType.isNull())
5875 QualType
Result = TL.getType();
5876 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType()) {
5877 Result = getDerived().RebuildConstantMatrixType(
5878 ElementType,
T->getNumRows(),
T->getNumColumns());
5883 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(
Result);
5884 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5885 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5886 NewTL.setAttrRowOperand(TL.getAttrRowOperand());
5887 NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());
5892template <
typename Derived>
5893QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
5894 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
5895 const DependentSizedMatrixType *
T = TL.getTypePtr();
5897 QualType ElementType = getDerived().TransformType(
T->getElementType());
5898 if (ElementType.isNull()) {
5906 Expr *origRows = TL.getAttrRowOperand();
5908 origRows =
T->getRowExpr();
5909 Expr *origColumns = TL.getAttrColumnOperand();
5911 origColumns =
T->getColumnExpr();
5913 ExprResult rowResult = getDerived().TransformExpr(origRows);
5915 if (rowResult.isInvalid())
5918 ExprResult columnResult = getDerived().TransformExpr(origColumns);
5920 if (columnResult.isInvalid())
5923 Expr *rows = rowResult.get();
5924 Expr *columns = columnResult.get();
5926 QualType
Result = TL.getType();
5927 if (getDerived().AlwaysRebuild() || ElementType !=
T->getElementType() ||
5928 rows != origRows || columns != origColumns) {
5929 Result = getDerived().RebuildDependentSizedMatrixType(
5930 ElementType, rows, columns,
T->getAttributeLoc());
5938 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(
Result);
5939 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5940 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5941 NewTL.setAttrRowOperand(rows);
5942 NewTL.setAttrColumnOperand(columns);
5946template <
typename Derived>
5947QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
5948 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
5949 const DependentAddressSpaceType *
T = TL.getTypePtr();
5951 QualType pointeeType =
5952 getDerived().TransformType(TLB, TL.getPointeeTypeLoc());
5954 if (pointeeType.isNull())
5961 ExprResult AddrSpace = getDerived().TransformExpr(
T->getAddrSpaceExpr());
5963 if (AddrSpace.isInvalid())
5966 QualType
Result = TL.getType();
5967 if (getDerived().AlwaysRebuild() || pointeeType !=
T->
getPointeeType() ||
5968 AddrSpace.get() !=
T->getAddrSpaceExpr()) {
5969 Result = getDerived().RebuildDependentAddressSpaceType(
5970 pointeeType, AddrSpace.get(),
T->getAttributeLoc());
5976 if (isa<DependentAddressSpaceType>(
Result)) {
5977 DependentAddressSpaceTypeLoc NewTL =
5978 TLB.push<DependentAddressSpaceTypeLoc>(
Result);
5980 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
5981 NewTL.setAttrExprOperand(TL.getAttrExprOperand());
5982 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
5985 TLB.TypeWasModifiedSafely(
Result);
5991template <
typename Derived>
5992QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
5994 const VectorType *
T = TL.getTypePtr();
5995 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5996 if (ElementType.isNull())
5999 QualType
Result = TL.getType();
6000 if (getDerived().AlwaysRebuild() ||
6001 ElementType !=
T->getElementType()) {
6002 Result = getDerived().RebuildVectorType(ElementType,
T->getNumElements(),
6003 T->getVectorKind());
6008 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(
Result);
6009 NewTL.setNameLoc(TL.getNameLoc());
6014template<
typename Derived>
6015QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
6016 ExtVectorTypeLoc TL) {
6017 const VectorType *
T = TL.getTypePtr();
6018 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6019 if (ElementType.isNull())
6022 QualType
Result = TL.getType();
6023 if (getDerived().AlwaysRebuild() ||
6024 ElementType !=
T->getElementType()) {
6025 Result = getDerived().RebuildExtVectorType(ElementType,
6026 T->getNumElements(),
6032 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(
Result);
6033 NewTL.setNameLoc(TL.getNameLoc());
6038template <
typename Derived>
6041 std::optional<unsigned> NumExpansions,
bool ExpectParameterPack) {
6045 if (NumExpansions && isa<PackExpansionType>(OldDI->
getType())) {
6072 NewDI = getDerived().TransformType(OldDI);
6076 if (NewDI == OldDI && indexAdjustment == 0)
6090 transformedLocalDecl(OldParm, {newParm});
6094template <
typename Derived>
6102 unsigned *LastParamTransformed) {
6103 int indexAdjustment = 0;
6105 unsigned NumParams = Params.size();
6106 for (
unsigned i = 0; i != NumParams; ++i) {
6107 if (LastParamTransformed)
6108 *LastParamTransformed = i;
6110 assert(OldParm->getFunctionScopeIndex() == i);
6112 std::optional<unsigned> NumExpansions;
6114 if (OldParm->isParameterPack()) {
6119 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
6125 bool ShouldExpand =
false;
6126 bool RetainExpansion =
false;
6127 std::optional<unsigned> OrigNumExpansions;
6128 if (Unexpanded.size() > 0) {
6130 NumExpansions = OrigNumExpansions;
6131 if (getDerived().TryExpandParameterPacks(ExpansionTL.
getEllipsisLoc(),
6132 Pattern.getSourceRange(),
6144 "Could not find parameter packs or undeduced auto type!");
6151 getDerived().ExpandingFunctionParameterPack(OldParm);
6152 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6155 = getDerived().TransformFunctionTypeParam(OldParm,
6163 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6164 OutParamTypes.push_back(NewParm->
getType());
6166 PVars->push_back(NewParm);
6171 if (RetainExpansion) {
6172 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6174 = getDerived().TransformFunctionTypeParam(OldParm,
6182 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6183 OutParamTypes.push_back(NewParm->
getType());
6185 PVars->push_back(NewParm);
6201 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
6206 "Parameter pack no longer a parameter pack after "
6209 NewParm = getDerived().TransformFunctionTypeParam(
6210 OldParm, indexAdjustment, std::nullopt,
6218 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6219 OutParamTypes.push_back(NewParm->
getType());
6221 PVars->push_back(NewParm);
6229 bool IsPackExpansion =
false;
6230 std::optional<unsigned> NumExpansions;
6233 = dyn_cast<PackExpansionType>(OldType)) {
6235 QualType Pattern = Expansion->getPattern();
6237 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
6240 bool ShouldExpand =
false;
6241 bool RetainExpansion =
false;
6253 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6255 QualType NewType = getDerived().TransformType(Pattern);
6260 NewType = getSema().getASTContext().getPackExpansionType(
6261 NewType, std::nullopt);
6268 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6269 OutParamTypes.push_back(NewType);
6271 PVars->push_back(
nullptr);
6280 if (RetainExpansion) {
6281 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6282 QualType NewType = getDerived().TransformType(Pattern);
6287 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6288 OutParamTypes.push_back(NewType);
6290 PVars->push_back(
nullptr);
6295 OldType = Expansion->getPattern();
6296 IsPackExpansion =
true;
6298 NewType = getDerived().TransformType(OldType);
6300 NewType = getDerived().TransformType(OldType);
6306 if (IsPackExpansion)
6307 NewType = getSema().Context.getPackExpansionType(NewType,
6311 PInfos.
set(OutParamTypes.size(), ParamInfos[i]);
6312 OutParamTypes.push_back(NewType);
6314 PVars->push_back(
nullptr);
6319 for (
unsigned i = 0, e = PVars->size(); i != e; ++i)
6321 assert(parm->getFunctionScopeIndex() == i);
6328template<
typename Derived>
6333 return getDerived().TransformFunctionProtoType(
6336 return getDerived().TransformExceptionSpec(TL.
getBeginLoc(), ESI,
6337 ExceptionStorage, Changed);
6341template<
typename Derived>
template<
typename Fn>
6344 Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {
6361 if (getDerived().TransformFunctionTypeParams(
6365 ParamTypes, &ParamDecls, ExtParamInfos))
6377 SemaRef, !ThisContext && RD ? RD : ThisContext, ThisTypeQuals);
6379 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
6385 ResultType = getDerived().TransformType(TLB, TL.
getReturnLoc());
6389 if (getDerived().TransformFunctionTypeParams(
6393 ParamTypes, &ParamDecls, ExtParamInfos))
6399 bool EPIChanged =
false;
6404 if (
auto NewExtParamInfos =
6420 std::optional<FunctionEffectSet> NewFX;
6429 ExprResult NewExpr = getDerived().TransformExpr(CondExpr);
6432 std::optional<FunctionEffectMode> Mode =
6452 "FunctionEffectMode::None shouldn't be possible here");
6458 NewFX->insert(NewEC, Errs);
6459 assert(Errs.empty());
6467 if (getDerived().AlwaysRebuild() || ResultType !=
T->
getReturnType() ||
6469 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
6480 for (
unsigned i = 0, e = NewTL.
getNumParams(); i != e; ++i)
6486template<
typename Derived>
6496 auto *Method = dyn_cast_if_present<CXXMethodDecl>(ESI.
SourceTemplate);
6498 SemaRef, Method ? Method->getParent() :
nullptr,
6499 Method ? Method->getMethodQualifiers() :
Qualifiers{},
6509 getSema().ActOnNoexceptSpec(NoexceptExpr.
get(), EST);
6532 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
6537 bool Expand =
false;
6538 bool RetainExpansion =
false;
6539 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6542 if (getDerived().TryExpandParameterPacks(
6544 RetainExpansion, NumExpansions))
6552 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6557 Exceptions.push_back(
U);
6563 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
6566 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6570 Exceptions.push_back(
U);
6579 Exceptions.push_back(
U);
6589template<
typename Derived>
6599 if (getDerived().AlwaysRebuild() || ResultType !=
T->
getReturnType())
6600 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
6611template <
typename Derived>
6612QualType TreeTransform<Derived>::TransformUnresolvedUsingType(
6613 TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
6614 const UnresolvedUsingType *
T = TL.getTypePtr();
6615 Decl *
D = getDerived().TransformDecl(TL.getNameLoc(),
T->getDecl());
6619 QualType
Result = TL.getType();
6620 if (getDerived().AlwaysRebuild() ||
D !=
T->getDecl()) {
6621 Result = getDerived().RebuildUnresolvedUsingType(TL.getNameLoc(),
D);
6628 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(
Result);
6629 NewTL.setNameLoc(TL.getNameLoc());
6634template <
typename Derived>
6635QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
6637 const UsingType *
T = TL.getTypePtr();
6639 auto *
Found = cast_or_null<UsingShadowDecl>(getDerived().TransformDecl(
6640 TL.getLocalSourceRange().getBegin(),
T->getFoundDecl()));
6644 QualType Underlying = getDerived().TransformType(
T->
desugar());
6645 if (Underlying.isNull())
6648 QualType
Result = TL.getType();
6649 if (getDerived().AlwaysRebuild() ||
Found !=
T->getFoundDecl() ||
6650 Underlying !=
T->getUnderlyingType()) {
6651 Result = getDerived().RebuildUsingType(
Found, Underlying);
6656 TLB.pushTypeSpec(
Result).setNameLoc(TL.getNameLoc());
6660template<
typename Derived>
6661QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
6662 TypedefTypeLoc TL) {
6663 const TypedefType *
T = TL.getTypePtr();
6664 TypedefNameDecl *Typedef
6665 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6670 QualType
Result = TL.getType();
6671 if (getDerived().AlwaysRebuild() ||
6672 Typedef !=
T->getDecl()) {
6673 Result = getDerived().RebuildTypedefType(Typedef);
6678 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(
Result);
6679 NewTL.setNameLoc(TL.getNameLoc());
6684template<
typename Derived>
6685QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
6686 TypeOfExprTypeLoc TL) {
6692 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
6700 QualType
Result = TL.getType();
6702 if (getDerived().AlwaysRebuild() ||
E.get() != TL.getUnderlyingExpr()) {
6704 getDerived().RebuildTypeOfExprType(
E.get(), TL.getTypeofLoc(), Kind);
6709 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(
Result);
6710 NewTL.setTypeofLoc(TL.getTypeofLoc());
6711 NewTL.setLParenLoc(TL.getLParenLoc());
6712 NewTL.setRParenLoc(TL.getRParenLoc());
6717template<
typename Derived>
6718QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
6720 TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();
6721 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
6725 QualType
Result = TL.getType();
6727 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
6728 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
6733 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(
Result);
6734 NewTL.setTypeofLoc(TL.getTypeofLoc());
6735 NewTL.setLParenLoc(TL.getLParenLoc());
6736 NewTL.setRParenLoc(TL.getRParenLoc());
6737 NewTL.setUnmodifiedTInfo(New_Under_TI);
6742template<
typename Derived>
6743QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
6744 DecltypeTypeLoc TL) {
6745 const DecltypeType *
T = TL.getTypePtr();
6752 ExprResult E = getDerived().TransformExpr(
T->getUnderlyingExpr());
6756 E = getSema().ActOnDecltypeExpression(
E.get());
6760 QualType
Result = TL.getType();
6761 if (getDerived().AlwaysRebuild() ||
6762 E.get() !=
T->getUnderlyingExpr()) {
6763 Result = getDerived().RebuildDecltypeType(
E.get(), TL.getDecltypeLoc());
6769 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(
Result);
6770 NewTL.setDecltypeLoc(TL.getDecltypeLoc());
6771 NewTL.setRParenLoc(TL.getRParenLoc());
6775template <
typename Derived>
6777TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,
6778 PackIndexingTypeLoc TL) {
6782 EnterExpressionEvaluationContext ConstantContext(
6785 IndexExpr = getDerived().TransformExpr(TL.getIndexExpr());
6786 if (IndexExpr.isInvalid())
6789 QualType Pattern = TL.getPattern();
6791 const PackIndexingType *PIT = TL.getTypePtr();
6795 bool NotYetExpanded = Types.empty();
6796 bool FullySubstituted =
true;
6798 if (Types.empty() && !PIT->expandsToEmptyPack())
6801 for (QualType
T : Types) {
6803 QualType Transformed = getDerived().TransformType(
T);
6804 if (Transformed.isNull())
6806 SubtitutedTypes.push_back(Transformed);
6811 getSema().collectUnexpandedParameterPacks(
T, Unexpanded);
6812 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
6815 bool ShouldExpand =
true;
6816 bool RetainExpansion =
false;
6817 std::optional<unsigned> OrigNumExpansions;
6818 std::optional<unsigned> NumExpansions = OrigNumExpansions;
6819 if (getDerived().TryExpandParameterPacks(TL.getEllipsisLoc(), SourceRange(),
6820 Unexpanded, ShouldExpand,
6821 RetainExpansion, NumExpansions))
6823 if (!ShouldExpand) {
6824 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6827 TypeSourceInfo *TI =
6829 QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc());
6832 if (NotYetExpanded) {
6833 FullySubstituted =
false;
6834 QualType Out = getDerived().RebuildPackIndexingType(
6835 Pack, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),
6840 PackIndexingTypeLoc
Loc = TLB.push<PackIndexingTypeLoc>(Out);
6841 Loc.setEllipsisLoc(TL.getEllipsisLoc());
6844 SubtitutedTypes.push_back(Pack);
6847 for (
unsigned I = 0; I != *NumExpansions; ++I) {
6848 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
6849 QualType Out = getDerived().TransformType(
T);
6852 SubtitutedTypes.push_back(Out);
6853 FullySubstituted &= !Out->containsUnexpandedParameterPack();
6857 if (RetainExpansion) {
6858 FullySubstituted =
false;
6859 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6860 QualType Out = getDerived().TransformType(
T);
6863 SubtitutedTypes.push_back(Out);
6870 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6871 QualType
Result = getDerived().TransformType(TLB, TL.getPatternLoc());
6873 QualType Out = getDerived().RebuildPackIndexingType(
6874 Result, IndexExpr.get(), SourceLocation(), TL.getEllipsisLoc(),
6875 FullySubstituted, SubtitutedTypes);
6879 PackIndexingTypeLoc
Loc = TLB.push<PackIndexingTypeLoc>(Out);
6880 Loc.setEllipsisLoc(TL.getEllipsisLoc());
6884template<
typename Derived>
6885QualType TreeTransform<Derived>::TransformUnaryTransformType(
6886 TypeLocBuilder &TLB,
6887 UnaryTransformTypeLoc TL) {
6888 QualType
Result = TL.getType();
6889 if (
Result->isDependentType()) {
6890 const UnaryTransformType *
T = TL.getTypePtr();
6892 TypeSourceInfo *NewBaseTSI =
6893 getDerived().TransformType(TL.getUnderlyingTInfo());
6896 QualType NewBase = NewBaseTSI->getType();
6898 Result = getDerived().RebuildUnaryTransformType(NewBase,
6905 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(
Result);
6906 NewTL.setKWLoc(TL.getKWLoc());
6907 NewTL.setParensRange(TL.getParensRange());
6908 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
6912template<
typename Derived>
6913QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
6914 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
6915 const DeducedTemplateSpecializationType *
T = TL.getTypePtr();
6918 TemplateName TemplateName = getDerived().TransformTemplateName(
6919 SS,
T->getTemplateName(), TL.getTemplateNameLoc());
6920 if (TemplateName.isNull())
6923 QualType OldDeduced =
T->getDeducedType();
6924 QualType NewDeduced;
6925 if (!OldDeduced.isNull()) {
6926 NewDeduced = getDerived().TransformType(OldDeduced);
6927 if (NewDeduced.isNull())
6931 QualType
Result = getDerived().RebuildDeducedTemplateSpecializationType(
6932 TemplateName, NewDeduced);
6936 DeducedTemplateSpecializationTypeLoc NewTL =
6937 TLB.push<DeducedTemplateSpecializationTypeLoc>(
Result);
6938 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
6943template<
typename Derived>
6944QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
6946 const RecordType *
T = TL.getTypePtr();
6948 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6953 QualType
Result = TL.getType();
6954 if (getDerived().AlwaysRebuild() ||
6961 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(
Result);
6962 NewTL.setNameLoc(TL.getNameLoc());
6967template<
typename Derived>
6968QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
6970 const EnumType *
T = TL.getTypePtr();
6972 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(),
6977 QualType
Result = TL.getType();
6978 if (getDerived().AlwaysRebuild() ||
6979 Enum !=
T->getDecl()) {
6985 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(
Result);
6986 NewTL.setNameLoc(TL.getNameLoc());
6991template<
typename Derived>
6992QualType TreeTransform<Derived>::TransformInjectedClassNameType(
6993 TypeLocBuilder &TLB,
6994 InjectedClassNameTypeLoc TL) {
6995 Decl *
D = getDerived().TransformDecl(TL.getNameLoc(),
6996 TL.getTypePtr()->getDecl());
6997 if (!
D)
return QualType();
7000 TLB.pushTypeSpec(
T).setNameLoc(TL.getNameLoc());
7004template<
typename Derived>
7008 return getDerived().TransformTemplateTypeParmType(
7013template <
typename Derived>
7019template<
typename Derived>
7020QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
7021 TypeLocBuilder &TLB,
7022 SubstTemplateTypeParmTypeLoc TL) {
7023 const SubstTemplateTypeParmType *
T = TL.getTypePtr();
7026 getDerived().TransformDecl(TL.getNameLoc(),
T->getAssociatedDecl());
7031 TemporaryBase Rebase(*
this, TL.getNameLoc(), DeclarationName());
7032 QualType Replacement = getDerived().TransformType(
T->getReplacementType());
7033 if (Replacement.isNull())
7037 Replacement, NewReplaced,
T->getIndex(),
T->getPackIndex());
7040 SubstTemplateTypeParmTypeLoc NewTL
7041 = TLB.push<SubstTemplateTypeParmTypeLoc>(
Result);
7042 NewTL.setNameLoc(TL.getNameLoc());
7047template<
typename Derived>
7051 return getDerived().TransformSubstTemplateTypeParmPackType(
7055template <
typename Derived>
7061template<
typename Derived>
7071 = getDerived().TransformTemplateName(SS,
T->getTemplateName(),
7076 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
7079template<
typename Derived>
7087 if (getDerived().AlwaysRebuild() ||
7089 Result = getDerived().RebuildAtomicType(ValueType, TL.
getKWLoc());
7094 AtomicTypeLoc NewTL = TLB.
push<AtomicTypeLoc>(
Result);
7102template <
typename Derived>
7103QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
7105 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
7106 if (ValueType.isNull())
7109 QualType
Result = TL.getType();
7110 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
7111 const PipeType *PT =
Result->castAs<PipeType>();
7112 bool isReadPipe = PT->isReadOnly();
7113 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
7118 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(
Result);
7119 NewTL.setKWLoc(TL.getKWLoc());
7124template <
typename Derived>
7125QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
7127 const BitIntType *EIT = TL.getTypePtr();
7128 QualType
Result = TL.getType();
7130 if (getDerived().AlwaysRebuild()) {
7131 Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
7132 EIT->getNumBits(), TL.getNameLoc());
7137 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(
Result);
7138 NewTL.setNameLoc(TL.getNameLoc());
7142template <
typename Derived>
7143QualType TreeTransform<Derived>::TransformDependentBitIntType(
7144 TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
7145 const DependentBitIntType *EIT = TL.getTypePtr();
7149 ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
7152 if (BitsExpr.isInvalid())
7155 QualType
Result = TL.getType();
7157 if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
7158 Result = getDerived().RebuildDependentBitIntType(
7159 EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());
7165 if (isa<DependentBitIntType>(
Result)) {
7166 DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(
Result);
7167 NewTL.setNameLoc(TL.getNameLoc());
7169 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(
Result);
7170 NewTL.setNameLoc(TL.getNameLoc());
7180 template<
typename ArgLocContainer>
7182 ArgLocContainer *Container;
7207 : Container(&Container), Index(Index) { }
7221 return Container->getArgLoc(Index);
7225 return pointer(Container->getArgLoc(Index));
7230 return X.Container == Y.Container &&
X.Index == Y.Index;
7239template<
typename Derived>
7240QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
7242 const AutoType *
T = TL.getTypePtr();
7243 QualType OldDeduced =
T->getDeducedType();
7244 QualType NewDeduced;
7245 if (!OldDeduced.isNull()) {
7246 NewDeduced = getDerived().TransformType(OldDeduced);
7247 if (NewDeduced.isNull())
7251 ConceptDecl *NewCD =
nullptr;
7252 TemplateArgumentListInfo NewTemplateArgs;
7253 NestedNameSpecifierLoc NewNestedNameSpec;
7254 if (
T->isConstrained()) {
7255 assert(TL.getConceptReference());
7256 NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl(
7257 TL.getConceptNameLoc(),
T->getTypeConstraintConcept()));
7259 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7260 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7261 typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
7262 if (getDerived().TransformTemplateArguments(
7263 ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),
7267 if (TL.getNestedNameSpecifierLoc()) {
7269 = getDerived().TransformNestedNameSpecifierLoc(
7270 TL.getNestedNameSpecifierLoc());
7271 if (!NewNestedNameSpec)
7276 QualType
Result = TL.getType();
7277 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
7281 NewArgList.reserve(NewTemplateArgs.size());
7282 for (
const auto &ArgLoc : NewTemplateArgs.arguments())
7283 NewArgList.push_back(ArgLoc.getArgument());
7284 Result = getDerived().RebuildAutoType(NewDeduced,
T->getKeyword(), NewCD,
7290 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(
Result);
7291 NewTL.setNameLoc(TL.getNameLoc());
7292 NewTL.setRParenLoc(TL.getRParenLoc());
7293 NewTL.setConceptReference(
nullptr);
7295 if (
T->isConstrained()) {
7296 DeclarationNameInfo DNI = DeclarationNameInfo(
7297 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(),
7298 TL.getConceptNameLoc(),
7299 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());
7301 SemaRef.
Context, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI,
7302 TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(),
7304 NewTL.setConceptReference(CR);
7310template <
typename Derived>
7312 TypeLocBuilder &TLB,
7313 TemplateSpecializationTypeLoc TL,
7314 TemplateName Template) {
7315 TemplateArgumentListInfo NewTemplateArgs;
7316 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7317 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7318 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
7320 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7321 ArgIterator(TL, TL.getNumArgs()),
7328 getDerived().RebuildTemplateSpecializationType(Template,
7329 TL.getTemplateNameLoc(),
7337 if (isa<DependentTemplateSpecializationType>(
Result)) {
7338 DependentTemplateSpecializationTypeLoc NewTL
7339 = TLB.push<DependentTemplateSpecializationTypeLoc>(
Result);
7340 NewTL.setElaboratedKeywordLoc(SourceLocation());
7341 NewTL.setQualifierLoc(NestedNameSpecifierLoc());
7342 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
7343 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
7344 NewTL.setLAngleLoc(TL.getLAngleLoc());
7345 NewTL.setRAngleLoc(TL.getRAngleLoc());
7346 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
7347 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
7351 TemplateSpecializationTypeLoc NewTL
7352 = TLB.push<TemplateSpecializationTypeLoc>(
Result);
7353 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
7354 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
7355 NewTL.setLAngleLoc(TL.getLAngleLoc());
7356 NewTL.setRAngleLoc(TL.getRAngleLoc());
7357 for (
unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i)
7358 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo());
7364template <
typename Derived>
7375 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7383 QualType Result = getSema().Context.getDependentTemplateSpecializationType(
7385 DTN->getIdentifier(), NewTemplateArgs.
arguments());
7395 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
7401 = getDerived().RebuildTemplateSpecializationType(Template,
7413 for (
unsigned i = 0, e = NewTemplateArgs.
size(); i != e; ++i)
7420template<
typename Derived>
7435 QualType NamedT = getDerived().TransformType(TLB, TL.
getNamedTypeLoc());
7436 if (NamedT.isNull())
7445 if (
const TemplateSpecializationType *TST =
7446 NamedT->getAs<TemplateSpecializationType>()) {
7447 TemplateName Template = TST->getTemplateName();
7448 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>(
7449 Template.getAsTemplateDecl())) {
7451 diag::err_tag_reference_non_tag)
7453 << llvm::to_underlying(
7455 SemaRef.
Diag(TAT->getLocation(), diag::note_declared_at);
7461 if (getDerived().AlwaysRebuild() ||
7463 NamedT !=
T->getNamedType()) {
7466 QualifierLoc, NamedT);
7471 ElaboratedTypeLoc NewTL = TLB.
push<ElaboratedTypeLoc>(
Result);
7473 NewTL.setQualifierLoc(QualifierLoc);
7477template <
typename Derived>
7478QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB,
7479 AttributedTypeLoc TL) {
7481 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
7482 if (modifiedType.isNull())
7486 const Attr *oldAttr = TL.getAttr();
7487 const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) :
nullptr;
7488 if (oldAttr && !newAttr)
7491 QualType result = TL.getType();
7494 if (getDerived().AlwaysRebuild() ||
7495 modifiedType != oldType->getModifiedType()) {
7508 QualType equivalentType = modifiedType;
7509 if (TL.getModifiedLoc().getType() != TL.getEquivalentTypeLoc().getType()) {
7510 TypeLocBuilder AuxiliaryTLB;
7511 AuxiliaryTLB.reserve(TL.getFullDataSize());
7513 getDerived().TransformType(AuxiliaryTLB, TL.getEquivalentTypeLoc());
7514 if (equivalentType.isNull())
7520 if (
auto nullability = oldType->getImmediateNullability()) {
7521 if (!modifiedType->canHaveNullability()) {
7522 SemaRef.
Diag((TL.getAttr() ? TL.getAttr()->getLocation()
7523 : TL.getModifiedLoc().getBeginLoc()),
7524 diag::err_nullability_nonpointer)
7536 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
7537 newTL.setAttr(newAttr);
7541template <
typename Derived>
7542QualType TreeTransform<Derived>::TransformCountAttributedType(
7543 TypeLocBuilder &TLB, CountAttributedTypeLoc TL) {
7544 const CountAttributedType *OldTy = TL.
getTypePtr();
7545 QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());
7546 if (InnerTy.isNull())
7549 Expr *OldCount = TL.getCountExpr();
7550 Expr *NewCount =
nullptr;
7552 ExprResult CountResult = getDerived().TransformExpr(OldCount);
7553 if (CountResult.isInvalid())
7555 NewCount = CountResult.get();
7558 QualType
Result = TL.getType();
7559 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() ||
7560 OldCount != NewCount) {
7563 InnerTy, NewCount, OldTy->isCountInBytes(), OldTy->isOrNull());
7566 TLB.push<CountAttributedTypeLoc>(
Result);
7570template <
typename Derived>
7571QualType TreeTransform<Derived>::TransformBTFTagAttributedType(
7572 TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
7574 llvm_unreachable(
"Unexpected TreeTransform for BTFTagAttributedType");
7577template <
typename Derived>
7578QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType(
7579 TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) {
7581 const HLSLAttributedResourceType *oldType = TL.getTypePtr();
7583 QualType WrappedTy = getDerived().TransformType(TLB, TL.getWrappedLoc());
7584 if (WrappedTy.isNull())
7587 QualType ContainedTy = QualType();
7588 QualType OldContainedTy = oldType->getContainedType();
7589 if (!OldContainedTy.isNull()) {
7590 TypeSourceInfo *oldContainedTSI = TL.getContainedTypeSourceInfo();
7591 if (!oldContainedTSI)
7592 oldContainedTSI = getSema().getASTContext().getTrivialTypeSourceInfo(
7593 OldContainedTy, SourceLocation());
7594 TypeSourceInfo *ContainedTSI = getDerived().TransformType(oldContainedTSI);
7597 ContainedTy = ContainedTSI->getType();
7600 QualType
Result = TL.getType();
7601 if (getDerived().AlwaysRebuild() || WrappedTy != oldType->getWrappedType() ||
7602 ContainedTy != oldType->getContainedType()) {
7604 WrappedTy, ContainedTy, oldType->getAttrs());
7607 TLB.push<HLSLAttributedResourceTypeLoc>(
Result);
7611template<
typename Derived>
7613TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
7615 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7619 QualType
Result = TL.getType();
7620 if (getDerived().AlwaysRebuild() ||
7621 Inner != TL.getInnerLoc().getType()) {
7622 Result = getDerived().RebuildParenType(Inner);
7627 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(
Result);
7628 NewTL.setLParenLoc(TL.getLParenLoc());
7629 NewTL.setRParenLoc(TL.getRParenLoc());
7633template <
typename Derived>
7635TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
7636 MacroQualifiedTypeLoc TL) {
7637 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7641 QualType
Result = TL.getType();
7642 if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
7644 getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
7649 MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(
Result);
7650 NewTL.setExpansionLoc(TL.getExpansionLoc());
7654template<
typename Derived>
7655QualType TreeTransform<Derived>::TransformDependentNameType(
7656 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
7657 return TransformDependentNameType(TLB, TL,
false);
7660template<
typename Derived>
7661QualType TreeTransform<Derived>::TransformDependentNameType(
7662 TypeLocBuilder &TLB, DependentNameTypeLoc TL,
bool DeducedTSTContext) {
7663 const DependentNameType *
T = TL.getTypePtr();
7665 NestedNameSpecifierLoc QualifierLoc
7666 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
7671 = getDerived().RebuildDependentNameType(
T->getKeyword(),
7672 TL.getElaboratedKeywordLoc(),
7680 if (
const ElaboratedType* ElabT =
Result->getAs<ElaboratedType>()) {
7681 QualType NamedT = ElabT->getNamedType();
7682 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
7684 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(
Result);
7685 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7686 NewTL.setQualifierLoc(QualifierLoc);
7688 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(
Result);
7689 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7690 NewTL.setQualifierLoc(QualifierLoc);
7691 NewTL.setNameLoc(TL.getNameLoc());
7696template<
typename Derived>
7699 DependentTemplateSpecializationTypeLoc TL) {
7700 NestedNameSpecifierLoc QualifierLoc;
7701 if (TL.getQualifierLoc()) {
7703 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc());
7709 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
7712template<
typename Derived>
7725 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7730 QualType Result = getDerived().RebuildDependentTemplateSpecializationType(
7738 QualType NamedT = ElabT->getNamedType();
7747 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7754 }
else if (isa<DependentTemplateSpecializationType>(
Result)) {
7763 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7772 for (
unsigned I = 0,
E = NewTemplateArgs.
size(); I !=
E; ++I)
7778template<
typename Derived>
7787 if (getDerived().AlwaysRebuild() ||
7789 Result = getDerived().RebuildPackExpansionType(Pattern,
7797 PackExpansionTypeLoc NewT = TLB.
push<PackExpansionTypeLoc>(
Result);
7802template<
typename Derived>
7804TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
7805 ObjCInterfaceTypeLoc TL) {
7807 TLB.pushFullCopy(TL);
7808 return TL.getType();
7811template<
typename Derived>
7813TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
7814 ObjCTypeParamTypeLoc TL) {
7815 const ObjCTypeParamType *
T = TL.getTypePtr();
7816 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
7817 getDerived().TransformDecl(
T->getDecl()->getLocation(),
T->getDecl()));
7821 QualType
Result = TL.getType();
7822 if (getDerived().AlwaysRebuild() ||
7823 OTP !=
T->getDecl()) {
7824 Result = getDerived().RebuildObjCTypeParamType(
7825 OTP, TL.getProtocolLAngleLoc(),
7826 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7827 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
7832 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(
Result);
7833 if (TL.getNumProtocols()) {
7834 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
7835 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
7836 NewTL.setProtocolLoc(i, TL.getProtocolLoc(i));
7837 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
7842template<
typename Derived>
7844TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
7845 ObjCObjectTypeLoc TL) {
7847 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
7848 if (BaseType.isNull())
7851 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
7855 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
7856 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
7857 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
7858 QualType TypeArg = TypeArgInfo->getType();
7859 if (
auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
7863 const auto *PackExpansion = PackExpansionLoc.getType()
7864 ->castAs<PackExpansionType>();
7868 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
7872 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
7873 bool Expand =
false;
7874 bool RetainExpansion =
false;
7875 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
7876 if (getDerived().TryExpandParameterPacks(
7877 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
7878 Unexpanded, Expand, RetainExpansion, NumExpansions))
7885 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
7887 TypeLocBuilder TypeArgBuilder;
7888 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
7889 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
7891 if (NewPatternType.isNull())
7895 NewPatternType, NumExpansions);
7896 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
7897 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
7898 NewTypeArgInfos.push_back(
7899 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewExpansionType));
7905 for (
unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
7906 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
7908 TypeLocBuilder TypeArgBuilder;
7909 TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
7911 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
7913 if (NewTypeArg.isNull())
7916 NewTypeArgInfos.push_back(
7917 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewTypeArg));
7923 TypeLocBuilder TypeArgBuilder;
7924 TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
7925 QualType NewTypeArg =
7926 getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
7927 if (NewTypeArg.isNull())
7931 if (NewTypeArg == TypeArg) {
7932 NewTypeArgInfos.push_back(TypeArgInfo);
7936 NewTypeArgInfos.push_back(
7937 TypeArgBuilder.getTypeSourceInfo(SemaRef.
Context, NewTypeArg));
7941 QualType
Result = TL.getType();
7942 if (getDerived().AlwaysRebuild() || AnyChanged) {
7944 Result = getDerived().RebuildObjCObjectType(
7945 BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
7946 TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
7947 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7948 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
7954 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(
Result);
7955 NewT.setHasBaseTypeAsWritten(
true);
7956 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
7957 for (
unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
7958 NewT.setTypeArgTInfo(i, NewTypeArgInfos[i]);
7959 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
7960 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
7961 for (
unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
7962 NewT.setProtocolLoc(i, TL.getProtocolLoc(i));
7963 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
7967template<
typename Derived>
7969TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
7970 ObjCObjectPointerTypeLoc TL) {
7971 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
7972 if (PointeeType.isNull())
7975 QualType
Result = TL.getType();
7976 if (getDerived().AlwaysRebuild() ||
7977 PointeeType != TL.getPointeeLoc().getType()) {
7978 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
7984 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(
Result);
7985 NewT.setStarLoc(TL.getStarLoc());
7992template<
typename Derived>
7994TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
7998template<
typename Derived>
8001 return getDerived().TransformCompoundStmt(S,
false);
8004template<
typename Derived>
8010 if (S->hasStoredFPFeatures())
8011 getSema().resetFPOptions(
8012 S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts()));
8015 bool SubStmtInvalid =
false;
8016 bool SubStmtChanged =
false;
8018 for (
auto *B : S->body()) {
8020 B, IsStmtExpr && B ==
ExprResult ? SDK_StmtExprResult : SDK_Discarded);
8022 if (
Result.isInvalid()) {
8025 if (isa<DeclStmt>(B))
8029 SubStmtInvalid =
true;
8033 SubStmtChanged = SubStmtChanged ||
Result.get() != B;
8034 Statements.push_back(
Result.getAs<Stmt>());
8040 if (!getDerived().AlwaysRebuild() &&
8044 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
8050template<
typename Derived>
8052TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
8059 LHS = getDerived().TransformExpr(S->getLHS());
8061 if (LHS.isInvalid())
8065 RHS = getDerived().TransformExpr(S->getRHS());
8067 if (RHS.isInvalid())
8074 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
8076 S->getEllipsisLoc(),
8079 if (Case.isInvalid())
8084 getDerived().TransformStmt(S->getSubStmt());
8085 if (SubStmt.isInvalid())
8089 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
8092template <
typename Derived>
8093StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
8096 getDerived().TransformStmt(S->getSubStmt());
8097 if (SubStmt.isInvalid())
8101 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
8105template<
typename Derived>
8107TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
8108 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8109 if (SubStmt.isInvalid())
8112 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
8120 if (LD == S->getDecl())
8121 S->getDecl()->setStmt(
nullptr);
8124 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
8125 cast<LabelDecl>(LD), SourceLocation(),
8129template <
typename Derived>
8138 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
8139#include "clang/Basic/AttrList.inc"
8144template <
typename Derived>
8155 return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R));
8156#include "clang/Basic/AttrList.inc"
8158 return TransformAttr(R);
8161template <
typename Derived>
8164 StmtDiscardKind SDK) {
8165 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8169 bool AttrsChanged =
false;
8173 for (
const auto *I : S->getAttrs()) {
8175 getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.
get(), I);
8176 AttrsChanged |= (I != R);
8181 if (SubStmt.
get() == S->getSubStmt() && !AttrsChanged)
8189 return getDerived().RebuildAttributedStmt(S->
getAttrLoc(), Attrs,
8193template<
typename Derived>
8195TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
8198 if (
Init.isInvalid())
8201 Sema::ConditionResult Cond;
8202 if (!S->isConsteval()) {
8204 Cond = getDerived().TransformCondition(
8205 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
8208 if (Cond.isInvalid())
8213 std::optional<bool> ConstexprConditionValue;
8214 if (S->isConstexpr())
8215 ConstexprConditionValue = Cond.getKnownValue();
8219 if (!ConstexprConditionValue || *ConstexprConditionValue) {
8220 EnterExpressionEvaluationContext Ctx(
8223 S->isNonNegatedConsteval());
8225 Then = getDerived().TransformStmt(S->getThen());
8226 if (Then.isInvalid())
8232 Then =
new (getSema().Context)
8233 CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc());
8238 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
8239 EnterExpressionEvaluationContext Ctx(
8242 S->isNegatedConsteval());
8244 Else = getDerived().TransformStmt(S->getElse());
8245 if (Else.isInvalid())
8247 }
else if (S->getElse() && ConstexprConditionValue &&
8248 *ConstexprConditionValue) {
8252 Else =
new (getSema().Context)
8253 CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc());
8256 if (!getDerived().AlwaysRebuild() &&
8257 Init.get() == S->getInit() &&
8258 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8259 Then.get() == S->getThen() &&
8260 Else.get() == S->getElse())
8263 return getDerived().RebuildIfStmt(
8264 S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
8265 S->getRParenLoc(),
Init.get(), Then.get(), S->getElseLoc(), Else.get());
8268template<
typename Derived>
8270TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
8273 if (
Init.isInvalid())
8277 Sema::ConditionResult Cond = getDerived().TransformCondition(
8278 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
8280 if (Cond.isInvalid())
8285 getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
8286 Init.get(), Cond, S->getRParenLoc());
8291 StmtResult Body = getDerived().TransformStmt(S->getBody());
8292 if (Body.isInvalid())
8296 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(),
Switch.get(),
8300template<
typename Derived>
8302TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
8304 Sema::ConditionResult Cond = getDerived().TransformCondition(
8305 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
8307 if (Cond.isInvalid())
8312 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8316 StmtResult Body = getDerived().TransformStmt(S->getBody());
8317 if (Body.isInvalid())
8320 if (!getDerived().AlwaysRebuild() &&
8321 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8322 Body.get() == S->getBody())
8325 return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
8326 Cond, S->getRParenLoc(), Body.get());
8329template<
typename Derived>
8331TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
8334 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8338 StmtResult Body = getDerived().TransformStmt(S->getBody());
8339 if (Body.isInvalid())
8343 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8344 if (Cond.isInvalid())
8347 if (!getDerived().AlwaysRebuild() &&
8348 Cond.get() == S->getCond() &&
8349 Body.get() == S->getBody())
8352 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
8353 S->getWhileLoc(), Cond.get(),
8357template<
typename Derived>
8359TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
8360 if (getSema().getLangOpts().OpenMP)
8361 getSema().OpenMP().startOpenMPLoop();
8365 if (
Init.isInvalid())
8370 if (getSema().getLangOpts().OpenMP &&
Init.isUsable())
8371 getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(),
8375 Sema::ConditionResult Cond = getDerived().TransformCondition(
8376 S->getForLoc(), S->getConditionVariable(), S->getCond(),
8378 if (Cond.isInvalid())
8383 if (
Inc.isInvalid())
8386 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(
Inc.get()));
8387 if (S->getInc() && !FullInc.get())
8392 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
8394 S->getBeginLoc(), S->getInit(),
Init.get(), S->getCond(),
8395 Cond.get().second, S->getInc(),
Inc.get());
8398 StmtResult Body = getDerived().TransformStmt(S->getBody());
8399 if (Body.isInvalid())
8404 if (!getDerived().AlwaysRebuild() &&
8405 Init.get() == S->getInit() &&
8406 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8407 Inc.get() == S->getInc() &&
8408 Body.get() == S->getBody())
8411 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
8412 Init.get(), Cond, FullInc,
8413 S->getRParenLoc(), Body.get());
8416template<
typename Derived>
8418TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
8419 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
8425 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
8426 cast<LabelDecl>(LD));
8429template<
typename Derived>
8431TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
8437 if (!getDerived().AlwaysRebuild() &&
8438 Target.get() == S->getTarget())
8441 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
8445template<
typename Derived>
8447TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
8451template<
typename Derived>
8453TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
8457template<
typename Derived>
8459TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
8467 return getDerived().RebuildReturnStmt(S->getReturnLoc(),
Result.get());
8470template<
typename Derived>
8472TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
8473 bool DeclChanged =
false;
8475 LambdaScopeInfo *LSI = getSema().getCurLambda();
8476 for (
auto *
D : S->decls()) {
8481 if (Transformed !=
D)
8485 if (
auto *TD = dyn_cast<TypeDecl>(Transformed))
8486 LSI->ContainsUnexpandedParameterPack |=
8489 .getTypeDeclType(TD)
8491 ->containsUnexpandedParameterPack();
8493 if (
auto *VD = dyn_cast<VarDecl>(Transformed))
8494 LSI->ContainsUnexpandedParameterPack |=
8495 VD->getType()->containsUnexpandedParameterPack();
8498 Decls.push_back(Transformed);
8501 if (!getDerived().AlwaysRebuild() && !DeclChanged)
8504 return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
8507template<
typename Derived>
8509TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
8518 bool ExprsChanged =
false;
8521 for (
unsigned I = 0,
E = S->getNumOutputs(); I !=
E; ++I) {
8522 Names.push_back(S->getOutputIdentifier(I));
8525 Constraints.push_back(S->getOutputConstraintLiteral(I));
8528 Expr *OutputExpr = S->getOutputExpr(I);
8533 ExprsChanged |=
Result.get() != OutputExpr;
8535 Exprs.push_back(
Result.get());
8539 for (
unsigned I = 0,
E = S->getNumInputs(); I !=
E; ++I) {
8540 Names.push_back(S->getInputIdentifier(I));
8543 Constraints.push_back(S->getInputConstraintLiteral(I));
8546 Expr *InputExpr = S->getInputExpr(I);
8551 ExprsChanged |=
Result.get() != InputExpr;
8553 Exprs.push_back(
Result.get());
8557 for (
unsigned I = 0,
E = S->getNumLabels(); I !=
E; ++I) {
8558 Names.push_back(S->getLabelIdentifier(I));
8563 ExprsChanged |=
Result.get() != S->getLabelExpr(I);
8564 Exprs.push_back(
Result.get());
8566 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
8570 for (
unsigned I = 0,
E = S->getNumClobbers(); I !=
E; ++I)
8571 Clobbers.push_back(S->getClobberStringLiteral(I));
8574 AsmString = S->getAsmString();
8575 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
8576 S->isVolatile(), S->getNumOutputs(),
8577 S->getNumInputs(), Names.data(),
8578 Constraints, Exprs, AsmString.get(),
8579 Clobbers, S->getNumLabels(),
8583template<
typename Derived>
8585TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
8588 bool HadError =
false, HadChange =
false;
8592 TransformedExprs.reserve(SrcExprs.size());
8593 for (
unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
8595 if (!
Result.isUsable()) {
8598 HadChange |= (
Result.get() != SrcExprs[i]);
8599 TransformedExprs.push_back(
Result.get());
8604 if (!HadChange && !getDerived().AlwaysRebuild())
8607 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
8608 AsmToks, S->getAsmString(),
8609 S->getNumOutputs(), S->getNumInputs(),
8610 S->getAllConstraints(), S->getClobbers(),
8611 TransformedExprs, S->getEndLoc());
8615template<
typename Derived>
8617TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
8619 auto *FD = cast<FunctionDecl>(SemaRef.
CurContext);
8620 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
8621 ScopeInfo->NeedsCoroutineSuspends &&
8622 ScopeInfo->CoroutineSuspends.first ==
nullptr &&
8623 ScopeInfo->CoroutineSuspends.second ==
nullptr &&
8624 "expected clean scope info");
8628 ScopeInfo->setNeedsCoroutineSuspends(
false);
8641 getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
8642 ScopeInfo->CoroutinePromise = Promise;
8647 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
8648 if (InitSuspend.isInvalid())
8651 getDerived().TransformStmt(S->getFinalSuspendStmt());
8652 if (FinalSuspend.isInvalid() ||
8655 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
8656 assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));
8658 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
8659 if (BodyRes.isInvalid())
8662 CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
8663 if (Builder.isInvalid())
8666 Expr *ReturnObject = S->getReturnValueInit();
8667 assert(ReturnObject &&
"the return object is expected to be valid");
8668 ExprResult Res = getDerived().TransformInitializer(ReturnObject,
8670 if (Res.isInvalid())
8672 Builder.ReturnValue = Res.get();
8677 if (S->hasDependentPromiseType()) {
8680 if (!Promise->getType()->isDependentType()) {
8681 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
8682 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
8683 "these nodes should not have been built yet");
8684 if (!Builder.buildDependentStatements())
8688 if (
auto *OnFallthrough = S->getFallthroughHandler()) {
8689 StmtResult Res = getDerived().TransformStmt(OnFallthrough);
8690 if (Res.isInvalid())
8692 Builder.OnFallthrough = Res.get();
8695 if (
auto *OnException = S->getExceptionHandler()) {
8696 StmtResult Res = getDerived().TransformStmt(OnException);
8697 if (Res.isInvalid())
8699 Builder.OnException = Res.get();
8702 if (
auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
8703 StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
8704 if (Res.isInvalid())
8706 Builder.ReturnStmtOnAllocFailure = Res.get();
8710 assert(S->getAllocate() && S->getDeallocate() &&
8711 "allocation and deallocation calls must already be built");
8712 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
8713 if (AllocRes.isInvalid())
8715 Builder.Allocate = AllocRes.get();
8717 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
8718 if (DeallocRes.isInvalid())
8720 Builder.Deallocate = DeallocRes.get();
8722 if (
auto *ResultDecl = S->getResultDecl()) {
8723 StmtResult Res = getDerived().TransformStmt(ResultDecl);
8724 if (Res.isInvalid())
8726 Builder.ResultDecl = Res.get();
8729 if (
auto *ReturnStmt = S->getReturnStmt()) {
8730 StmtResult Res = getDerived().TransformStmt(ReturnStmt);
8731 if (Res.isInvalid())
8733 Builder.ReturnStmt = Res.get();
8737 return getDerived().RebuildCoroutineBodyStmt(Builder);
8740template<
typename Derived>
8742TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
8750 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(),
Result.get(),
8754template <
typename Derived>
8755ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *
E) {
8767 ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
8768 getSema().getCurScope(),
E->getKeywordLoc());
8772 return getDerived().RebuildCoawaitExpr(
8774 cast<UnresolvedLookupExpr>(Lookup.get()),
E->isImplicit());
8777template <
typename Derived>
8779TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *
E) {
8780 ExprResult OperandResult = getDerived().TransformInitializer(
E->getOperand(),
8782 if (OperandResult.isInvalid())
8785 ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
8786 E->getOperatorCoawaitLookup());
8788 if (LookupResult.isInvalid())
8793 return getDerived().RebuildDependentCoawaitExpr(
8794 E->getKeywordLoc(), OperandResult.get(),
8795 cast<UnresolvedLookupExpr>(LookupResult.get()));
8798template<
typename Derived>
8800TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *
E) {
8808 return getDerived().RebuildCoyieldExpr(
E->getKeywordLoc(),
Result.get());
8813template<
typename Derived>
8815TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
8817 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
8818 if (TryBody.isInvalid())
8822 bool AnyCatchChanged =
false;
8824 for (
unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
8825 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
8826 if (Catch.isInvalid())
8828 if (Catch.get() != S->getCatchStmt(I))
8829 AnyCatchChanged =
true;
8830 CatchStmts.push_back(Catch.get());
8835 if (S->getFinallyStmt()) {
8836 Finally = getDerived().TransformStmt(S->getFinallyStmt());
8837 if (Finally.isInvalid())
8842 if (!getDerived().AlwaysRebuild() &&
8843 TryBody.get() == S->getTryBody() &&
8845 Finally.get() == S->getFinallyStmt())
8849 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
8850 CatchStmts, Finally.get());
8853template<
typename Derived>
8855TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
8857 VarDecl *Var =
nullptr;
8858 if (VarDecl *FromVar = S->getCatchParamDecl()) {
8859 TypeSourceInfo *TSInfo =
nullptr;
8860 if (FromVar->getTypeSourceInfo()) {
8861 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
8868 T = TSInfo->getType();
8870 T = getDerived().TransformType(FromVar->getType());
8875 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo,
T);
8880 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
8881 if (Body.isInvalid())
8884 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
8889template<
typename Derived>
8891TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
8893 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
8894 if (Body.isInvalid())
8898 if (!getDerived().AlwaysRebuild() &&
8899 Body.get() == S->getFinallyBody())
8903 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
8907template<
typename Derived>
8909TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
8911 if (S->getThrowExpr()) {
8912 Operand = getDerived().TransformExpr(S->getThrowExpr());
8917 if (!getDerived().AlwaysRebuild() &&
8918 Operand.get() == S->getThrowExpr())
8921 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(),
Operand.get());
8924template<
typename Derived>
8926TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
8927 ObjCAtSynchronizedStmt *S) {
8933 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
8939 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
8940 if (Body.isInvalid())
8944 if (!getDerived().AlwaysRebuild() &&
8945 Object.get() == S->getSynchExpr() &&
8946 Body.get() == S->getSynchBody())
8950 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
8951 Object.get(), Body.get());
8954template<
typename Derived>
8956TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
8957 ObjCAutoreleasePoolStmt *S) {
8959 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
8960 if (Body.isInvalid())
8964 if (!getDerived().AlwaysRebuild() &&
8965 Body.get() == S->getSubStmt())
8969 return getDerived().RebuildObjCAutoreleasePoolStmt(
8970 S->getAtLoc(), Body.get());
8973template<
typename Derived>
8975TreeTransform<Derived>::TransformObjCForCollectionStmt(
8976 ObjCForCollectionStmt *S) {
8979 getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
8980 if (Element.isInvalid())
8984 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
8985 if (Collection.isInvalid())
8989 StmtResult Body = getDerived().TransformStmt(S->getBody());
8990 if (Body.isInvalid())
8994 if (!getDerived().AlwaysRebuild() &&
8995 Element.get() == S->getElement() &&
8996 Collection.get() == S->getCollection() &&
8997 Body.get() == S->getBody())
9001 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
9008template <
typename Derived>
9009StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
9011 VarDecl *Var =
nullptr;
9012 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
9014 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
9018 Var = getDerived().RebuildExceptionDecl(
9019 ExceptionDecl,
T, ExceptionDecl->getInnerLocStart(),
9020 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
9021 if (!Var || Var->isInvalidDecl())
9026 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
9027 if (Handler.isInvalid())
9030 if (!getDerived().AlwaysRebuild() && !Var &&
9031 Handler.get() == S->getHandlerBlock())
9034 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
9037template <
typename Derived>
9038StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
9040 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9041 if (TryBlock.isInvalid())
9045 bool HandlerChanged =
false;
9047 for (
unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
9048 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
9049 if (Handler.isInvalid())
9052 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
9053 Handlers.push_back(Handler.getAs<Stmt>());
9056 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9060 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
9064template<
typename Derived>
9066TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
9067 EnterExpressionEvaluationContext ForRangeInitContext(
9075 auto &LastRecord = getSema().currentEvaluationContext();
9076 LastRecord.InLifetimeExtendingContext =
true;
9077 LastRecord.RebuildDefaultArgOrDefaultInit =
true;
9080 S->getInit() ? getDerived().TransformStmt(S->getInit()) :
StmtResult();
9081 if (
Init.isInvalid())
9090 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty());
9091 auto ForRangeLifetimeExtendTemps =
9092 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps;
9097 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
9098 if (End.isInvalid())
9101 ExprResult Cond = getDerived().TransformExpr(S->getCond());
9102 if (Cond.isInvalid())
9106 if (Cond.isInvalid())
9112 if (
Inc.isInvalid())
9117 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
9118 if (LoopVar.isInvalid())
9122 if (getDerived().AlwaysRebuild() ||
9123 Init.get() != S->getInit() ||
9124 Range.get() != S->getRangeStmt() ||
9125 Begin.get() != S->getBeginStmt() ||
9126 End.get() != S->getEndStmt() ||
9127 Cond.get() != S->getCond() ||
9128 Inc.get() != S->getInc() ||
9129 LoopVar.get() != S->getLoopVarStmt()) {
9130 NewStmt = getDerived().RebuildCXXForRangeStmt(
9131 S->getForLoc(), S->getCoawaitLoc(),
Init.get(), S->getColonLoc(),
9133 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9134 if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
9137 cast<DeclStmt>(LoopVar.get())->getSingleDecl());
9144 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.
OpenACC()};
9147 StmtResult Body = getDerived().TransformStmt(S->getBody());
9148 if (Body.isInvalid())
9155 if (Body.get() != S->getBody() && NewStmt.get() == S) {
9156 NewStmt = getDerived().RebuildCXXForRangeStmt(
9157 S->getForLoc(), S->getCoawaitLoc(),
Init.get(), S->getColonLoc(),
9159 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9160 if (NewStmt.isInvalid())
9164 if (NewStmt.get() == S)
9167 return FinishCXXForRangeStmt(NewStmt.get(), Body.get());
9170template<
typename Derived>
9172TreeTransform<Derived>::TransformMSDependentExistsStmt(
9173 MSDependentExistsStmt *S) {
9175 NestedNameSpecifierLoc QualifierLoc;
9176 if (S->getQualifierLoc()) {
9178 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
9184 DeclarationNameInfo NameInfo = S->getNameInfo();
9185 if (NameInfo.getName()) {
9186 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9187 if (!NameInfo.getName())
9192 if (!getDerived().AlwaysRebuild() &&
9193 QualifierLoc == S->getQualifierLoc() &&
9194 NameInfo.getName() == S->getNameInfo().getName())
9199 SS.Adopt(QualifierLoc);
9201 switch (getSema().CheckMicrosoftIfExistsSymbol(
nullptr, SS, NameInfo)) {
9203 if (S->isIfExists())
9206 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9209 if (S->isIfNotExists())
9212 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9223 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
9224 if (SubStmt.isInvalid())
9232 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
9239template<
typename Derived>
9241TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *
E) {
9242 NestedNameSpecifierLoc QualifierLoc;
9243 if (
E->getQualifierLoc()) {
9245 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
9250 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
9251 getDerived().TransformDecl(
E->getMemberLoc(),
E->getPropertyDecl()));
9256 if (
Base.isInvalid())
9260 MSPropertyRefExpr(
Base.get(), PD,
E->isArrow(),
9262 QualifierLoc,
E->getMemberLoc());
9265template <
typename Derived>
9266ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
9267 MSPropertySubscriptExpr *
E) {
9268 auto BaseRes = getDerived().TransformExpr(
E->getBase());
9269 if (BaseRes.isInvalid())
9271 auto IdxRes = getDerived().TransformExpr(
E->getIdx());
9272 if (IdxRes.isInvalid())
9275 if (!getDerived().AlwaysRebuild() &&
9276 BaseRes.get() ==
E->getBase() &&
9277 IdxRes.get() ==
E->getIdx())
9280 return getDerived().RebuildArraySubscriptExpr(
9281 BaseRes.get(), SourceLocation(), IdxRes.get(),
E->getRBracketLoc());
9284template <
typename Derived>
9285StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
9286 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9287 if (TryBlock.isInvalid())
9290 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
9291 if (Handler.isInvalid())
9294 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9295 Handler.get() == S->getHandler())
9298 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
9299 TryBlock.get(), Handler.get());
9302template <
typename Derived>
9303StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
9305 if (
Block.isInvalid())
9308 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(),
Block.get());
9311template <
typename Derived>
9312StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
9313 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
9314 if (FilterExpr.isInvalid())
9318 if (
Block.isInvalid())
9321 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
9325template <
typename Derived>
9327 if (isa<SEHFinallyStmt>(Handler))
9328 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler));
9330 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler));
9333template<
typename Derived>
9343template <
typename Derived>
9345TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) {
9349 return getDerived().TransformStmt(L->getLoopStmt());
9352template <
typename Derived>
9359 TClauses.reserve(Clauses.size());
9363 getDerived().getSema().OpenMP().StartOpenMPClause((*I)->getClauseKind());
9364 OMPClause *Clause = getDerived().TransformOMPClause(*I);
9365 getDerived().getSema().OpenMP().EndOpenMPClause();
9367 TClauses.push_back(Clause);
9369 TClauses.push_back(
nullptr);
9373 if (
D->hasAssociatedStmt() &&
D->getAssociatedStmt()) {
9374 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
9375 D->getDirectiveKind(),
9381 if (
D->getDirectiveKind() == OMPD_atomic ||
9382 D->getDirectiveKind() == OMPD_critical ||
9383 D->getDirectiveKind() == OMPD_section ||
9384 D->getDirectiveKind() == OMPD_master)
9385 CS =
D->getAssociatedStmt();
9387 CS =
D->getRawStmt();
9388 Body = getDerived().TransformStmt(CS);
9390 getSema().getLangOpts().OpenMPIRBuilder)
9391 Body = getDerived().RebuildOMPCanonicalLoop(Body.
get());
9394 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
9399 if (TClauses.size() != Clauses.size()) {
9405 if (
D->getDirectiveKind() == OMPD_critical) {
9406 DirName = cast<OMPCriticalDirective>(
D)->getDirectiveName();
9407 DirName = getDerived().TransformDeclarationNameInfo(DirName);
9410 if (
D->getDirectiveKind() == OMPD_cancellation_point) {
9411 CancelRegion = cast<OMPCancellationPointDirective>(
D)->getCancelRegion();
9412 }
else if (
D->getDirectiveKind() == OMPD_cancel) {
9413 CancelRegion = cast<OMPCancelDirective>(
D)->getCancelRegion();
9416 return getDerived().RebuildOMPExecutableDirective(
9417 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
9426template <
typename Derived>
9433 TClauses.reserve(Clauses.size());
9436 getDerived().getSema().OpenMP().StartOpenMPClause(
C->getClauseKind());
9437 OMPClause *Clause = getDerived().TransformOMPClause(
C);
9438 getDerived().getSema().OpenMP().EndOpenMPClause();
9440 TClauses.push_back(Clause);
9442 TClauses.push_back(
nullptr);
9446 if (
D->hasAssociatedStmt() &&
D->getAssociatedStmt()) {
9447 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
9448 D->getDirectiveKind(),
9453 assert(
D->getDirectiveKind() == OMPD_assume &&
9454 "Unexpected informational directive");
9455 Stmt *CS =
D->getAssociatedStmt();
9456 Body = getDerived().TransformStmt(CS);
9459 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
9463 if (TClauses.size() != Clauses.size())
9468 return getDerived().RebuildOMPInformationalDirective(
9469 D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.
get(),
9473template <
typename Derived>
9478 << getOpenMPDirectiveName(
D->getDirectiveKind());
9482template <
typename Derived>
9484TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *
D) {
9485 DeclarationNameInfo DirName;
9486 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9488 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9489 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9493template <
typename Derived>
9495TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *
D) {
9496 DeclarationNameInfo DirName;
9497 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9499 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9500 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9504template <
typename Derived>
9506TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *
D) {
9507 DeclarationNameInfo DirName;
9508 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9510 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9511 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9515template <
typename Derived>
9517TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *
D) {
9518 DeclarationNameInfo DirName;
9519 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9521 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9522 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9526template <
typename Derived>
9528TreeTransform<Derived>::TransformOMPReverseDirective(OMPReverseDirective *
D) {
9529 DeclarationNameInfo DirName;
9530 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9532 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9533 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9537template <
typename Derived>
9538StmtResult TreeTransform<Derived>::TransformOMPInterchangeDirective(
9539 OMPInterchangeDirective *
D) {
9540 DeclarationNameInfo DirName;
9541 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9543 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9544 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9548template <
typename Derived>
9550TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *
D) {
9551 DeclarationNameInfo DirName;
9552 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9554 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9555 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9559template <
typename Derived>
9561TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *
D) {
9562 DeclarationNameInfo DirName;
9563 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9565 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9566 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9570template <
typename Derived>
9572TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *
D) {
9573 DeclarationNameInfo DirName;
9574 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9576 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9577 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9581template <
typename Derived>
9583TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *
D) {
9584 DeclarationNameInfo DirName;
9585 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9587 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9588 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9592template <
typename Derived>
9594TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *
D) {
9595 DeclarationNameInfo DirName;
9596 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9598 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9599 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9603template <
typename Derived>
9605TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *
D) {
9606 DeclarationNameInfo DirName;
9607 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9609 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9610 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9614template <
typename Derived>
9616TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *
D) {
9617 DeclarationNameInfo DirName;
9618 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9620 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9621 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9625template <
typename Derived>
9627TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *
D) {
9628 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9629 OMPD_critical,
D->getDirectiveName(),
nullptr,
D->
getBeginLoc());
9630 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9631 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9635template <
typename Derived>
9636StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
9637 OMPParallelForDirective *
D) {
9638 DeclarationNameInfo DirName;
9639 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9640 OMPD_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
9641 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9642 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9646template <
typename Derived>
9647StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
9648 OMPParallelForSimdDirective *
D) {
9649 DeclarationNameInfo DirName;
9650 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9651 OMPD_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
9652 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9653 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9657template <
typename Derived>
9658StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
9659 OMPParallelMasterDirective *
D) {
9660 DeclarationNameInfo DirName;
9661 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9662 OMPD_parallel_master, DirName,
nullptr,
D->
getBeginLoc());
9663 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9664 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9668template <
typename Derived>
9669StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective(
9670 OMPParallelMaskedDirective *
D) {
9671 DeclarationNameInfo DirName;
9672 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9673 OMPD_parallel_masked, DirName,
nullptr,
D->
getBeginLoc());
9674 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9675 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9679template <
typename Derived>
9680StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
9681 OMPParallelSectionsDirective *
D) {
9682 DeclarationNameInfo DirName;
9683 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9684 OMPD_parallel_sections, DirName,
nullptr,
D->
getBeginLoc());
9685 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9686 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9690template <
typename Derived>
9692TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *
D) {
9693 DeclarationNameInfo DirName;
9694 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9696 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9697 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9701template <
typename Derived>
9702StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
9703 OMPTaskyieldDirective *
D) {
9704 DeclarationNameInfo DirName;
9705 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9707 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9708 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9712template <
typename Derived>
9714TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *
D) {
9715 DeclarationNameInfo DirName;
9716 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9718 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9719 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9723template <
typename Derived>
9725TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *
D) {
9726 DeclarationNameInfo DirName;
9727 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9729 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9730 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9734template <
typename Derived>
9736TreeTransform<Derived>::TransformOMPAssumeDirective(OMPAssumeDirective *
D) {
9737 DeclarationNameInfo DirName;
9738 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9740 StmtResult Res = getDerived().TransformOMPInformationalDirective(
D);
9741 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9745template <
typename Derived>
9747TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *
D) {
9748 DeclarationNameInfo DirName;
9749 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9751 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9752 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9756template <
typename Derived>
9757StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
9758 OMPTaskgroupDirective *
D) {
9759 DeclarationNameInfo DirName;
9760 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9762 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9763 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9767template <
typename Derived>
9769TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *
D) {
9770 DeclarationNameInfo DirName;
9771 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9773 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9774 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9778template <
typename Derived>
9780TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *
D) {
9781 DeclarationNameInfo DirName;
9782 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9784 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9785 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9789template <
typename Derived>
9791TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *
D) {
9792 DeclarationNameInfo DirName;
9793 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9795 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9796 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9800template <
typename Derived>
9802TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *
D) {
9803 DeclarationNameInfo DirName;
9804 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9806 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9807 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9811template <
typename Derived>
9813TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *
D) {
9814 DeclarationNameInfo DirName;
9815 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9817 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9818 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9822template <
typename Derived>
9824TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *
D) {
9825 DeclarationNameInfo DirName;
9826 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9828 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9829 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9833template <
typename Derived>
9834StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
9835 OMPTargetDataDirective *
D) {
9836 DeclarationNameInfo DirName;
9837 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9839 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9840 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9844template <
typename Derived>
9845StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
9846 OMPTargetEnterDataDirective *
D) {
9847 DeclarationNameInfo DirName;
9848 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9849 OMPD_target_enter_data, DirName,
nullptr,
D->
getBeginLoc());
9850 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9851 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9855template <
typename Derived>
9856StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
9857 OMPTargetExitDataDirective *
D) {
9858 DeclarationNameInfo DirName;
9859 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9860 OMPD_target_exit_data, DirName,
nullptr,
D->
getBeginLoc());
9861 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9862 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9866template <
typename Derived>
9867StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
9868 OMPTargetParallelDirective *
D) {
9869 DeclarationNameInfo DirName;
9870 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9871 OMPD_target_parallel, DirName,
nullptr,
D->
getBeginLoc());
9872 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9873 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9877template <
typename Derived>
9878StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
9879 OMPTargetParallelForDirective *
D) {
9880 DeclarationNameInfo DirName;
9881 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9882 OMPD_target_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
9883 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9884 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9888template <
typename Derived>
9889StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
9890 OMPTargetUpdateDirective *
D) {
9891 DeclarationNameInfo DirName;
9892 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9893 OMPD_target_update, DirName,
nullptr,
D->
getBeginLoc());
9894 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9895 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9899template <
typename Derived>
9901TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *
D) {
9902 DeclarationNameInfo DirName;
9903 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9905 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9906 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9910template <
typename Derived>
9911StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
9912 OMPCancellationPointDirective *
D) {
9913 DeclarationNameInfo DirName;
9914 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9915 OMPD_cancellation_point, DirName,
nullptr,
D->
getBeginLoc());
9916 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9917 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9921template <
typename Derived>
9923TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *
D) {
9924 DeclarationNameInfo DirName;
9925 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9927 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9928 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9932template <
typename Derived>
9934TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *
D) {
9935 DeclarationNameInfo DirName;
9936 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9938 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9939 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9943template <
typename Derived>
9944StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
9945 OMPTaskLoopSimdDirective *
D) {
9946 DeclarationNameInfo DirName;
9947 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9948 OMPD_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
9949 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9950 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9954template <
typename Derived>
9955StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
9956 OMPMasterTaskLoopDirective *
D) {
9957 DeclarationNameInfo DirName;
9958 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9959 OMPD_master_taskloop, DirName,
nullptr,
D->
getBeginLoc());
9960 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9961 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9965template <
typename Derived>
9966StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective(
9967 OMPMaskedTaskLoopDirective *
D) {
9968 DeclarationNameInfo DirName;
9969 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9970 OMPD_masked_taskloop, DirName,
nullptr,
D->
getBeginLoc());
9971 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9972 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9976template <
typename Derived>
9977StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
9978 OMPMasterTaskLoopSimdDirective *
D) {
9979 DeclarationNameInfo DirName;
9980 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9981 OMPD_master_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
9982 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9983 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9987template <
typename Derived>
9988StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
9989 OMPMaskedTaskLoopSimdDirective *
D) {
9990 DeclarationNameInfo DirName;
9991 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
9992 OMPD_masked_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
9993 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
9994 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
9998template <
typename Derived>
9999StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
10000 OMPParallelMasterTaskLoopDirective *
D) {
10001 DeclarationNameInfo DirName;
10002 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10003 OMPD_parallel_master_taskloop, DirName,
nullptr,
D->
getBeginLoc());
10004 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10005 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10009template <
typename Derived>
10010StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective(
10011 OMPParallelMaskedTaskLoopDirective *
D) {
10012 DeclarationNameInfo DirName;
10013 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10014 OMPD_parallel_masked_taskloop, DirName,
nullptr,
D->
getBeginLoc());
10015 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10016 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10020template <
typename Derived>
10022TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
10023 OMPParallelMasterTaskLoopSimdDirective *
D) {
10024 DeclarationNameInfo DirName;
10025 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10026 OMPD_parallel_master_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
10027 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10028 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10032template <
typename Derived>
10034TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective(
10035 OMPParallelMaskedTaskLoopSimdDirective *
D) {
10036 DeclarationNameInfo DirName;
10037 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10038 OMPD_parallel_masked_taskloop_simd, DirName,
nullptr,
D->
getBeginLoc());
10039 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10040 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10044template <
typename Derived>
10045StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
10046 OMPDistributeDirective *
D) {
10047 DeclarationNameInfo DirName;
10048 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10050 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10051 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10055template <
typename Derived>
10056StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
10057 OMPDistributeParallelForDirective *
D) {
10058 DeclarationNameInfo DirName;
10059 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10060 OMPD_distribute_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
10061 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10062 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10066template <
typename Derived>
10068TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
10069 OMPDistributeParallelForSimdDirective *
D) {
10070 DeclarationNameInfo DirName;
10071 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10072 OMPD_distribute_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
10073 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10074 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10078template <
typename Derived>
10079StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
10080 OMPDistributeSimdDirective *
D) {
10081 DeclarationNameInfo DirName;
10082 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10083 OMPD_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10084 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10085 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10089template <
typename Derived>
10090StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
10091 OMPTargetParallelForSimdDirective *
D) {
10092 DeclarationNameInfo DirName;
10093 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10094 OMPD_target_parallel_for_simd, DirName,
nullptr,
D->
getBeginLoc());
10095 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10096 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10100template <
typename Derived>
10101StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
10102 OMPTargetSimdDirective *
D) {
10103 DeclarationNameInfo DirName;
10104 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10105 OMPD_target_simd, DirName,
nullptr,
D->
getBeginLoc());
10106 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10107 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10111template <
typename Derived>
10112StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
10113 OMPTeamsDistributeDirective *
D) {
10114 DeclarationNameInfo DirName;
10115 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10116 OMPD_teams_distribute, DirName,
nullptr,
D->
getBeginLoc());
10117 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10118 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10122template <
typename Derived>
10123StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
10124 OMPTeamsDistributeSimdDirective *
D) {
10125 DeclarationNameInfo DirName;
10126 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10127 OMPD_teams_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10128 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10129 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10133template <
typename Derived>
10134StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
10135 OMPTeamsDistributeParallelForSimdDirective *
D) {
10136 DeclarationNameInfo DirName;
10137 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10138 OMPD_teams_distribute_parallel_for_simd, DirName,
nullptr,
10140 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10141 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10145template <
typename Derived>
10146StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
10147 OMPTeamsDistributeParallelForDirective *
D) {
10148 DeclarationNameInfo DirName;
10149 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10150 OMPD_teams_distribute_parallel_for, DirName,
nullptr,
D->
getBeginLoc());
10151 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10152 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10156template <
typename Derived>
10157StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
10158 OMPTargetTeamsDirective *
D) {
10159 DeclarationNameInfo DirName;
10160 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10161 OMPD_target_teams, DirName,
nullptr,
D->
getBeginLoc());
10162 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10163 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10167template <
typename Derived>
10168StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
10169 OMPTargetTeamsDistributeDirective *
D) {
10170 DeclarationNameInfo DirName;
10171 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10172 OMPD_target_teams_distribute, DirName,
nullptr,
D->
getBeginLoc());
10173 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10174 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10178template <
typename Derived>
10180TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
10181 OMPTargetTeamsDistributeParallelForDirective *
D) {
10182 DeclarationNameInfo DirName;
10183 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10184 OMPD_target_teams_distribute_parallel_for, DirName,
nullptr,
10186 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10187 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10191template <
typename Derived>
10193 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
10194 OMPTargetTeamsDistributeParallelForSimdDirective *
D) {
10195 DeclarationNameInfo DirName;
10196 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10197 OMPD_target_teams_distribute_parallel_for_simd, DirName,
nullptr,
10199 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10200 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10204template <
typename Derived>
10206TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
10207 OMPTargetTeamsDistributeSimdDirective *
D) {
10208 DeclarationNameInfo DirName;
10209 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10210 OMPD_target_teams_distribute_simd, DirName,
nullptr,
D->
getBeginLoc());
10211 auto Res = getDerived().TransformOMPExecutableDirective(
D);
10212 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10216template <
typename Derived>
10218TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *
D) {
10219 DeclarationNameInfo DirName;
10220 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10222 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10223 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10227template <
typename Derived>
10229TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *
D) {
10230 DeclarationNameInfo DirName;
10231 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10233 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10234 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10238template <
typename Derived>
10240TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *
D) {
10241 DeclarationNameInfo DirName;
10242 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10244 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10245 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10249template <
typename Derived>
10250StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
10251 OMPGenericLoopDirective *
D) {
10252 DeclarationNameInfo DirName;
10253 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10255 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10256 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10260template <
typename Derived>
10261StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective(
10262 OMPTeamsGenericLoopDirective *
D) {
10263 DeclarationNameInfo DirName;
10264 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10266 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10267 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10271template <
typename Derived>
10272StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective(
10273 OMPTargetTeamsGenericLoopDirective *
D) {
10274 DeclarationNameInfo DirName;
10275 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10276 OMPD_target_teams_loop, DirName,
nullptr,
D->
getBeginLoc());
10277 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10278 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10282template <
typename Derived>
10283StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective(
10284 OMPParallelGenericLoopDirective *
D) {
10285 DeclarationNameInfo DirName;
10286 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10287 OMPD_parallel_loop, DirName,
nullptr,
D->
getBeginLoc());
10288 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10289 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10293template <
typename Derived>
10295TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
10296 OMPTargetParallelGenericLoopDirective *
D) {
10297 DeclarationNameInfo DirName;
10298 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10299 OMPD_target_parallel_loop, DirName,
nullptr,
D->
getBeginLoc());
10300 StmtResult Res = getDerived().TransformOMPExecutableDirective(
D);
10301 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10308template <
typename Derived>
10309OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *
C) {
10310 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10311 if (Cond.isInvalid())
10313 return getDerived().RebuildOMPIfClause(
10314 C->getNameModifier(), Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
10315 C->getNameModifierLoc(),
C->getColonLoc(),
C->getEndLoc());
10318template <
typename Derived>
10319OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *
C) {
10320 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10321 if (Cond.isInvalid())
10323 return getDerived().RebuildOMPFinalClause(Cond.get(),
C->getBeginLoc(),
10324 C->getLParenLoc(),
C->getEndLoc());
10327template <
typename Derived>
10329TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *
C) {
10330 ExprResult NumThreads = getDerived().TransformExpr(
C->getNumThreads());
10331 if (NumThreads.isInvalid())
10333 return getDerived().RebuildOMPNumThreadsClause(
10334 NumThreads.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10337template <
typename Derived>
10339TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *
C) {
10340 ExprResult E = getDerived().TransformExpr(
C->getSafelen());
10343 return getDerived().RebuildOMPSafelenClause(
10344 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10347template <
typename Derived>
10349TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *
C) {
10350 ExprResult E = getDerived().TransformExpr(
C->getAllocator());
10353 return getDerived().RebuildOMPAllocatorClause(
10354 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10357template <
typename Derived>
10359TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *
C) {
10360 ExprResult E = getDerived().TransformExpr(
C->getSimdlen());
10363 return getDerived().RebuildOMPSimdlenClause(
10364 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10367template <
typename Derived>
10368OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *
C) {
10370 TransformedSizes.reserve(
C->getNumSizes());
10372 for (Expr *
E :
C->getSizesRefs()) {
10374 TransformedSizes.push_back(
nullptr);
10383 TransformedSizes.push_back(
T.get());
10386 if (!Changed && !getDerived().AlwaysRebuild())
10388 return RebuildOMPSizesClause(TransformedSizes,
C->getBeginLoc(),
10389 C->getLParenLoc(),
C->getEndLoc());
10392template <
typename Derived>
10394TreeTransform<Derived>::TransformOMPPermutationClause(OMPPermutationClause *
C) {
10396 TransformedArgs.reserve(
C->getNumLoops());
10398 for (Expr *
E :
C->getArgsRefs()) {
10400 TransformedArgs.push_back(
nullptr);
10409 TransformedArgs.push_back(
T.get());
10412 if (!Changed && !getDerived().AlwaysRebuild())
10414 return RebuildOMPPermutationClause(TransformedArgs,
C->getBeginLoc(),
10415 C->getLParenLoc(),
C->getEndLoc());
10418template <
typename Derived>
10419OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *
C) {
10420 if (!getDerived().AlwaysRebuild())
10422 return RebuildOMPFullClause(
C->getBeginLoc(),
C->getEndLoc());
10425template <
typename Derived>
10427TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *
C) {
10428 ExprResult T = getDerived().TransformExpr(
C->getFactor());
10431 Expr *Factor =
T.get();
10432 bool Changed = Factor !=
C->getFactor();
10434 if (!Changed && !getDerived().AlwaysRebuild())
10436 return RebuildOMPPartialClause(Factor,
C->getBeginLoc(),
C->getLParenLoc(),
10440template <
typename Derived>
10442TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *
C) {
10443 ExprResult E = getDerived().TransformExpr(
C->getNumForLoops());
10446 return getDerived().RebuildOMPCollapseClause(
10447 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10450template <
typename Derived>
10452TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *
C) {
10453 return getDerived().RebuildOMPDefaultClause(
10454 C->getDefaultKind(),
C->getDefaultKindKwLoc(),
C->getBeginLoc(),
10455 C->getLParenLoc(),
C->getEndLoc());
10458template <
typename Derived>
10460TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *
C) {
10461 return getDerived().RebuildOMPProcBindClause(
10462 C->getProcBindKind(),
C->getProcBindKindKwLoc(),
C->getBeginLoc(),
10463 C->getLParenLoc(),
C->getEndLoc());
10466template <
typename Derived>
10468TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *
C) {
10469 ExprResult E = getDerived().TransformExpr(
C->getChunkSize());
10472 return getDerived().RebuildOMPScheduleClause(
10473 C->getFirstScheduleModifier(),
C->getSecondScheduleModifier(),
10474 C->getScheduleKind(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
10475 C->getFirstScheduleModifierLoc(),
C->getSecondScheduleModifierLoc(),
10476 C->getScheduleKindLoc(),
C->getCommaLoc(),
C->getEndLoc());
10479template <
typename Derived>
10481TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *
C) {
10483 if (
auto *
Num =
C->getNumForLoops()) {
10484 E = getDerived().TransformExpr(
Num);
10488 return getDerived().RebuildOMPOrderedClause(
C->getBeginLoc(),
C->getEndLoc(),
10489 C->getLParenLoc(),
E.get());
10492template <
typename Derived>
10494TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *
C) {
10496 if (Expr *Evt =
C->getEventHandler()) {
10497 E = getDerived().TransformExpr(Evt);
10501 return getDerived().RebuildOMPDetachClause(
E.get(),
C->getBeginLoc(),
10502 C->getLParenLoc(),
C->getEndLoc());
10505template <
typename Derived>
10507TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *
C) {
10512template <
typename Derived>
10514TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *
C) {
10519template <
typename Derived>
10521TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *
C) {
10526template <
typename Derived>
10527OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *
C) {
10532template <
typename Derived>
10533OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *
C) {
10538template <
typename Derived>
10540TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *
C) {
10545template <
typename Derived>
10547TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *
C) {
10552template <
typename Derived>
10554TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *
C) {
10559template <
typename Derived>
10560OMPClause *TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *
C) {
10565template <
typename Derived>
10567TreeTransform<Derived>::TransformOMPAbsentClause(OMPAbsentClause *
C) {
10571template <
typename Derived>
10572OMPClause *TreeTransform<Derived>::TransformOMPHoldsClause(OMPHoldsClause *
C) {
10573 ExprResult E = getDerived().TransformExpr(
C->getExpr());
10576 return getDerived().RebuildOMPHoldsClause(
E.get(),
C->getBeginLoc(),
10577 C->getLParenLoc(),
C->getEndLoc());
10580template <
typename Derived>
10582TreeTransform<Derived>::TransformOMPContainsClause(OMPContainsClause *
C) {
10586template <
typename Derived>
10588TreeTransform<Derived>::TransformOMPNoOpenMPClause(OMPNoOpenMPClause *
C) {
10591template <
typename Derived>
10592OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPRoutinesClause(
10593 OMPNoOpenMPRoutinesClause *
C) {
10596template <
typename Derived>
10597OMPClause *TreeTransform<Derived>::TransformOMPNoParallelismClause(
10598 OMPNoParallelismClause *
C) {
10602template <
typename Derived>
10604TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *
C) {
10609template <
typename Derived>
10611TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *
C) {
10616template <
typename Derived>
10618TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *
C) {
10623template <
typename Derived>
10625TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *
C) {
10630template <
typename Derived>
10632TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *
C) {
10637template <
typename Derived>
10638OMPClause *TreeTransform<Derived>::TransformOMPWeakClause(OMPWeakClause *
C) {
10643template <
typename Derived>
10645TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *
C) {
10650template <
typename Derived>
10651OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *
C) {
10656template <
typename Derived>
10658TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *
C) {
10663template <
typename Derived>
10664OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *
C) {
10665 ExprResult IVR = getDerived().TransformExpr(
C->getInteropVar());
10666 if (IVR.isInvalid())
10669 OMPInteropInfo InteropInfo(
C->getIsTarget(),
C->getIsTargetSync());
10670 InteropInfo.PreferTypes.reserve(
C->varlist_size() - 1);
10671 for (Expr *
E : llvm::drop_begin(
C->varlist())) {
10672 ExprResult ER = getDerived().TransformExpr(cast<Expr>(
E));
10673 if (ER.isInvalid())
10675 InteropInfo.PreferTypes.push_back(ER.get());
10677 return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo,
10678 C->getBeginLoc(),
C->getLParenLoc(),
10679 C->getVarLoc(),
C->getEndLoc());
10682template <
typename Derived>
10683OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *
C) {
10684 ExprResult ER = getDerived().TransformExpr(
C->getInteropVar());
10685 if (ER.isInvalid())
10687 return getDerived().RebuildOMPUseClause(ER.get(),
C->getBeginLoc(),
10688 C->getLParenLoc(),
C->getVarLoc(),
10692template <
typename Derived>
10694TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *
C) {
10696 if (Expr *IV =
C->getInteropVar()) {
10697 ER = getDerived().TransformExpr(IV);
10698 if (ER.isInvalid())
10701 return getDerived().RebuildOMPDestroyClause(ER.get(),
C->getBeginLoc(),
10702 C->getLParenLoc(),
C->getVarLoc(),
10706template <
typename Derived>
10708TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *
C) {
10709 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10710 if (Cond.isInvalid())
10712 return getDerived().RebuildOMPNovariantsClause(
10713 Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10716template <
typename Derived>
10718TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *
C) {
10719 ExprResult Cond = getDerived().TransformExpr(
C->getCondition());
10720 if (Cond.isInvalid())
10722 return getDerived().RebuildOMPNocontextClause(
10723 Cond.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10726template <
typename Derived>
10728TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *
C) {
10729 ExprResult ThreadID = getDerived().TransformExpr(
C->getThreadID());
10730 if (ThreadID.isInvalid())
10732 return getDerived().RebuildOMPFilterClause(ThreadID.get(),
C->getBeginLoc(),
10733 C->getLParenLoc(),
C->getEndLoc());
10736template <
typename Derived>
10737OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *
C) {
10738 ExprResult E = getDerived().TransformExpr(
C->getAlignment());
10741 return getDerived().RebuildOMPAlignClause(
E.get(),
C->getBeginLoc(),
10742 C->getLParenLoc(),
C->getEndLoc());
10745template <
typename Derived>
10746OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
10747 OMPUnifiedAddressClause *
C) {
10748 llvm_unreachable(
"unified_address clause cannot appear in dependent context");
10751template <
typename Derived>
10752OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
10753 OMPUnifiedSharedMemoryClause *
C) {
10755 "unified_shared_memory clause cannot appear in dependent context");
10758template <
typename Derived>
10759OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
10760 OMPReverseOffloadClause *
C) {
10761 llvm_unreachable(
"reverse_offload clause cannot appear in dependent context");
10764template <
typename Derived>
10765OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
10766 OMPDynamicAllocatorsClause *
C) {
10768 "dynamic_allocators clause cannot appear in dependent context");
10771template <
typename Derived>
10772OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
10773 OMPAtomicDefaultMemOrderClause *
C) {
10775 "atomic_default_mem_order clause cannot appear in dependent context");
10778template <
typename Derived>
10779OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *
C) {
10780 return getDerived().RebuildOMPAtClause(
C->getAtKind(),
C->getAtKindKwLoc(),
10781 C->getBeginLoc(),
C->getLParenLoc(),
10785template <
typename Derived>
10787TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *
C) {
10788 return getDerived().RebuildOMPSeverityClause(
10789 C->getSeverityKind(),
C->getSeverityKindKwLoc(),
C->getBeginLoc(),
10790 C->getLParenLoc(),
C->getEndLoc());
10793template <
typename Derived>
10795TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *
C) {
10796 ExprResult E = getDerived().TransformExpr(
C->getMessageString());
10799 return getDerived().RebuildOMPMessageClause(
10800 C->getMessageString(),
C->getBeginLoc(),
C->getLParenLoc(),
10804template <
typename Derived>
10806TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *
C) {
10808 Vars.reserve(
C->varlist_size());
10809 for (
auto *VE :
C->varlist()) {
10810 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10811 if (EVar.isInvalid())
10813 Vars.push_back(EVar.get());
10815 return getDerived().RebuildOMPPrivateClause(
10816 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10819template <
typename Derived>
10820OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
10821 OMPFirstprivateClause *
C) {
10823 Vars.reserve(
C->varlist_size());
10824 for (
auto *VE :
C->varlist()) {
10825 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10826 if (EVar.isInvalid())
10828 Vars.push_back(EVar.get());
10830 return getDerived().RebuildOMPFirstprivateClause(
10831 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
10834template <
typename Derived>
10836TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *
C) {
10838 Vars.reserve(
C->varlist_size());
10839 for (
auto *VE :
C->varlist()) {
10840 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10841 if (EVar.isInvalid())
10843 Vars.push_back(EVar.get());
10845 return getDerived().RebuildOMPLastprivateClause(
10846 Vars,
C->getKind(),
C->getKindLoc(),
C->getColonLoc(),
C->getBeginLoc(),
10847 C->getLParenLoc(),
C->getEndLoc());
10850template <
typename Derived>
10852TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *
C) {
10854 Vars.reserve(
C->varlist_size());
10855 for (
auto *VE :
C->varlist()) {
10856 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10857 if (EVar.isInvalid())
10859 Vars.push_back(EVar.get());
10861 return getDerived().RebuildOMPSharedClause(Vars,
C->getBeginLoc(),
10862 C->getLParenLoc(),
C->getEndLoc());
10865template <
typename Derived>
10867TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *
C) {
10869 Vars.reserve(
C->varlist_size());
10870 for (
auto *VE :
C->varlist()) {
10871 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10872 if (EVar.isInvalid())
10874 Vars.push_back(EVar.get());
10876 CXXScopeSpec ReductionIdScopeSpec;
10877 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10879 DeclarationNameInfo NameInfo =
C->getNameInfo();
10880 if (NameInfo.getName()) {
10881 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10882 if (!NameInfo.getName())
10888 for (
auto *
E :
C->reduction_ops()) {
10891 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10892 UnresolvedSet<8> Decls;
10893 for (
auto *
D : ULE->decls()) {
10895 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10896 Decls.addDecl(InstD, InstD->getAccess());
10900 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
10901 true, Decls.begin(), Decls.end(),
10904 UnresolvedReductions.push_back(
nullptr);
10906 return getDerived().RebuildOMPReductionClause(
10907 Vars,
C->getModifier(),
C->getBeginLoc(),
C->getLParenLoc(),
10908 C->getModifierLoc(),
C->getColonLoc(),
C->getEndLoc(),
10909 ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10912template <
typename Derived>
10913OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
10914 OMPTaskReductionClause *
C) {
10916 Vars.reserve(
C->varlist_size());
10917 for (
auto *VE :
C->varlist()) {
10918 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10919 if (EVar.isInvalid())
10921 Vars.push_back(EVar.get());
10923 CXXScopeSpec ReductionIdScopeSpec;
10924 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10926 DeclarationNameInfo NameInfo =
C->getNameInfo();
10927 if (NameInfo.getName()) {
10928 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10929 if (!NameInfo.getName())
10935 for (
auto *
E :
C->reduction_ops()) {
10938 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10939 UnresolvedSet<8> Decls;
10940 for (
auto *
D : ULE->decls()) {
10942 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10943 Decls.addDecl(InstD, InstD->getAccess());
10947 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
10948 true, Decls.begin(), Decls.end(),
10951 UnresolvedReductions.push_back(
nullptr);
10953 return getDerived().RebuildOMPTaskReductionClause(
10954 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
10955 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10958template <
typename Derived>
10960TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *
C) {
10962 Vars.reserve(
C->varlist_size());
10963 for (
auto *VE :
C->varlist()) {
10964 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
10965 if (EVar.isInvalid())
10967 Vars.push_back(EVar.get());
10969 CXXScopeSpec ReductionIdScopeSpec;
10970 ReductionIdScopeSpec.Adopt(
C->getQualifierLoc());
10972 DeclarationNameInfo NameInfo =
C->getNameInfo();
10973 if (NameInfo.getName()) {
10974 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
10975 if (!NameInfo.getName())
10981 for (
auto *
E :
C->reduction_ops()) {
10984 auto *ULE = cast<UnresolvedLookupExpr>(
E);
10985 UnresolvedSet<8> Decls;
10986 for (
auto *
D : ULE->decls()) {
10988 cast<NamedDecl>(getDerived().TransformDecl(
E->
getExprLoc(),
D));
10989 Decls.addDecl(InstD, InstD->getAccess());
10993 ReductionIdScopeSpec.getWithLocInContext(SemaRef.
Context), NameInfo,
10994 true, Decls.begin(), Decls.end(),
10997 UnresolvedReductions.push_back(
nullptr);
10999 return getDerived().RebuildOMPInReductionClause(
11000 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
11001 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
11004template <
typename Derived>
11006TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *
C) {
11008 Vars.reserve(
C->varlist_size());
11009 for (
auto *VE :
C->varlist()) {
11010 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11011 if (EVar.isInvalid())
11013 Vars.push_back(EVar.get());
11015 ExprResult Step = getDerived().TransformExpr(
C->getStep());
11016 if (Step.isInvalid())
11018 return getDerived().RebuildOMPLinearClause(
11019 Vars, Step.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getModifier(),
11020 C->getModifierLoc(),
C->getColonLoc(),
C->getStepModifierLoc(),
11024template <
typename Derived>
11026TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *
C) {
11028 Vars.reserve(
C->varlist_size());
11029 for (
auto *VE :
C->varlist()) {
11030 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11031 if (EVar.isInvalid())
11033 Vars.push_back(EVar.get());
11035 ExprResult Alignment = getDerived().TransformExpr(
C->getAlignment());
11036 if (Alignment.isInvalid())
11038 return getDerived().RebuildOMPAlignedClause(
11039 Vars, Alignment.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11040 C->getColonLoc(),
C->getEndLoc());
11043template <
typename Derived>
11045TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *
C) {
11047 Vars.reserve(
C->varlist_size());
11048 for (
auto *VE :
C->varlist()) {
11049 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11050 if (EVar.isInvalid())
11052 Vars.push_back(EVar.get());
11054 return getDerived().RebuildOMPCopyinClause(Vars,
C->getBeginLoc(),
11055 C->getLParenLoc(),
C->getEndLoc());
11058template <
typename Derived>
11060TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *
C) {
11062 Vars.reserve(
C->varlist_size());
11063 for (
auto *VE :
C->varlist()) {
11064 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11065 if (EVar.isInvalid())
11067 Vars.push_back(EVar.get());
11069 return getDerived().RebuildOMPCopyprivateClause(
11070 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11073template <
typename Derived>
11074OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *
C) {
11076 Vars.reserve(
C->varlist_size());
11077 for (
auto *VE :
C->varlist()) {
11078 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11079 if (EVar.isInvalid())
11081 Vars.push_back(EVar.get());
11083 return getDerived().RebuildOMPFlushClause(Vars,
C->getBeginLoc(),
11084 C->getLParenLoc(),
C->getEndLoc());
11087template <
typename Derived>
11089TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *
C) {
11090 ExprResult E = getDerived().TransformExpr(
C->getDepobj());
11093 return getDerived().RebuildOMPDepobjClause(
E.get(),
C->getBeginLoc(),
11094 C->getLParenLoc(),
C->getEndLoc());
11097template <
typename Derived>
11099TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *
C) {
11101 Expr *DepModifier =
C->getModifier();
11103 ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
11104 if (DepModRes.isInvalid())
11106 DepModifier = DepModRes.
get();
11108 Vars.reserve(
C->varlist_size());
11109 for (
auto *VE :
C->varlist()) {
11110 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11111 if (EVar.isInvalid())
11113 Vars.push_back(EVar.get());
11115 return getDerived().RebuildOMPDependClause(
11116 {
C->getDependencyKind(),
C->getDependencyLoc(),
C->getColonLoc(),
11117 C->getOmpAllMemoryLoc()},
11118 DepModifier, Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11121template <
typename Derived>
11123TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *
C) {
11124 ExprResult E = getDerived().TransformExpr(
C->getDevice());
11127 return getDerived().RebuildOMPDeviceClause(
11128 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11129 C->getModifierLoc(),
C->getEndLoc());
11132template <
typename Derived,
class T>
11139 Vars.reserve(
C->varlist_size());
11140 for (
auto *VE :
C->varlist()) {
11144 Vars.push_back(EVar.
get());
11148 if (
C->getMapperQualifierLoc()) {
11149 QualifierLoc = TT.
getDerived().TransformNestedNameSpecifierLoc(
11150 C->getMapperQualifierLoc());
11154 MapperIdScopeSpec.
Adopt(QualifierLoc);
11155 MapperIdInfo =
C->getMapperIdInfo();
11156 if (MapperIdInfo.
getName()) {
11157 MapperIdInfo = TT.
getDerived().TransformDeclarationNameInfo(MapperIdInfo);
11163 for (
auto *
E :
C->mapperlists()) {
11166 auto *ULE = cast<UnresolvedLookupExpr>(
E);
11168 for (
auto *
D : ULE->decls()) {
11176 MapperIdInfo,
true, Decls.
begin(), Decls.
end(),
11179 UnresolvedMappers.push_back(
nullptr);
11185template <
typename Derived>
11186OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *
C) {
11187 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11189 Expr *IteratorModifier =
C->getIteratorModifier();
11190 if (IteratorModifier) {
11191 ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
11192 if (MapModRes.isInvalid())
11194 IteratorModifier = MapModRes.
get();
11196 CXXScopeSpec MapperIdScopeSpec;
11197 DeclarationNameInfo MapperIdInfo;
11199 if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
11200 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11202 return getDerived().RebuildOMPMapClause(
11203 IteratorModifier,
C->getMapTypeModifiers(),
C->getMapTypeModifiersLoc(),
11204 MapperIdScopeSpec, MapperIdInfo,
C->getMapType(),
C->isImplicitMapType(),
11205 C->getMapLoc(),
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11208template <
typename Derived>
11210TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *
C) {
11211 Expr *Allocator =
C->getAllocator();
11213 ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
11214 if (AllocatorRes.isInvalid())
11216 Allocator = AllocatorRes.get();
11219 Vars.reserve(
C->varlist_size());
11220 for (
auto *VE :
C->varlist()) {
11221 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11222 if (EVar.isInvalid())
11224 Vars.push_back(EVar.get());
11226 return getDerived().RebuildOMPAllocateClause(
11227 Allocator,
C->getAllocatorModifier(), Vars,
C->getBeginLoc(),
11228 C->getLParenLoc(),
C->getColonLoc(),
C->getEndLoc());
11231template <
typename Derived>
11233TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *
C) {
11235 Vars.reserve(
C->varlist_size());
11236 for (
auto *VE :
C->varlist()) {
11237 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11238 if (EVar.isInvalid())
11240 Vars.push_back(EVar.get());
11242 return getDerived().RebuildOMPNumTeamsClause(
11243 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11246template <
typename Derived>
11248TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *
C) {
11250 Vars.reserve(
C->varlist_size());
11251 for (
auto *VE :
C->varlist()) {
11252 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11253 if (EVar.isInvalid())
11255 Vars.push_back(EVar.get());
11257 return getDerived().RebuildOMPThreadLimitClause(
11258 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11261template <
typename Derived>
11263TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *
C) {
11264 ExprResult E = getDerived().TransformExpr(
C->getPriority());
11267 return getDerived().RebuildOMPPriorityClause(
11268 E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11271template <
typename Derived>
11273TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *
C) {
11274 ExprResult E = getDerived().TransformExpr(
C->getGrainsize());
11277 return getDerived().RebuildOMPGrainsizeClause(
11278 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11279 C->getModifierLoc(),
C->getEndLoc());
11282template <
typename Derived>
11284TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *
C) {
11285 ExprResult E = getDerived().TransformExpr(
C->getNumTasks());
11288 return getDerived().RebuildOMPNumTasksClause(
11289 C->getModifier(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11290 C->getModifierLoc(),
C->getEndLoc());
11293template <
typename Derived>
11294OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *
C) {
11295 ExprResult E = getDerived().TransformExpr(
C->getHint());
11298 return getDerived().RebuildOMPHintClause(
E.get(),
C->getBeginLoc(),
11299 C->getLParenLoc(),
C->getEndLoc());
11302template <
typename Derived>
11303OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
11304 OMPDistScheduleClause *
C) {
11305 ExprResult E = getDerived().TransformExpr(
C->getChunkSize());
11308 return getDerived().RebuildOMPDistScheduleClause(
11309 C->getDistScheduleKind(),
E.get(),
C->getBeginLoc(),
C->getLParenLoc(),
11310 C->getDistScheduleKindLoc(),
C->getCommaLoc(),
C->getEndLoc());
11313template <
typename Derived>
11315TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *
C) {
11318 return getDerived().RebuildOMPDefaultmapClause(
C->getDefaultmapModifier(),
11319 C->getDefaultmapKind(),
11322 C->getDefaultmapModifierLoc(),
11323 C->getDefaultmapKindLoc(),
11327template <
typename Derived>
11328OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *
C) {
11329 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11331 CXXScopeSpec MapperIdScopeSpec;
11332 DeclarationNameInfo MapperIdInfo;
11334 if (transformOMPMappableExprListClause<Derived, OMPToClause>(
11335 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11337 return getDerived().RebuildOMPToClause(
11338 C->getMotionModifiers(),
C->getMotionModifiersLoc(), MapperIdScopeSpec,
11339 MapperIdInfo,
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11342template <
typename Derived>
11343OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *
C) {
11344 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11346 CXXScopeSpec MapperIdScopeSpec;
11347 DeclarationNameInfo MapperIdInfo;
11349 if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
11350 *
this,
C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
11352 return getDerived().RebuildOMPFromClause(
11353 C->getMotionModifiers(),
C->getMotionModifiersLoc(), MapperIdScopeSpec,
11354 MapperIdInfo,
C->getColonLoc(), Vars, Locs, UnresolvedMappers);
11357template <
typename Derived>
11358OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
11359 OMPUseDevicePtrClause *
C) {
11361 Vars.reserve(
C->varlist_size());
11362 for (
auto *VE :
C->varlist()) {
11363 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11364 if (EVar.isInvalid())
11366 Vars.push_back(EVar.get());
11368 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11369 return getDerived().RebuildOMPUseDevicePtrClause(Vars, Locs);
11372template <
typename Derived>
11373OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
11374 OMPUseDeviceAddrClause *
C) {
11376 Vars.reserve(
C->varlist_size());
11377 for (
auto *VE :
C->varlist()) {
11378 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11379 if (EVar.isInvalid())
11381 Vars.push_back(EVar.get());
11383 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11384 return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
11387template <
typename Derived>
11389TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *
C) {
11391 Vars.reserve(
C->varlist_size());
11392 for (
auto *VE :
C->varlist()) {
11393 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11394 if (EVar.isInvalid())
11396 Vars.push_back(EVar.get());
11398 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11399 return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
11402template <
typename Derived>
11403OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
11404 OMPHasDeviceAddrClause *
C) {
11406 Vars.reserve(
C->varlist_size());
11407 for (
auto *VE :
C->varlist()) {
11408 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11409 if (EVar.isInvalid())
11411 Vars.push_back(EVar.get());
11413 OMPVarListLocTy Locs(
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11414 return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
11417template <
typename Derived>
11419TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *
C) {
11421 Vars.reserve(
C->varlist_size());
11422 for (
auto *VE :
C->varlist()) {
11423 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11424 if (EVar.isInvalid())
11426 Vars.push_back(EVar.get());
11428 return getDerived().RebuildOMPNontemporalClause(
11429 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11432template <
typename Derived>
11434TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *
C) {
11436 Vars.reserve(
C->varlist_size());
11437 for (
auto *VE :
C->varlist()) {
11438 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11439 if (EVar.isInvalid())
11441 Vars.push_back(EVar.get());
11443 return getDerived().RebuildOMPInclusiveClause(
11444 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11447template <
typename Derived>
11449TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *
C) {
11451 Vars.reserve(
C->varlist_size());
11452 for (
auto *VE :
C->varlist()) {
11453 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11454 if (EVar.isInvalid())
11456 Vars.push_back(EVar.get());
11458 return getDerived().RebuildOMPExclusiveClause(
11459 Vars,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11462template <
typename Derived>
11463OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
11464 OMPUsesAllocatorsClause *
C) {
11466 Data.reserve(
C->getNumberOfAllocators());
11467 for (
unsigned I = 0,
E =
C->getNumberOfAllocators(); I <
E; ++I) {
11468 OMPUsesAllocatorsClause::Data
D =
C->getAllocatorData(I);
11469 ExprResult Allocator = getDerived().TransformExpr(
D.Allocator);
11470 if (Allocator.isInvalid())
11473 if (Expr *AT =
D.AllocatorTraits) {
11474 AllocatorTraits = getDerived().TransformExpr(AT);
11475 if (AllocatorTraits.isInvalid())
11478 SemaOpenMP::UsesAllocatorsData &NewD =
Data.emplace_back();
11479 NewD.Allocator = Allocator.get();
11480 NewD.AllocatorTraits = AllocatorTraits.get();
11481 NewD.LParenLoc =
D.LParenLoc;
11482 NewD.RParenLoc =
D.RParenLoc;
11484 return getDerived().RebuildOMPUsesAllocatorsClause(
11485 Data,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11488template <
typename Derived>
11490TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *
C) {
11492 Locators.reserve(
C->varlist_size());
11494 if (Expr *Modifier =
C->getModifier()) {
11495 ModifierRes = getDerived().TransformExpr(Modifier);
11496 if (ModifierRes.isInvalid())
11499 for (Expr *
E :
C->varlist()) {
11500 ExprResult Locator = getDerived().TransformExpr(
E);
11501 if (Locator.isInvalid())
11503 Locators.push_back(Locator.get());
11505 return getDerived().RebuildOMPAffinityClause(
11506 C->getBeginLoc(),
C->getLParenLoc(),
C->getColonLoc(),
C->getEndLoc(),
11507 ModifierRes.get(), Locators);
11510template <
typename Derived>
11511OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *
C) {
11512 return getDerived().RebuildOMPOrderClause(
11513 C->getKind(),
C->getKindKwLoc(),
C->getBeginLoc(),
C->getLParenLoc(),
11514 C->getEndLoc(),
C->getModifier(),
C->getModifierKwLoc());
11517template <
typename Derived>
11518OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *
C) {
11519 return getDerived().RebuildOMPBindClause(
11520 C->getBindKind(),
C->getBindKindLoc(),
C->getBeginLoc(),
11521 C->getLParenLoc(),
C->getEndLoc());
11524template <
typename Derived>
11525OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
11526 OMPXDynCGroupMemClause *
C) {
11528 if (
Size.isInvalid())
11530 return getDerived().RebuildOMPXDynCGroupMemClause(
11531 Size.get(),
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11534template <
typename Derived>
11536TreeTransform<Derived>::TransformOMPDoacrossClause(OMPDoacrossClause *
C) {
11538 Vars.reserve(
C->varlist_size());
11539 for (
auto *VE :
C->varlist()) {
11540 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE));
11541 if (EVar.isInvalid())
11543 Vars.push_back(EVar.get());
11545 return getDerived().RebuildOMPDoacrossClause(
11546 C->getDependenceType(),
C->getDependenceLoc(),
C->getColonLoc(), Vars,
11547 C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11550template <
typename Derived>
11552TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *
C) {
11554 for (
auto *A :
C->getAttrs())
11555 NewAttrs.push_back(getDerived().TransformAttr(A));
11556 return getDerived().RebuildOMPXAttributeClause(
11557 NewAttrs,
C->getBeginLoc(),
C->getLParenLoc(),
C->getEndLoc());
11560template <
typename Derived>
11561OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *
C) {
11562 return getDerived().RebuildOMPXBareClause(
C->getBeginLoc(),
C->getEndLoc());
11569template <
typename Derived>
11570class OpenACCClauseTransform final
11571 :
public OpenACCClauseVisitor<OpenACCClauseTransform<Derived>> {
11572 TreeTransform<Derived> &Self;
11574 SemaOpenACC::OpenACCParsedClause &ParsedClause;
11575 OpenACCClause *NewClause =
nullptr;
11579 for (Expr *CurVar : VarList) {
11580 ExprResult Res = Self.TransformExpr(CurVar);
11582 if (!Res.isUsable())
11585 Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getClauseKind(),
11588 if (Res.isUsable())
11589 InstantiatedVarList.push_back(Res.get());
11592 return InstantiatedVarList;
11596 OpenACCClauseTransform(TreeTransform<Derived> &Self,
11598 SemaOpenACC::OpenACCParsedClause &PC)
11599 : Self(Self), ExistingClauses(ExistingClauses), ParsedClause(PC) {}
11601 OpenACCClause *CreatedClause()
const {
return NewClause; }
11603#define VISIT_CLAUSE(CLAUSE_NAME) \
11604 void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);
11605#include "clang/Basic/OpenACCClauses.def"
11608template <
typename Derived>
11609void OpenACCClauseTransform<Derived>::VisitDefaultClause(
11610 const OpenACCDefaultClause &
C) {
11619template <
typename Derived>
11620void OpenACCClauseTransform<Derived>::VisitIfClause(
const OpenACCIfClause &
C) {
11621 Expr *Cond =
const_cast<Expr *
>(
C.getConditionExpr());
11622 assert(Cond &&
"If constructed with invalid Condition");
11623 Sema::ConditionResult Res =
Self.TransformCondition(
11626 if (Res.isInvalid() || !Res.get().second)
11637template <
typename Derived>
11638void OpenACCClauseTransform<Derived>::VisitSelfClause(
11639 const OpenACCSelfClause &
C) {
11641 if (
C.hasConditionExpr()) {
11642 Expr *Cond =
const_cast<Expr *
>(
C.getConditionExpr());
11643 Sema::ConditionResult Res =
11644 Self.TransformCondition(Cond->getExprLoc(),
nullptr, Cond,
11647 if (Res.isInvalid() || !Res.get().second)
11659template <
typename Derived>
11660void OpenACCClauseTransform<Derived>::VisitNumGangsClause(
11661 const OpenACCNumGangsClause &
C) {
11664 for (Expr *CurIntExpr :
C.getIntExprs()) {
11667 if (!Res.isUsable())
11672 C.getBeginLoc(), Res.get());
11673 if (!Res.isUsable())
11676 InstantiatedIntExprs.push_back(Res.get());
11686template <
typename Derived>
11687void OpenACCClauseTransform<Derived>::VisitPrivateClause(
11688 const OpenACCPrivateClause &
C) {
11698template <
typename Derived>
11699void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause(
11700 const OpenACCFirstPrivateClause &
C) {
11710template <
typename Derived>
11711void OpenACCClauseTransform<Derived>::VisitNoCreateClause(
11712 const OpenACCNoCreateClause &
C) {
11722template <
typename Derived>
11723void OpenACCClauseTransform<Derived>::VisitPresentClause(
11724 const OpenACCPresentClause &
C) {
11734template <
typename Derived>
11735void OpenACCClauseTransform<Derived>::VisitCopyClause(
11736 const OpenACCCopyClause &
C) {
11746template <
typename Derived>
11747void OpenACCClauseTransform<Derived>::VisitCopyInClause(
11748 const OpenACCCopyInClause &
C) {
11759template <
typename Derived>
11760void OpenACCClauseTransform<Derived>::VisitCopyOutClause(
11761 const OpenACCCopyOutClause &
C) {
11763 false,
C.isZero());
11772template <
typename Derived>
11773void OpenACCClauseTransform<Derived>::VisitCreateClause(
11774 const OpenACCCreateClause &
C) {
11776 false,
C.isZero());
11784template <
typename Derived>
11785void OpenACCClauseTransform<Derived>::VisitAttachClause(
11786 const OpenACCAttachClause &
C) {
11790 VarList.erase(std::remove_if(VarList.begin(), VarList.end(), [&](Expr *
E) {
11791 return Self.getSema().OpenACC().CheckVarIsPointerType(
11792 OpenACCClauseKind::Attach, E);
11793 }), VarList.end());
11803template <
typename Derived>
11804void OpenACCClauseTransform<Derived>::VisitDetachClause(
11805 const OpenACCDetachClause &
C) {
11810 std::remove_if(VarList.begin(), VarList.end(),
11812 return Self.getSema().OpenACC().CheckVarIsPointerType(
11813 OpenACCClauseKind::Detach, E);
11825template <
typename Derived>
11826void OpenACCClauseTransform<Derived>::VisitDeleteClause(
11827 const OpenACCDeleteClause &
C) {
11836template <
typename Derived>
11837void OpenACCClauseTransform<Derived>::VisitUseDeviceClause(
11838 const OpenACCUseDeviceClause &
C) {
11847template <
typename Derived>
11848void OpenACCClauseTransform<Derived>::VisitDevicePtrClause(
11849 const OpenACCDevicePtrClause &
C) {
11853 VarList.erase(std::remove_if(VarList.begin(), VarList.end(), [&](Expr *
E) {
11854 return Self.getSema().OpenACC().CheckVarIsPointerType(
11855 OpenACCClauseKind::DevicePtr, E);
11856 }), VarList.end());
11866template <
typename Derived>
11867void OpenACCClauseTransform<Derived>::VisitNumWorkersClause(
11868 const OpenACCNumWorkersClause &
C) {
11869 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11870 assert(IntExpr &&
"num_workers clause constructed with invalid int expr");
11873 if (!Res.isUsable())
11878 C.getBeginLoc(), Res.get());
11879 if (!Res.isUsable())
11889template <
typename Derived>
11890void OpenACCClauseTransform<Derived>::VisitDeviceNumClause (
11891 const OpenACCDeviceNumClause &
C) {
11892 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11893 assert(IntExpr &&
"device_num clause constructed with invalid int expr");
11896 if (!Res.isUsable())
11901 C.getBeginLoc(), Res.get());
11902 if (!Res.isUsable())
11912template <
typename Derived>
11913void OpenACCClauseTransform<Derived>::VisitDefaultAsyncClause(
11914 const OpenACCDefaultAsyncClause &
C) {
11915 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11916 assert(IntExpr &&
"default_async clause constructed with invalid int expr");
11919 if (!Res.isUsable())
11924 C.getBeginLoc(), Res.get());
11925 if (!Res.isUsable())
11935template <
typename Derived>
11936void OpenACCClauseTransform<Derived>::VisitVectorLengthClause(
11937 const OpenACCVectorLengthClause &
C) {
11938 Expr *IntExpr =
const_cast<Expr *
>(
C.getIntExpr());
11939 assert(IntExpr &&
"vector_length clause constructed with invalid int expr");
11942 if (!Res.isUsable())
11947 C.getBeginLoc(), Res.get());
11948 if (!Res.isUsable())
11958template <
typename Derived>
11959void OpenACCClauseTransform<Derived>::VisitAsyncClause(
11960 const OpenACCAsyncClause &
C) {
11961 if (
C.hasIntExpr()) {
11962 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
11963 if (!Res.isUsable())
11968 C.getBeginLoc(), Res.get());
11969 if (!Res.isUsable())
11982template <
typename Derived>
11983void OpenACCClauseTransform<Derived>::VisitWorkerClause(
11984 const OpenACCWorkerClause &
C) {
11985 if (
C.hasIntExpr()) {
11989 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
11990 if (!Res.isUsable())
11995 C.getBeginLoc(), Res.get());
11996 if (!Res.isUsable())
12009template <
typename Derived>
12010void OpenACCClauseTransform<Derived>::VisitVectorClause(
12011 const OpenACCVectorClause &
C) {
12012 if (
C.hasIntExpr()) {
12016 ExprResult Res =
Self.TransformExpr(
const_cast<Expr *
>(
C.getIntExpr()));
12017 if (!Res.isUsable())
12022 C.getBeginLoc(), Res.get());
12023 if (!Res.isUsable())
12036template <
typename Derived>
12037void OpenACCClauseTransform<Derived>::VisitWaitClause(
12038 const OpenACCWaitClause &
C) {
12039 if (!
C.getLParenLoc().isInvalid()) {
12040 Expr *DevNumExpr =
nullptr;
12044 if (
C.getDevNumExpr()) {
12046 if (!Res.isUsable())
12050 C.getBeginLoc(), Res.get());
12051 if (!Res.isUsable())
12054 DevNumExpr = Res.get();
12058 for (Expr *CurQueueIdExpr :
C.getQueueIdExprs()) {
12060 if (!Res.isUsable())
12064 C.getBeginLoc(), Res.get());
12065 if (!Res.isUsable())
12068 InstantiatedQueueIdExprs.push_back(Res.get());
12072 std::move(InstantiatedQueueIdExprs));
12082template <
typename Derived>
12083void OpenACCClauseTransform<Derived>::VisitDeviceTypeClause(
12084 const OpenACCDeviceTypeClause &
C) {
12087 Self.getSema().getASTContext(),
C.getClauseKind(),
12089 C.getArchitectures(), ParsedClause.
getEndLoc());
12092template <
typename Derived>
12093void OpenACCClauseTransform<Derived>::VisitAutoClause(
12094 const OpenACCAutoClause &
C) {
12101template <
typename Derived>
12102void OpenACCClauseTransform<Derived>::VisitIndependentClause(
12103 const OpenACCIndependentClause &
C) {
12109template <
typename Derived>
12110void OpenACCClauseTransform<Derived>::VisitSeqClause(
12111 const OpenACCSeqClause &
C) {
12116template <
typename Derived>
12117void OpenACCClauseTransform<Derived>::VisitFinalizeClause(
12118 const OpenACCFinalizeClause &
C) {
12124template <
typename Derived>
12125void OpenACCClauseTransform<Derived>::VisitIfPresentClause(
12126 const OpenACCIfPresentClause &
C) {
12132template <
typename Derived>
12133void OpenACCClauseTransform<Derived>::VisitReductionClause(
12134 const OpenACCReductionClause &
C) {
12138 for (Expr *Var : TransformedVars) {
12141 if (Res.isUsable())
12142 ValidVars.push_back(Res.get());
12145 NewClause =
Self.getSema().OpenACC().CheckReductionClause(
12148 C.getReductionOp(), ValidVars, ParsedClause.
getEndLoc());
12151template <
typename Derived>
12152void OpenACCClauseTransform<Derived>::VisitCollapseClause(
12153 const OpenACCCollapseClause &
C) {
12154 Expr *LoopCount =
const_cast<Expr *
>(
C.getLoopCount());
12155 assert(LoopCount &&
"collapse clause constructed with invalid loop count");
12159 NewLoopCount =
Self.getSema().OpenACC().ActOnIntExpr(
12161 NewLoopCount.get()->getBeginLoc(), NewLoopCount.get());
12164 Self.getSema().OpenACC().CheckCollapseLoopCount(NewLoopCount.get());
12166 if (!NewLoopCount.isUsable())
12176template <
typename Derived>
12177void OpenACCClauseTransform<Derived>::VisitTileClause(
12178 const OpenACCTileClause &
C) {
12182 for (Expr *
E :
C.getSizeExprs()) {
12185 if (!NewSizeExpr.isUsable())
12188 NewSizeExpr =
Self.getSema().OpenACC().ActOnIntExpr(
12190 NewSizeExpr.get()->getBeginLoc(), NewSizeExpr.get());
12192 NewSizeExpr =
Self.getSema().OpenACC().CheckTileSizeExpr(NewSizeExpr.get());
12194 if (!NewSizeExpr.isUsable())
12196 TransformedExprs.push_back(NewSizeExpr.get());
12205template <
typename Derived>
12206void OpenACCClauseTransform<Derived>::VisitGangClause(
12207 const OpenACCGangClause &
C) {
12211 for (
unsigned I = 0; I <
C.getNumExprs(); ++I) {
12212 ExprResult ER =
Self.TransformExpr(
const_cast<Expr *
>(
C.getExpr(I).second));
12213 if (!ER.isUsable())
12216 ER =
Self.getSema().OpenACC().CheckGangExpr(ExistingClauses,
12218 C.getExpr(I).first, ER.get());
12219 if (!ER.isUsable())
12221 TransformedGangKinds.push_back(
C.getExpr(I).first);
12222 TransformedIntExprs.push_back(ER.get());
12225 NewClause =
Self.getSema().OpenACC().CheckGangClause(
12228 TransformedGangKinds, TransformedIntExprs, ParsedClause.
getEndLoc());
12231template <
typename Derived>
12232OpenACCClause *TreeTransform<Derived>::TransformOpenACCClause(
12236 SemaOpenACC::OpenACCParsedClause ParsedClause(
12237 DirKind, OldClause->getClauseKind(), OldClause->getBeginLoc());
12238 ParsedClause.
setEndLoc(OldClause->getEndLoc());
12240 if (
const auto *WithParms = dyn_cast<OpenACCClauseWithParams>(OldClause))
12243 OpenACCClauseTransform<Derived> Transform{*
this, ExistingClauses,
12245 Transform.Visit(OldClause);
12247 return Transform.CreatedClause();
12250template <
typename Derived>
12252TreeTransform<Derived>::TransformOpenACCClauseList(
12255 for (
const auto *Clause : OldClauses) {
12256 if (OpenACCClause *TransformedClause = getDerived().TransformOpenACCClause(
12257 TransformedClauses, DirKind, Clause))
12258 TransformedClauses.push_back(TransformedClause);
12260 return TransformedClauses;
12263template <
typename Derived>
12264StmtResult TreeTransform<Derived>::TransformOpenACCComputeConstruct(
12265 OpenACCComputeConstruct *
C) {
12266 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12269 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12272 if (getSema().OpenACC().ActOnStartStmtDirective(
12273 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12277 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12278 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12279 C->clauses(), TransformedClauses);
12280 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12281 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12282 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12284 return getDerived().RebuildOpenACCComputeConstruct(
12285 C->getDirectiveKind(),
C->getBeginLoc(),
C->getDirectiveLoc(),
12286 C->getEndLoc(), TransformedClauses, StrBlock);
12289template <
typename Derived>
12291TreeTransform<Derived>::TransformOpenACCLoopConstruct(OpenACCLoopConstruct *
C) {
12293 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12296 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12299 if (getSema().OpenACC().ActOnStartStmtDirective(
12300 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12304 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12305 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12306 C->clauses(), TransformedClauses);
12308 Loop = getSema().OpenACC().ActOnAssociatedStmt(
12309 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses,
Loop);
12311 return getDerived().RebuildOpenACCLoopConstruct(
12312 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12313 TransformedClauses,
Loop);
12316template <
typename Derived>
12317StmtResult TreeTransform<Derived>::TransformOpenACCCombinedConstruct(
12318 OpenACCCombinedConstruct *
C) {
12319 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12322 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12325 if (getSema().OpenACC().ActOnStartStmtDirective(
12326 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12330 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12331 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12332 C->clauses(), TransformedClauses);
12334 Loop = getSema().OpenACC().ActOnAssociatedStmt(
12335 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses,
Loop);
12337 return getDerived().RebuildOpenACCCombinedConstruct(
12338 C->getDirectiveKind(),
C->getBeginLoc(),
C->getDirectiveLoc(),
12339 C->getEndLoc(), TransformedClauses,
Loop);
12342template <
typename Derived>
12344TreeTransform<Derived>::TransformOpenACCDataConstruct(OpenACCDataConstruct *
C) {
12345 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12348 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12350 if (getSema().OpenACC().ActOnStartStmtDirective(
12351 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12354 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12355 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12356 C->clauses(), TransformedClauses);
12357 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12358 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12359 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12361 return getDerived().RebuildOpenACCDataConstruct(
12362 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12363 TransformedClauses, StrBlock);
12366template <
typename Derived>
12367StmtResult TreeTransform<Derived>::TransformOpenACCEnterDataConstruct(
12368 OpenACCEnterDataConstruct *
C) {
12369 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12372 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12374 if (getSema().OpenACC().ActOnStartStmtDirective(
12375 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12378 return getDerived().RebuildOpenACCEnterDataConstruct(
12379 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12380 TransformedClauses);
12383template <
typename Derived>
12384StmtResult TreeTransform<Derived>::TransformOpenACCExitDataConstruct(
12385 OpenACCExitDataConstruct *
C) {
12386 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12389 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12391 if (getSema().OpenACC().ActOnStartStmtDirective(
12392 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12395 return getDerived().RebuildOpenACCExitDataConstruct(
12396 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12397 TransformedClauses);
12400template <
typename Derived>
12401StmtResult TreeTransform<Derived>::TransformOpenACCHostDataConstruct(
12402 OpenACCHostDataConstruct *
C) {
12403 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12406 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12408 if (getSema().OpenACC().ActOnStartStmtDirective(
12409 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12412 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
12413 getSema().OpenACC(),
C->getDirectiveKind(),
C->getDirectiveLoc(),
12414 C->clauses(), TransformedClauses);
12415 StmtResult StrBlock = getDerived().TransformStmt(
C->getStructuredBlock());
12416 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
12417 C->getBeginLoc(),
C->getDirectiveKind(), TransformedClauses, StrBlock);
12419 return getDerived().RebuildOpenACCHostDataConstruct(
12420 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12421 TransformedClauses, StrBlock);
12424template <
typename Derived>
12426TreeTransform<Derived>::TransformOpenACCInitConstruct(OpenACCInitConstruct *
C) {
12427 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12430 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12432 if (getSema().OpenACC().ActOnStartStmtDirective(
12433 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12436 return getDerived().RebuildOpenACCInitConstruct(
12437 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12438 TransformedClauses);
12441template <
typename Derived>
12442StmtResult TreeTransform<Derived>::TransformOpenACCShutdownConstruct(
12443 OpenACCShutdownConstruct *
C) {
12444 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12447 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12449 if (getSema().OpenACC().ActOnStartStmtDirective(
12450 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12453 return getDerived().RebuildOpenACCShutdownConstruct(
12454 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12455 TransformedClauses);
12457template <
typename Derived>
12459TreeTransform<Derived>::TransformOpenACCSetConstruct(OpenACCSetConstruct *
C) {
12460 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12463 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12465 if (getSema().OpenACC().ActOnStartStmtDirective(
12466 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12469 return getDerived().RebuildOpenACCSetConstruct(
12470 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getEndLoc(),
12471 TransformedClauses);
12474template <
typename Derived>
12476TreeTransform<Derived>::TransformOpenACCWaitConstruct(OpenACCWaitConstruct *
C) {
12477 getSema().OpenACC().ActOnConstruct(
C->getDirectiveKind(),
C->getBeginLoc());
12480 if (
C->hasDevNumExpr()) {
12481 DevNumExpr = getDerived().TransformExpr(
C->getDevNumExpr());
12483 if (DevNumExpr.isUsable())
12484 DevNumExpr = getSema().OpenACC().ActOnIntExpr(
12486 C->getBeginLoc(), DevNumExpr.get());
12491 for (Expr *QE :
C->getQueueIdExprs()) {
12492 assert(QE &&
"Null queue id expr?");
12493 ExprResult NewEQ = getDerived().TransformExpr(QE);
12495 if (!NewEQ.isUsable())
12499 C->getBeginLoc(), NewEQ.get());
12500 if (NewEQ.isUsable())
12501 QueueIdExprs.push_back(NewEQ.get());
12505 getDerived().TransformOpenACCClauseList(
C->getDirectiveKind(),
12508 if (getSema().OpenACC().ActOnStartStmtDirective(
12509 C->getDirectiveKind(),
C->getBeginLoc(), TransformedClauses))
12512 return getDerived().RebuildOpenACCWaitConstruct(
12513 C->getBeginLoc(),
C->getDirectiveLoc(),
C->getLParenLoc(),
12514 DevNumExpr.isUsable() ? DevNumExpr.get() :
nullptr,
C->getQueuesLoc(),
12515 QueueIdExprs,
C->getRParenLoc(),
C->getEndLoc(), TransformedClauses);
12518template <
typename Derived>
12519ExprResult TreeTransform<Derived>::TransformOpenACCAsteriskSizeExpr(
12520 OpenACCAsteriskSizeExpr *
E) {
12521 if (getDerived().AlwaysRebuild())
12522 return getDerived().RebuildOpenACCAsteriskSizeExpr(
E->getLocation());
12530template<
typename Derived>
12532TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *
E) {
12533 return TransformExpr(
E->getSubExpr());
12536template <
typename Derived>
12537ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr(
12538 SYCLUniqueStableNameExpr *
E) {
12542 TypeSourceInfo *NewT = getDerived().TransformType(
E->getTypeSourceInfo());
12547 if (!getDerived().AlwaysRebuild() &&
E->getTypeSourceInfo() == NewT)
12550 return getDerived().RebuildSYCLUniqueStableNameExpr(
12551 E->getLocation(),
E->getLParenLocation(),
E->getRParenLocation(), NewT);
12554template<
typename Derived>
12556TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *
E) {
12560 return getDerived().RebuildPredefinedExpr(
E->getLocation(),
12561 E->getIdentKind());
12564template<
typename Derived>
12566TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *
E) {
12567 NestedNameSpecifierLoc QualifierLoc;
12568 if (
E->getQualifierLoc()) {
12570 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
12576 = cast_or_null<ValueDecl>(getDerived().TransformDecl(
E->getLocation(),
12581 NamedDecl *
Found = ND;
12582 if (
E->getFoundDecl() !=
E->getDecl()) {
12583 Found = cast_or_null<NamedDecl>(
12584 getDerived().TransformDecl(
E->getLocation(),
E->getFoundDecl()));
12589 DeclarationNameInfo NameInfo =
E->getNameInfo();
12590 if (NameInfo.getName()) {
12591 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
12592 if (!NameInfo.getName())
12596 if (!getDerived().AlwaysRebuild() &&
12597 !
E->isCapturedByCopyInLambdaWithExplicitObjectParameter() &&
12598 QualifierLoc ==
E->getQualifierLoc() && ND ==
E->getDecl() &&
12599 Found ==
E->getFoundDecl() &&
12600 NameInfo.getName() ==
E->getDecl()->getDeclName() &&
12601 !
E->hasExplicitTemplateArgs()) {
12610 TemplateArgumentListInfo TransArgs, *TemplateArgs =
nullptr;
12611 if (
E->hasExplicitTemplateArgs()) {
12612 TemplateArgs = &TransArgs;
12613 TransArgs.setLAngleLoc(
E->getLAngleLoc());
12614 TransArgs.setRAngleLoc(
E->getRAngleLoc());
12615 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
12616 E->getNumTemplateArgs(),
12621 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
12622 Found, TemplateArgs);
12625template<
typename Derived>
12627TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *
E) {
12631template <
typename Derived>
12632ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
12633 FixedPointLiteral *
E) {
12637template<
typename Derived>
12639TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *
E) {
12643template<
typename Derived>
12645TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *
E) {
12649template<
typename Derived>
12651TreeTransform<Derived>::TransformStringLiteral(StringLiteral *
E) {
12655template<
typename Derived>
12657TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *
E) {
12661template<
typename Derived>
12663TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *
E) {
12664 return getDerived().TransformCallExpr(
E);
12667template<
typename Derived>
12669TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *
E) {
12671 TypeSourceInfo *ControllingType =
nullptr;
12672 if (
E->isExprPredicate())
12673 ControllingExpr = getDerived().TransformExpr(
E->getControllingExpr());
12675 ControllingType = getDerived().TransformType(
E->getControllingType());
12677 if (ControllingExpr.isInvalid() && !ControllingType)
12683 TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
12685 TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
12688 AssocTypes.push_back(AssocType);
12690 AssocTypes.push_back(
nullptr);
12694 getDerived().TransformExpr(Assoc.getAssociationExpr());
12695 if (AssocExpr.isInvalid())
12697 AssocExprs.push_back(AssocExpr.get());
12700 if (!ControllingType)
12701 return getDerived().RebuildGenericSelectionExpr(
E->getGenericLoc(),
12702 E->getDefaultLoc(),
12704 ControllingExpr.get(),
12707 return getDerived().RebuildGenericSelectionExpr(
12708 E->getGenericLoc(),
E->getDefaultLoc(),
E->getRParenLoc(),
12709 ControllingType, AssocTypes, AssocExprs);
12712template<
typename Derived>
12714TreeTransform<Derived>::TransformParenExpr(ParenExpr *
E) {
12715 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
12716 if (SubExpr.isInvalid())
12719 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getSubExpr())
12722 return getDerived().RebuildParenExpr(SubExpr.get(),
E->getLParen(),
12729template<
typename Derived>
12733 return getDerived().TransformDependentScopeDeclRefExpr(
12734 DRE,
true,
nullptr);
12736 return getDerived().TransformUnresolvedLookupExpr(
12739 return getDerived().TransformExpr(
E);
12742template<
typename Derived>
12746 if (
E->getOpcode() == UO_AddrOf)
12747 SubExpr = TransformAddressOfOperand(
E->getSubExpr());
12749 SubExpr = TransformExpr(
E->getSubExpr());
12753 if (!getDerived().AlwaysRebuild() && SubExpr.
get() ==
E->getSubExpr())
12756 return getDerived().RebuildUnaryOperator(
E->getOperatorLoc(),
12761template<
typename Derived>
12763TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *
E) {
12765 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeSourceInfo());
12775 bool ExprChanged =
false;
12776 typedef Sema::OffsetOfComponent Component;
12778 for (
unsigned I = 0, N =
E->getNumComponents(); I != N; ++I) {
12779 const OffsetOfNode &ON =
E->getComponent(I);
12781 Comp.isBrackets =
true;
12782 Comp.LocStart = ON.getSourceRange().getBegin();
12783 Comp.LocEnd = ON.getSourceRange().getEnd();
12784 switch (ON.getKind()) {
12786 Expr *FromIndex =
E->getIndexExpr(ON.getArrayExprIndex());
12787 ExprResult Index = getDerived().TransformExpr(FromIndex);
12788 if (Index.isInvalid())
12791 ExprChanged = ExprChanged || Index.get() != FromIndex;
12792 Comp.isBrackets =
true;
12793 Comp.U.E = Index.get();
12799 Comp.isBrackets =
false;
12800 Comp.U.IdentInfo = ON.getFieldName();
12801 if (!
Comp.U.IdentInfo)
12811 Components.push_back(Comp);
12815 if (!getDerived().AlwaysRebuild() &&
12816 Type ==
E->getTypeSourceInfo() &&
12821 return getDerived().RebuildOffsetOfExpr(
E->getOperatorLoc(), Type,
12822 Components,
E->getRParenLoc());
12825template<
typename Derived>
12827TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *
E) {
12828 assert((!
E->getSourceExpr() || getDerived().AlreadyTransformed(
E->
getType())) &&
12829 "opaque value expression requires transformation");
12833template<
typename Derived>
12835TreeTransform<Derived>::TransformTypoExpr(TypoExpr *
E) {
12839template <
typename Derived>
12840ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *
E) {
12843 for (Expr *
C :
E->subExpressions()) {
12845 if (NewC.isInvalid())
12847 Children.push_back(NewC.get());
12851 if (!getDerived().AlwaysRebuild() && !Changed)
12857template<
typename Derived>
12859TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *
E) {
12867 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
12868 if (result.isInvalid())
return ExprError();
12873 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
12879template<
typename Derived>
12881TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
12882 UnaryExprOrTypeTraitExpr *
E) {
12883 if (
E->isArgumentType()) {
12884 TypeSourceInfo *OldT =
E->getArgumentTypeInfo();
12886 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
12890 if (!getDerived().AlwaysRebuild() && OldT == NewT)
12893 return getDerived().RebuildUnaryExprOrTypeTrait(NewT,
E->getOperatorLoc(),
12907 TypeSourceInfo *RecoveryTSI =
nullptr;
12909 auto *PE = dyn_cast<ParenExpr>(
E->getArgumentExpr());
12911 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) :
nullptr)
12912 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
12913 PE, DRE,
false, &RecoveryTSI);
12915 SubExpr = getDerived().TransformExpr(
E->getArgumentExpr());
12918 return getDerived().RebuildUnaryExprOrTypeTrait(
12920 }
else if (SubExpr.isInvalid())
12923 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getArgumentExpr())
12926 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
12927 E->getOperatorLoc(),
12932template<
typename Derived>
12934TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *
E) {
12935 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
12936 if (LHS.isInvalid())
12939 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
12940 if (RHS.isInvalid())
12944 if (!getDerived().AlwaysRebuild() &&
12945 LHS.get() ==
E->getLHS() &&
12946 RHS.get() ==
E->getRHS())
12949 return getDerived().RebuildArraySubscriptExpr(
12951 E->getLHS()->
getBeginLoc(), RHS.get(),
E->getRBracketLoc());
12954template <
typename Derived>
12956TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *
E) {
12958 if (
Base.isInvalid())
12961 ExprResult RowIdx = getDerived().TransformExpr(
E->getRowIdx());
12962 if (RowIdx.isInvalid())
12965 ExprResult ColumnIdx = getDerived().TransformExpr(
E->getColumnIdx());
12966 if (ColumnIdx.isInvalid())
12969 if (!getDerived().AlwaysRebuild() &&
Base.get() ==
E->getBase() &&
12970 RowIdx.get() ==
E->getRowIdx() && ColumnIdx.get() ==
E->getColumnIdx())
12973 return getDerived().RebuildMatrixSubscriptExpr(
12974 Base.get(), RowIdx.get(), ColumnIdx.get(),
E->getRBracketLoc());
12977template <
typename Derived>
12979TreeTransform<Derived>::TransformArraySectionExpr(ArraySectionExpr *
E) {
12981 if (
Base.isInvalid())
12985 if (
E->getLowerBound()) {
12986 LowerBound = getDerived().TransformExpr(
E->getLowerBound());
12987 if (LowerBound.isInvalid())
12992 if (
E->getLength()) {
12993 Length = getDerived().TransformExpr(
E->getLength());
12994 if (Length.isInvalid())
12999 if (
E->isOMPArraySection()) {
13000 if (Expr *Str =
E->getStride()) {
13001 Stride = getDerived().TransformExpr(Str);
13002 if (Stride.isInvalid())
13007 if (!getDerived().AlwaysRebuild() &&
Base.get() ==
E->getBase() &&
13008 LowerBound.get() ==
E->getLowerBound() &&
13009 Length.get() ==
E->getLength() &&
13010 (
E->isOpenACCArraySection() || Stride.get() ==
E->getStride()))
13013 return getDerived().RebuildArraySectionExpr(
13015 LowerBound.get(),
E->getColonLocFirst(),
13016 E->isOMPArraySection() ?
E->getColonLocSecond() : SourceLocation{},
13017 Length.get(), Stride.get(),
E->getRBracketLoc());
13020template <
typename Derived>
13022TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *
E) {
13024 if (
Base.isInvalid())
13028 bool ErrorFound =
false;
13029 for (Expr *
Dim :
E->getDimensions()) {
13031 if (DimRes.isInvalid()) {
13035 Dims.push_back(DimRes.get());
13040 return getDerived().RebuildOMPArrayShapingExpr(
Base.get(),
E->getLParenLoc(),
13041 E->getRParenLoc(), Dims,
13042 E->getBracketsRanges());
13045template <
typename Derived>
13047TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *
E) {
13048 unsigned NumIterators =
E->numOfIterators();
13051 bool ErrorFound =
false;
13052 bool NeedToRebuild = getDerived().AlwaysRebuild();
13053 for (
unsigned I = 0; I < NumIterators; ++I) {
13054 auto *
D = cast<VarDecl>(
E->getIteratorDecl(I));
13055 Data[I].DeclIdent =
D->getIdentifier();
13059 "Implicit type must be int.");
13061 TypeSourceInfo *TSI = getDerived().TransformType(
D->getTypeSourceInfo());
13062 QualType
DeclTy = getDerived().TransformType(
D->getType());
13065 OMPIteratorExpr::IteratorRange
Range =
E->getIteratorRange(I);
13069 ErrorFound = ErrorFound ||
13070 !(!
D->getTypeSourceInfo() || (
Data[I].Type.getAsOpaquePtr() &&
13071 !
Data[I].Type.get().isNull())) ||
13076 Data[I].Range.End = End.get();
13077 Data[I].Range.Step = Step.get();
13078 Data[I].AssignLoc =
E->getAssignLoc(I);
13079 Data[I].ColonLoc =
E->getColonLoc(I);
13080 Data[I].SecColonLoc =
E->getSecondColonLoc(I);
13083 (
D->getTypeSourceInfo() &&
Data[I].Type.get().getTypePtrOrNull() !=
13084 D->getType().getTypePtrOrNull()) ||
13090 if (!NeedToRebuild)
13093 ExprResult Res = getDerived().RebuildOMPIteratorExpr(
13094 E->getIteratorKwLoc(),
E->getLParenLoc(),
E->getRParenLoc(),
Data);
13095 if (!Res.isUsable())
13097 auto *IE = cast<OMPIteratorExpr>(Res.get());
13098 for (
unsigned I = 0; I < NumIterators; ++I)
13099 getDerived().transformedLocalDecl(
E->getIteratorDecl(I),
13100 IE->getIteratorDecl(I));
13104template<
typename Derived>
13106TreeTransform<Derived>::TransformCallExpr(CallExpr *
E) {
13113 bool ArgChanged =
false;
13115 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
13119 if (!getDerived().AlwaysRebuild() &&
13120 Callee.get() ==
E->getCallee() &&
13125 SourceLocation FakeLParenLoc
13128 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13129 if (
E->hasStoredFPFeatures()) {
13130 FPOptionsOverride NewOverrides =
E->getFPFeatures();
13131 getSema().CurFPFeatures =
13132 NewOverrides.applyOverrides(getSema().getLangOpts());
13133 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13136 return getDerived().RebuildCallExpr(
Callee.get(), FakeLParenLoc,
13138 E->getRParenLoc());
13141template<
typename Derived>
13143TreeTransform<Derived>::TransformMemberExpr(MemberExpr *
E) {
13145 if (
Base.isInvalid())
13148 NestedNameSpecifierLoc QualifierLoc;
13149 if (
E->hasQualifier()) {
13151 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
13156 SourceLocation TemplateKWLoc =
E->getTemplateKeywordLoc();
13159 = cast_or_null<ValueDecl>(getDerived().TransformDecl(
E->getMemberLoc(),
13160 E->getMemberDecl()));
13164 NamedDecl *FoundDecl =
E->getFoundDecl();
13165 if (FoundDecl ==
E->getMemberDecl()) {
13168 FoundDecl = cast_or_null<NamedDecl>(
13169 getDerived().TransformDecl(
E->getMemberLoc(), FoundDecl));
13174 if (!getDerived().AlwaysRebuild() &&
13175 Base.get() ==
E->getBase() &&
13176 QualifierLoc ==
E->getQualifierLoc() &&
13177 Member ==
E->getMemberDecl() &&
13178 FoundDecl ==
E->getFoundDecl() &&
13179 !
E->hasExplicitTemplateArgs()) {
13183 if (!(isa<CXXThisExpr>(
E->getBase()) &&
13184 getSema().OpenMP().isOpenMPRebuildMemberExpr(
13185 cast<ValueDecl>(
Member)))) {
13193 TemplateArgumentListInfo TransArgs;
13194 if (
E->hasExplicitTemplateArgs()) {
13195 TransArgs.setLAngleLoc(
E->getLAngleLoc());
13196 TransArgs.setRAngleLoc(
E->getRAngleLoc());
13197 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
13198 E->getNumTemplateArgs(),
13204 SourceLocation FakeOperatorLoc =
13211 NamedDecl *FirstQualifierInScope =
nullptr;
13212 DeclarationNameInfo MemberNameInfo =
E->getMemberNameInfo();
13213 if (MemberNameInfo.getName()) {
13214 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
13215 if (!MemberNameInfo.getName())
13219 return getDerived().RebuildMemberExpr(
Base.get(), FakeOperatorLoc,
13226 (
E->hasExplicitTemplateArgs()
13227 ? &TransArgs :
nullptr),
13228 FirstQualifierInScope);
13231template<
typename Derived>
13233TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *
E) {
13234 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13235 if (LHS.isInvalid())
13239 getDerived().TransformInitializer(
E->getRHS(),
false);
13240 if (RHS.isInvalid())
13243 if (!getDerived().AlwaysRebuild() &&
13244 LHS.get() ==
E->getLHS() &&
13245 RHS.get() ==
E->getRHS())
13248 if (
E->isCompoundAssignmentOp())
13250 return getDerived().RebuildBinaryOperator(
13251 E->getOperatorLoc(),
E->getOpcode(), LHS.get(), RHS.get());
13252 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13253 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13254 getSema().CurFPFeatures =
13255 NewOverrides.applyOverrides(getSema().getLangOpts());
13256 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13257 return getDerived().RebuildBinaryOperator(
E->getOperatorLoc(),
E->getOpcode(),
13258 LHS.get(), RHS.get());
13261template <
typename Derived>
13262ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
13263 CXXRewrittenBinaryOperator *
E) {
13264 CXXRewrittenBinaryOperator::DecomposedForm Decomp =
E->getDecomposedForm();
13266 ExprResult LHS = getDerived().TransformExpr(
const_cast<Expr*
>(Decomp.LHS));
13267 if (LHS.isInvalid())
13270 ExprResult RHS = getDerived().TransformExpr(
const_cast<Expr*
>(Decomp.RHS));
13271 if (RHS.isInvalid())
13276 UnresolvedSet<2> UnqualLookups;
13277 bool ChangedAnyLookups =
false;
13278 Expr *PossibleBinOps[] = {
E->getSemanticForm(),
13279 const_cast<Expr *
>(Decomp.InnerBinOp)};
13280 for (Expr *PossibleBinOp : PossibleBinOps) {
13281 auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
13284 auto *
Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
13285 if (!Callee || isa<CXXMethodDecl>(
Callee->getDecl()))
13290 NamedDecl *
Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
13291 E->getOperatorLoc(),
Callee->getFoundDecl()));
13295 ChangedAnyLookups =
true;
13296 UnqualLookups.addDecl(
Found);
13299 if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups &&
13300 LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) {
13306 const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS};
13311 return getDerived().RebuildCXXRewrittenBinaryOperator(
13312 E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
13315template<
typename Derived>
13317TreeTransform<Derived>::TransformCompoundAssignOperator(
13318 CompoundAssignOperator *
E) {
13319 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13320 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13321 getSema().CurFPFeatures =
13322 NewOverrides.applyOverrides(getSema().getLangOpts());
13323 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13324 return getDerived().TransformBinaryOperator(
E);
13327template<
typename Derived>
13329TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
13333 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
13334 if (commonExpr.isInvalid())
13337 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
13338 if (rhs.isInvalid())
13341 if (!getDerived().AlwaysRebuild() &&
13342 commonExpr.get() == e->getCommon() &&
13343 rhs.get() == e->getFalseExpr())
13346 return getDerived().RebuildConditionalOperator(commonExpr.get(),
13347 e->getQuestionLoc(),
13353template<
typename Derived>
13355TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *
E) {
13356 ExprResult Cond = getDerived().TransformExpr(
E->getCond());
13357 if (Cond.isInvalid())
13360 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13361 if (LHS.isInvalid())
13364 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
13365 if (RHS.isInvalid())
13368 if (!getDerived().AlwaysRebuild() &&
13369 Cond.get() ==
E->getCond() &&
13370 LHS.get() ==
E->getLHS() &&
13371 RHS.get() ==
E->getRHS())
13374 return getDerived().RebuildConditionalOperator(Cond.get(),
13375 E->getQuestionLoc(),
13381template<
typename Derived>
13383TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *
E) {
13386 return getDerived().TransformExpr(
E->getSubExprAsWritten());
13389template<
typename Derived>
13391TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *
E) {
13392 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeInfoAsWritten());
13397 = getDerived().TransformExpr(
E->getSubExprAsWritten());
13398 if (SubExpr.isInvalid())
13401 if (!getDerived().AlwaysRebuild() &&
13402 Type ==
E->getTypeInfoAsWritten() &&
13403 SubExpr.get() ==
E->getSubExpr())
13406 return getDerived().RebuildCStyleCastExpr(
E->getLParenLoc(),
13412template<
typename Derived>
13414TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *
E) {
13415 TypeSourceInfo *OldT =
E->getTypeSourceInfo();
13416 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
13421 if (
Init.isInvalid())
13424 if (!getDerived().AlwaysRebuild() &&
13426 Init.get() ==
E->getInitializer())
13433 return getDerived().RebuildCompoundLiteralExpr(
13434 E->getLParenLoc(), NewT,
13438template<
typename Derived>
13440TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *
E) {
13442 if (
Base.isInvalid())
13445 if (!getDerived().AlwaysRebuild() &&
13446 Base.get() ==
E->getBase())
13450 SourceLocation FakeOperatorLoc =
13452 return getDerived().RebuildExtVectorElementExpr(
13453 Base.get(), FakeOperatorLoc,
E->isArrow(),
E->getAccessorLoc(),
13457template<
typename Derived>
13459TreeTransform<Derived>::TransformInitListExpr(InitListExpr *
E) {
13460 if (InitListExpr *Syntactic =
E->getSyntacticForm())
13463 bool InitChanged =
false;
13465 EnterExpressionEvaluationContext Context(
13469 if (getDerived().TransformExprs(
E->getInits(),
E->getNumInits(),
false,
13470 Inits, &InitChanged))
13473 if (!getDerived().AlwaysRebuild() && !InitChanged) {
13480 return getDerived().RebuildInitList(
E->getLBraceLoc(), Inits,
13481 E->getRBraceLoc());
13484template<
typename Derived>
13486TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *
E) {
13491 if (
Init.isInvalid())
13496 bool ExprChanged =
false;
13497 for (
const DesignatedInitExpr::Designator &
D :
E->designators()) {
13498 if (
D.isFieldDesignator()) {
13499 if (
D.getFieldDecl()) {
13500 FieldDecl *
Field = cast_or_null<FieldDecl>(
13501 getDerived().TransformDecl(
D.getFieldLoc(),
D.getFieldDecl()));
13502 if (Field !=
D.getFieldDecl())
13505 ExprChanged =
true;
13506 if (
Field->isAnonymousStructOrUnion())
13512 ExprChanged =
true;
13515 D.getFieldName(),
D.getDotLoc(),
D.getFieldLoc()));
13519 if (
D.isArrayDesignator()) {
13520 ExprResult Index = getDerived().TransformExpr(
E->getArrayIndex(
D));
13521 if (Index.isInvalid())
13524 Desig.AddDesignator(
13527 ExprChanged = ExprChanged ||
Init.get() !=
E->getArrayIndex(
D);
13528 ArrayExprs.push_back(Index.get());
13532 assert(
D.isArrayRangeDesignator() &&
"New kind of designator?");
13534 = getDerived().TransformExpr(
E->getArrayRangeStart(
D));
13535 if (Start.isInvalid())
13538 ExprResult End = getDerived().TransformExpr(
E->getArrayRangeEnd(
D));
13539 if (End.isInvalid())
13543 Start.get(), End.get(),
D.getLBracketLoc(),
D.getEllipsisLoc()));
13545 ExprChanged = ExprChanged || Start.get() !=
E->getArrayRangeStart(
D) ||
13546 End.get() !=
E->getArrayRangeEnd(
D);
13548 ArrayExprs.push_back(Start.get());
13549 ArrayExprs.push_back(End.get());
13552 if (!getDerived().AlwaysRebuild() &&
13553 Init.get() ==
E->getInit() &&
13557 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
13558 E->getEqualOrColonLoc(),
13559 E->usesGNUSyntax(),
Init.get());
13564template<
typename Derived>
13566TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
13567 DesignatedInitUpdateExpr *
E) {
13568 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
13573template<
typename Derived>
13575TreeTransform<Derived>::TransformNoInitExpr(
13577 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
13581template<
typename Derived>
13583TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *
E) {
13584 llvm_unreachable(
"Unexpected ArrayInitLoopExpr outside of initializer");
13588template<
typename Derived>
13590TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *
E) {
13591 llvm_unreachable(
"Unexpected ArrayInitIndexExpr outside of initializer");
13595template<
typename Derived>
13597TreeTransform<Derived>::TransformImplicitValueInitExpr(
13598 ImplicitValueInitExpr *
E) {
13599 TemporaryBase Rebase(*
this,
E->
getBeginLoc(), DeclarationName());
13603 QualType
T = getDerived().TransformType(
E->
getType());
13607 if (!getDerived().AlwaysRebuild() &&
13611 return getDerived().RebuildImplicitValueInitExpr(
T);
13614template<
typename Derived>
13616TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *
E) {
13617 TypeSourceInfo *TInfo = getDerived().TransformType(
E->getWrittenTypeInfo());
13621 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
13622 if (SubExpr.isInvalid())
13625 if (!getDerived().AlwaysRebuild() &&
13626 TInfo ==
E->getWrittenTypeInfo() &&
13627 SubExpr.get() ==
E->getSubExpr())
13630 return getDerived().RebuildVAArgExpr(
E->getBuiltinLoc(), SubExpr.get(),
13631 TInfo,
E->getRParenLoc());
13634template<
typename Derived>
13636TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *
E) {
13637 bool ArgumentChanged =
false;
13639 if (TransformExprs(
E->getExprs(),
E->getNumExprs(),
true, Inits,
13643 return getDerived().RebuildParenListExpr(
E->getLParenLoc(),
13645 E->getRParenLoc());
13653template<
typename Derived>
13655TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *
E) {
13656 Decl *LD = getDerived().TransformDecl(
E->getLabel()->getLocation(),
13661 return getDerived().RebuildAddrLabelExpr(
E->getAmpAmpLoc(),
E->getLabelLoc(),
13662 cast<LabelDecl>(LD));
13665template<
typename Derived>
13667TreeTransform<Derived>::TransformStmtExpr(StmtExpr *
E) {
13670 = getDerived().TransformCompoundStmt(
E->getSubStmt(),
true);
13671 if (SubStmt.isInvalid()) {
13676 unsigned OldDepth =
E->getTemplateDepth();
13677 unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);
13679 if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
13680 SubStmt.get() ==
E->getSubStmt()) {
13686 return getDerived().RebuildStmtExpr(
E->getLParenLoc(), SubStmt.get(),
13687 E->getRParenLoc(), NewDepth);
13690template<
typename Derived>
13692TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *
E) {
13693 ExprResult Cond = getDerived().TransformExpr(
E->getCond());
13694 if (Cond.isInvalid())
13697 ExprResult LHS = getDerived().TransformExpr(
E->getLHS());
13698 if (LHS.isInvalid())
13701 ExprResult RHS = getDerived().TransformExpr(
E->getRHS());
13702 if (RHS.isInvalid())
13705 if (!getDerived().AlwaysRebuild() &&
13706 Cond.get() ==
E->getCond() &&
13707 LHS.get() ==
E->getLHS() &&
13708 RHS.get() ==
E->getRHS())
13711 return getDerived().RebuildChooseExpr(
E->getBuiltinLoc(),
13712 Cond.get(), LHS.get(), RHS.get(),
13713 E->getRParenLoc());
13716template<
typename Derived>
13718TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *
E) {
13722template<
typename Derived>
13724TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *
E) {
13725 switch (
E->getOperator()) {
13729 case OO_Array_Delete:
13730 llvm_unreachable(
"new and delete operators cannot use CXXOperatorCallExpr");
13735 assert(
E->getNumArgs() >= 1 &&
"Object call is missing arguments");
13744 static_cast<Expr *
>(
Object.get())->getEndLoc());
13748 if (getDerived().TransformExprs(
E->getArgs() + 1,
E->getNumArgs() - 1,
true,
13752 if (
E->getOperator() == OO_Subscript)
13753 return getDerived().RebuildCxxSubscriptExpr(
Object.get(), FakeLParenLoc,
13756 return getDerived().RebuildCallExpr(
Object.get(), FakeLParenLoc, Args,
13760#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
13764#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
13765#include "clang/Basic/OperatorKinds.def"
13767 case OO_Conditional:
13768 llvm_unreachable(
"conditional operator is not actually overloadable");
13772 llvm_unreachable(
"not an overloaded operator?");
13776 if (
E->getNumArgs() == 1 &&
E->getOperator() == OO_Amp)
13777 First = getDerived().TransformAddressOfOperand(
E->getArg(0));
13779 First = getDerived().TransformExpr(
E->getArg(0));
13780 if (
First.isInvalid())
13784 if (
E->getNumArgs() == 2) {
13786 getDerived().TransformInitializer(
E->getArg(1),
false);
13787 if (Second.isInvalid())
13791 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
13792 FPOptionsOverride NewOverrides(
E->getFPFeatures());
13793 getSema().CurFPFeatures =
13794 NewOverrides.applyOverrides(getSema().getLangOpts());
13795 getSema().FpPragmaStack.CurrentValue = NewOverrides;
13797 Expr *
Callee =
E->getCallee();
13798 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) {
13799 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
13801 if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R))
13804 return getDerived().RebuildCXXOperatorCallExpr(
13805 E->getOperator(),
E->getOperatorLoc(),
Callee->getBeginLoc(),
13806 ULE->requiresADL(), R.asUnresolvedSet(),
First.get(), Second.get());
13809 UnresolvedSet<1> Functions;
13810 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
13811 Callee = ICE->getSubExprAsWritten();
13812 NamedDecl *DR = cast<DeclRefExpr>(Callee)->getDecl();
13813 ValueDecl *VD = cast_or_null<ValueDecl>(
13814 getDerived().TransformDecl(DR->getLocation(), DR));
13818 if (!isa<CXXMethodDecl>(VD))
13819 Functions.addDecl(VD);
13821 return getDerived().RebuildCXXOperatorCallExpr(
13822 E->getOperator(),
E->getOperatorLoc(),
Callee->getBeginLoc(),
13823 false, Functions,
First.get(), Second.get());
13826template<
typename Derived>
13828TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *
E) {
13829 return getDerived().TransformCallExpr(
E);
13832template <
typename Derived>
13833ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *
E) {
13835 getSema().CurContext !=
E->getParentContext();
13837 if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
13840 return getDerived().RebuildSourceLocExpr(
E->getIdentKind(),
E->
getType(),
13842 getSema().CurContext);
13845template <
typename Derived>
13846ExprResult TreeTransform<Derived>::TransformEmbedExpr(EmbedExpr *
E) {
13850template<
typename Derived>
13852TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *
E) {
13859 ExprResult EC = getDerived().TransformCallExpr(
E->getConfig());
13860 if (EC.isInvalid())
13864 bool ArgChanged =
false;
13866 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
13870 if (!getDerived().AlwaysRebuild() &&
13871 Callee.get() ==
E->getCallee() &&
13876 SourceLocation FakeLParenLoc
13878 return getDerived().RebuildCallExpr(
Callee.get(), FakeLParenLoc,
13880 E->getRParenLoc(), EC.get());
13883template<
typename Derived>
13891 = getDerived().TransformExpr(
E->getSubExprAsWritten());
13895 if (!getDerived().AlwaysRebuild() &&
13896 Type ==
E->getTypeInfoAsWritten() &&
13897 SubExpr.
get() ==
E->getSubExpr())
13899 return getDerived().RebuildCXXNamedCastExpr(
13900 E->getOperatorLoc(),
E->
getStmtClass(),
E->getAngleBrackets().getBegin(),
13901 Type,
E->getAngleBrackets().getEnd(),
13903 E->getAngleBrackets().getEnd(), SubExpr.
get(),
E->getRParenLoc());
13906template<
typename Derived>
13915 if (Sub.isInvalid())
13918 return getDerived().RebuildBuiltinBitCastExpr(BCE->
getBeginLoc(), TSI,
13922template<
typename Derived>
13924TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *
E) {
13925 return getDerived().TransformCXXNamedCastExpr(
E);
13928template<
typename Derived>
13930TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *
E) {
13931 return getDerived().TransformCXXNamedCastExpr(
E);
13934template<
typename Derived>
13936TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
13937 CXXReinterpretCastExpr *
E) {
13938 return getDerived().TransformCXXNamedCastExpr(
E);
13941template<
typename Derived>
13943TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *
E) {
13944 return getDerived().TransformCXXNamedCastExpr(
E);
13947template<
typename Derived>
13949TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *
E) {
13950 return getDerived().TransformCXXNamedCastExpr(
E);
13953template<
typename Derived>
13955TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
13956 CXXFunctionalCastExpr *
E) {
13957 TypeSourceInfo *
Type =
13958 getDerived().TransformTypeWithDeducedTST(
E->getTypeInfoAsWritten());
13963 = getDerived().TransformExpr(
E->getSubExprAsWritten());
13964 if (SubExpr.isInvalid())
13967 if (!getDerived().AlwaysRebuild() &&
13968 Type ==
E->getTypeInfoAsWritten() &&
13969 SubExpr.get() ==
E->getSubExpr())
13972 return getDerived().RebuildCXXFunctionalCastExpr(Type,
13976 E->isListInitialization());
13979template<
typename Derived>
13981TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *
E) {
13982 if (
E->isTypeOperand()) {
13983 TypeSourceInfo *TInfo
13984 = getDerived().TransformType(
E->getTypeOperandSourceInfo());
13988 if (!getDerived().AlwaysRebuild() &&
13989 TInfo ==
E->getTypeOperandSourceInfo())
13999 Expr *Op =
E->getExprOperand();
14002 if (
auto *RecordT = Op->getType()->getAs<RecordType>())
14003 if (cast<CXXRecordDecl>(RecordT->getDecl())->isPolymorphic())
14006 EnterExpressionEvaluationContext
Unevaluated(SemaRef, EvalCtx,
14009 ExprResult SubExpr = getDerived().TransformExpr(Op);
14010 if (SubExpr.isInvalid())
14013 if (!getDerived().AlwaysRebuild() &&
14014 SubExpr.get() ==
E->getExprOperand())
14021template<
typename Derived>
14023TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *
E) {
14024 if (
E->isTypeOperand()) {
14025 TypeSourceInfo *TInfo
14026 = getDerived().TransformType(
E->getTypeOperandSourceInfo());
14030 if (!getDerived().AlwaysRebuild() &&
14031 TInfo ==
E->getTypeOperandSourceInfo())
14041 ExprResult SubExpr = getDerived().TransformExpr(
E->getExprOperand());
14042 if (SubExpr.isInvalid())
14045 if (!getDerived().AlwaysRebuild() &&
14046 SubExpr.get() ==
E->getExprOperand())
14053template<
typename Derived>
14055TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *
E) {
14059template<
typename Derived>
14061TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
14062 CXXNullPtrLiteralExpr *
E) {
14066template<
typename Derived>
14068TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *
E) {
14079 QualType
T = [&]() {
14080 auto &S = getSema();
14081 if (
E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
14084 return getDerived().TransformType(
E->
getType());
14088 if (!getDerived().AlwaysRebuild() &&
T ==
E->
getType()) {
14091 getSema().MarkThisReferenced(
E);
14095 return getDerived().RebuildCXXThisExpr(
E->
getBeginLoc(),
T,
E->isImplicit());
14098template<
typename Derived>
14100TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *
E) {
14101 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
14102 if (SubExpr.isInvalid())
14105 if (!getDerived().AlwaysRebuild() &&
14106 SubExpr.get() ==
E->getSubExpr())
14109 return getDerived().RebuildCXXThrowExpr(
E->getThrowLoc(), SubExpr.get(),
14110 E->isThrownVariableInScope());
14113template<
typename Derived>
14115TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *
E) {
14116 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
14117 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getParam()));
14122 if (
E->hasRewrittenInit()) {
14123 InitRes = getDerived().TransformExpr(
E->getRewrittenExpr());
14124 if (InitRes.isInvalid())
14128 if (!getDerived().AlwaysRebuild() && Param ==
E->getParam() &&
14130 InitRes.get() ==
E->getRewrittenExpr())
14133 return getDerived().RebuildCXXDefaultArgExpr(
E->getUsedLocation(), Param,
14137template<
typename Derived>
14139TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *
E) {
14140 FieldDecl *
Field = cast_or_null<FieldDecl>(
14141 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getField()));
14145 if (!getDerived().AlwaysRebuild() && Field ==
E->getField() &&
14149 return getDerived().RebuildCXXDefaultInitExpr(
E->
getExprLoc(), Field);
14152template<
typename Derived>
14154TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
14155 CXXScalarValueInitExpr *
E) {
14156 TypeSourceInfo *
T = getDerived().TransformType(
E->getTypeSourceInfo());
14160 if (!getDerived().AlwaysRebuild() &&
14161 T ==
E->getTypeSourceInfo())
14164 return getDerived().RebuildCXXScalarValueInitExpr(
T,
14165 T->getTypeLoc().getEndLoc(),
14166 E->getRParenLoc());
14169template<
typename Derived>
14171TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *
E) {
14173 TypeSourceInfo *AllocTypeInfo =
14174 getDerived().TransformTypeWithDeducedTST(
E->getAllocatedTypeSourceInfo());
14175 if (!AllocTypeInfo)
14179 std::optional<Expr *> ArraySize;
14180 if (
E->isArray()) {
14182 if (std::optional<Expr *> OldArraySize =
E->getArraySize()) {
14183 NewArraySize = getDerived().TransformExpr(*OldArraySize);
14184 if (NewArraySize.isInvalid())
14187 ArraySize = NewArraySize.get();
14191 bool ArgumentChanged =
false;
14193 if (getDerived().TransformExprs(
E->getPlacementArgs(),
14194 E->getNumPlacementArgs(),
true,
14195 PlacementArgs, &ArgumentChanged))
14199 Expr *OldInit =
E->getInitializer();
14202 NewInit = getDerived().TransformInitializer(OldInit,
true);
14203 if (NewInit.isInvalid())
14207 FunctionDecl *OperatorNew =
nullptr;
14208 if (
E->getOperatorNew()) {
14209 OperatorNew = cast_or_null<FunctionDecl>(
14210 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getOperatorNew()));
14215 FunctionDecl *OperatorDelete =
nullptr;
14216 if (
E->getOperatorDelete()) {
14217 OperatorDelete = cast_or_null<FunctionDecl>(
14218 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getOperatorDelete()));
14219 if (!OperatorDelete)
14223 if (!getDerived().AlwaysRebuild() &&
14224 AllocTypeInfo ==
E->getAllocatedTypeSourceInfo() &&
14225 ArraySize ==
E->getArraySize() &&
14226 NewInit.get() == OldInit &&
14227 OperatorNew ==
E->getOperatorNew() &&
14228 OperatorDelete ==
E->getOperatorDelete() &&
14229 !ArgumentChanged) {
14234 if (OperatorDelete)
14237 if (
E->isArray() && !
E->getAllocatedType()->isDependentType()) {
14238 QualType ElementType
14240 if (
const RecordType *RecordT = ElementType->getAs<RecordType>()) {
14241 CXXRecordDecl *
Record = cast<CXXRecordDecl>(RecordT->getDecl());
14251 QualType AllocType = AllocTypeInfo->
getType();
14261 }
else if (
const ConstantArrayType *ConsArrayT
14262 = dyn_cast<ConstantArrayType>(ArrayT)) {
14266 AllocType = ConsArrayT->getElementType();
14267 }
else if (
const DependentSizedArrayType *DepArrayT
14268 = dyn_cast<DependentSizedArrayType>(ArrayT)) {
14269 if (DepArrayT->getSizeExpr()) {
14270 ArraySize = DepArrayT->getSizeExpr();
14271 AllocType = DepArrayT->getElementType();
14276 return getDerived().RebuildCXXNewExpr(
14280 AllocTypeInfo, ArraySize,
E->getDirectInitRange(), NewInit.get());
14283template<
typename Derived>
14285TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *
E) {
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 Operand.get() ==
E->getArgument() &&
14301 OperatorDelete ==
E->getOperatorDelete()) {
14304 if (OperatorDelete)
14309 E->getDestroyedType());
14310 if (
const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
14311 CXXRecordDecl *
Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
14320 return getDerived().RebuildCXXDeleteExpr(
14324template<
typename Derived>
14326TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
14327 CXXPseudoDestructorExpr *
E) {
14329 if (
Base.isInvalid())
14333 bool MayBePseudoDestructor =
false;
14335 E->getOperatorLoc(),
14336 E->isArrow()? tok::arrow : tok::period,
14338 MayBePseudoDestructor);
14339 if (
Base.isInvalid())
14342 QualType ObjectType = ObjectTypePtr.get();
14343 NestedNameSpecifierLoc QualifierLoc =
E->getQualifierLoc();
14344 if (QualifierLoc) {
14346 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
14351 SS.Adopt(QualifierLoc);
14353 PseudoDestructorTypeStorage Destroyed;
14354 if (
E->getDestroyedTypeInfo()) {
14355 TypeSourceInfo *DestroyedTypeInfo
14356 = getDerived().TransformTypeInObjectScope(
E->getDestroyedTypeInfo(),
14357 ObjectType,
nullptr, SS);
14358 if (!DestroyedTypeInfo)
14360 Destroyed = DestroyedTypeInfo;
14361 }
else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
14364 Destroyed = PseudoDestructorTypeStorage(
E->getDestroyedTypeIdentifier(),
14365 E->getDestroyedTypeLoc());
14369 *
E->getDestroyedTypeIdentifier(),
E->getDestroyedTypeLoc(),
14370 nullptr, SS, ObjectTypePtr,
false);
14376 E->getDestroyedTypeLoc());
14379 TypeSourceInfo *ScopeTypeInfo =
nullptr;
14380 if (
E->getScopeTypeInfo()) {
14381 CXXScopeSpec EmptySS;
14382 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
14383 E->getScopeTypeInfo(), ObjectType,
nullptr, EmptySS);
14384 if (!ScopeTypeInfo)
14388 return getDerived().RebuildCXXPseudoDestructorExpr(
Base.get(),
14389 E->getOperatorLoc(),
14393 E->getColonColonLoc(),
14398template <
typename Derived>
14403 bool AllEmptyPacks =
true;
14404 for (
auto *OldD : Old->
decls()) {
14405 Decl *InstD = getDerived().TransformDecl(Old->
getNameLoc(), OldD);
14409 if (isa<UsingShadowDecl>(OldD))
14418 NamedDecl *SingleDecl = cast<NamedDecl>(InstD);
14420 if (
auto *UPD = dyn_cast<UsingPackDecl>(InstD))
14421 Decls = UPD->expansions();
14424 for (
auto *
D : Decls) {
14425 if (
auto *UD = dyn_cast<UsingDecl>(
D)) {
14426 for (
auto *SD : UD->shadows())
14433 AllEmptyPacks &= Decls.empty();
14442 if (AllEmptyPacks && !RequiresADL) {
14443 getSema().Diag(Old->
getNameLoc(), diag::err_using_pack_expansion_empty)
14444 << isa<UnresolvedMemberExpr>(Old) << Old->
getName();
14454 getSema().FilterAcceptableTemplateNames(R,
14461 diag::err_template_kw_refers_to_non_template)
14465 diag::note_template_kw_refers_to_non_template)
14474template <
typename Derived>
14477 return TransformUnresolvedLookupExpr(Old,
false);
14480template <
typename Derived>
14483 bool IsAddressOfOperand) {
14488 if (TransformOverloadExprDecls(Old, Old->
requiresADL(), R))
14495 = getDerived().TransformNestedNameSpecifierLoc(Old->
getQualifierLoc());
14499 SS.
Adopt(QualifierLoc);
14503 CXXRecordDecl *NamingClass
14504 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
14507 if (!NamingClass) {
14512 R.setNamingClass(NamingClass);
14533 SS, TemplateKWLoc, R,
14540 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->
requiresADL());
14543 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
14547template<
typename Derived>
14549TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *
E) {
14550 bool ArgChanged =
false;
14552 for (
unsigned I = 0, N =
E->getNumArgs(); I != N; ++I) {
14553 TypeSourceInfo *From =
E->getArg(I);
14554 TypeLoc FromTL = From->getTypeLoc();
14555 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
14556 TypeLocBuilder TLB;
14557 TLB.reserve(FromTL.getFullDataSize());
14558 QualType To = getDerived().TransformType(TLB, FromTL);
14562 if (To == From->getType())
14563 Args.push_back(From);
14565 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14574 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
14575 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
14581 bool Expand =
true;
14582 bool RetainExpansion =
false;
14583 std::optional<unsigned> OrigNumExpansions =
14584 ExpansionTL.getTypePtr()->getNumExpansions();
14585 std::optional<unsigned> NumExpansions = OrigNumExpansions;
14586 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
14587 PatternTL.getSourceRange(),
14589 Expand, RetainExpansion,
14597 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
14599 TypeLocBuilder TLB;
14600 TLB.reserve(From->getTypeLoc().getFullDataSize());
14602 QualType To = getDerived().TransformType(TLB, PatternTL);
14606 To = getDerived().RebuildPackExpansionType(To,
14607 PatternTL.getSourceRange(),
14608 ExpansionTL.getEllipsisLoc(),
14613 PackExpansionTypeLoc ToExpansionTL
14614 = TLB.push<PackExpansionTypeLoc>(To);
14615 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14616 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14622 for (
unsigned I = 0; I != *NumExpansions; ++I) {
14623 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
14624 TypeLocBuilder TLB;
14625 TLB.reserve(PatternTL.getFullDataSize());
14626 QualType To = getDerived().TransformType(TLB, PatternTL);
14630 if (To->containsUnexpandedParameterPack()) {
14631 To = getDerived().RebuildPackExpansionType(To,
14632 PatternTL.getSourceRange(),
14633 ExpansionTL.getEllipsisLoc(),
14638 PackExpansionTypeLoc ToExpansionTL
14639 = TLB.push<PackExpansionTypeLoc>(To);
14640 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14643 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14646 if (!RetainExpansion)
14651 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
14653 TypeLocBuilder TLB;
14654 TLB.reserve(From->getTypeLoc().getFullDataSize());
14656 QualType To = getDerived().TransformType(TLB, PatternTL);
14660 To = getDerived().RebuildPackExpansionType(To,
14661 PatternTL.getSourceRange(),
14662 ExpansionTL.getEllipsisLoc(),
14667 PackExpansionTypeLoc ToExpansionTL
14668 = TLB.push<PackExpansionTypeLoc>(To);
14669 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
14670 Args.push_back(TLB.getTypeSourceInfo(SemaRef.
Context, To));
14673 if (!getDerived().AlwaysRebuild() && !ArgChanged)
14676 return getDerived().RebuildTypeTrait(
E->getTrait(),
E->
getBeginLoc(), Args,
14680template<
typename Derived>
14682TreeTransform<Derived>::TransformConceptSpecializationExpr(
14683 ConceptSpecializationExpr *
E) {
14684 const ASTTemplateArgumentListInfo *Old =
E->getTemplateArgsAsWritten();
14685 TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
14686 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
14687 Old->NumTemplateArgs, TransArgs))
14690 return getDerived().RebuildConceptSpecializationExpr(
14691 E->getNestedNameSpecifierLoc(),
E->getTemplateKWLoc(),
14692 E->getConceptNameInfo(),
E->getFoundDecl(),
E->getNamedConcept(),
14696template<
typename Derived>
14698TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *
E) {
14701 Sema::ExtParameterInfoBuilder ExtParamInfos;
14705 EnterExpressionEvaluationContext Ctx(
14710 getSema().Context, getSema().CurContext,
14713 Sema::ContextRAII SavedContext(getSema(), Body,
false);
14715 ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
14716 E->getRequiresKWLoc(),
E->getRBraceLoc(),
E, Body,
14717 E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);
14719 for (ParmVarDecl *Param : TransParams)
14721 Param->setDeclContext(Body);
14727 if (!TypeParamResult.isUnset())
14728 return TypeParamResult;
14731 if (getDerived().TransformRequiresExprRequirements(
E->getRequirements(),
14735 for (concepts::Requirement *Req : TransReqs) {
14736 if (
auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
14737 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
14738 ER->getReturnTypeRequirement()
14739 .getTypeConstraintTemplateParameterList()->getParam(0)
14740 ->setDeclContext(Body);
14745 return getDerived().RebuildRequiresExpr(
14746 E->getRequiresKWLoc(), Body,
E->getLParenLoc(), TransParams,
14747 E->getRParenLoc(), TransReqs,
E->getRBraceLoc());
14750template<
typename Derived>
14756 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req))
14757 TransReq = getDerived().TransformTypeRequirement(TypeReq);
14758 else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req))
14759 TransReq = getDerived().TransformExprRequirement(ExprReq);
14761 TransReq = getDerived().TransformNestedRequirement(
14762 cast<concepts::NestedRequirement>(Req));
14765 Transformed.push_back(TransReq);
14770template<
typename Derived>
14775 if (getDerived().AlwaysRebuild())
14776 return getDerived().RebuildTypeRequirement(
14783 return getDerived().RebuildTypeRequirement(TransType);
14786template<
typename Derived>
14789 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
14798 TransExpr = TransExprRes.
get();
14801 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
14803 if (RetReq.isEmpty())
14804 TransRetReq.emplace();
14805 else if (RetReq.isSubstitutionFailure())
14806 TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
14807 else if (RetReq.isTypeConstraint()) {
14809 RetReq.getTypeConstraintTemplateParameterList();
14811 getDerived().TransformTemplateParameterList(OrigTPL);
14814 TransRetReq.emplace(TPL);
14816 assert(TransRetReq &&
"All code paths leading here must set TransRetReq");
14817 if (
Expr *
E = TransExpr.dyn_cast<
Expr *>())
14818 return getDerived().RebuildExprRequirement(
E, Req->
isSimple(),
14820 std::move(*TransRetReq));
14821 return getDerived().RebuildExprRequirement(
14822 cast<concepts::Requirement::SubstitutionDiagnostic *>(TransExpr),
14826template<
typename Derived>
14831 if (getDerived().AlwaysRebuild())
14832 return getDerived().RebuildNestedRequirement(
14840 return getDerived().RebuildNestedRequirement(TransConstraint.
get());
14843template<
typename Derived>
14846 TypeSourceInfo *
T = getDerived().TransformType(
E->getQueriedTypeSourceInfo());
14850 if (!getDerived().AlwaysRebuild() &&
14851 T ==
E->getQueriedTypeSourceInfo())
14858 SubExpr = getDerived().TransformExpr(
E->getDimensionExpression());
14862 if (!getDerived().AlwaysRebuild() && SubExpr.
get() ==
E->getDimensionExpression())
14866 return getDerived().RebuildArrayTypeTrait(
E->getTrait(),
E->
getBeginLoc(),
T,
14870template<
typename Derived>
14872TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *
E) {
14877 SubExpr = getDerived().TransformExpr(
E->getQueriedExpression());
14878 if (SubExpr.isInvalid())
14881 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getQueriedExpression())
14885 return getDerived().RebuildExpressionTrait(
E->getTrait(),
E->
getBeginLoc(),
14889template <
typename Derived>
14893 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
14894 DRE, AddrTaken, RecoveryTSI);
14901 if (!getDerived().AlwaysRebuild() && NewDRE.
get() == DRE)
14903 return getDerived().RebuildParenExpr(NewDRE.
get(), PE->
getLParen(),
14907template <
typename Derived>
14910 return TransformDependentScopeDeclRefExpr(
E,
false,
14914template <
typename Derived>
14918 assert(
E->getQualifierLoc());
14920 getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc());
14930 getDerived().TransformDeclarationNameInfo(
E->getNameInfo());
14934 if (!
E->hasExplicitTemplateArgs()) {
14935 if (!getDerived().AlwaysRebuild() && QualifierLoc ==
E->getQualifierLoc() &&
14938 NameInfo.
getName() ==
E->getDeclName())
14941 return getDerived().RebuildDependentScopeDeclRefExpr(
14942 QualifierLoc, TemplateKWLoc, NameInfo,
nullptr,
14943 IsAddressOfOperand, RecoveryTSI);
14946 TemplateArgumentListInfo TransArgs(
E->getLAngleLoc(),
E->getRAngleLoc());
14947 if (getDerived().TransformTemplateArguments(
14948 E->getTemplateArgs(),
E->getNumTemplateArgs(), TransArgs))
14951 return getDerived().RebuildDependentScopeDeclRefExpr(
14952 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
14956template<
typename Derived>
14958TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *
E) {
14962 if (getDerived().AllowSkippingCXXConstructExpr() &&
14963 ((
E->getNumArgs() == 1 ||
14964 (
E->getNumArgs() > 1 && getDerived().DropCallArgument(
E->getArg(1)))) &&
14965 (!getDerived().DropCallArgument(
E->getArg(0))) &&
14966 !
E->isListInitialization()))
14967 return getDerived().TransformInitializer(
E->getArg(0),
14970 TemporaryBase Rebase(*
this,
E->
getBeginLoc(), DeclarationName());
14972 QualType
T = getDerived().TransformType(
E->
getType());
14976 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
14977 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
14981 bool ArgumentChanged =
false;
14984 EnterExpressionEvaluationContext Context(
14986 E->isListInitialization());
14987 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
14992 if (!getDerived().AlwaysRebuild() &&
14994 Constructor ==
E->getConstructor() &&
14995 !ArgumentChanged) {
15002 return getDerived().RebuildCXXConstructExpr(
15004 E->hadMultipleCandidates(),
E->isListInitialization(),
15005 E->isStdInitListInitialization(),
E->requiresZeroInitialization(),
15006 E->getConstructionKind(),
E->getParenOrBraceRange());
15009template<
typename Derived>
15010ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
15011 CXXInheritedCtorInitExpr *
E) {
15012 QualType
T = getDerived().TransformType(
E->
getType());
15016 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
15017 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
15021 if (!getDerived().AlwaysRebuild() &&
15023 Constructor ==
E->getConstructor()) {
15030 return getDerived().RebuildCXXInheritedCtorInitExpr(
15031 T,
E->getLocation(), Constructor,
15032 E->constructsVBase(),
E->inheritedFromVBase());
15039template<
typename Derived>
15041TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *
E) {
15042 if (
auto *Dtor =
E->getTemporary()->getDestructor())
15044 const_cast<CXXDestructorDecl *
>(Dtor));
15045 return getDerived().TransformExpr(
E->getSubExpr());
15053template<
typename Derived>
15055TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *
E) {
15056 return getDerived().TransformExpr(
E->getSubExpr());
15059template<
typename Derived>
15061TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
15062 CXXTemporaryObjectExpr *
E) {
15063 TypeSourceInfo *
T =
15064 getDerived().TransformTypeWithDeducedTST(
E->getTypeSourceInfo());
15068 CXXConstructorDecl *
Constructor = cast_or_null<CXXConstructorDecl>(
15069 getDerived().TransformDecl(
E->
getBeginLoc(),
E->getConstructor()));
15073 bool ArgumentChanged =
false;
15075 Args.reserve(
E->getNumArgs());
15077 EnterExpressionEvaluationContext Context(
15079 E->isListInitialization());
15080 if (TransformExprs(
E->getArgs(),
E->getNumArgs(),
true, Args,
15084 if (
E->isListInitialization() && !
E->isStdInitListInitialization()) {
15086 if (Res.isInvalid())
15088 Args = {Res.get()};
15092 if (!getDerived().AlwaysRebuild() &&
15093 T ==
E->getTypeSourceInfo() &&
15094 Constructor ==
E->getConstructor() &&
15095 !ArgumentChanged) {
15101 SourceLocation LParenLoc =
T->getTypeLoc().getEndLoc();
15102 return getDerived().RebuildCXXTemporaryObjectExpr(
15103 T, LParenLoc, Args,
E->
getEndLoc(),
E->isListInitialization());
15106template<
typename Derived>
15108TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *
E) {
15111 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
15112 struct TransformedInitCapture {
15114 SourceLocation EllipsisLoc;
15119 InitCaptures.resize(
E->explicit_capture_end() -
E->explicit_capture_begin());
15121 CEnd =
E->capture_end();
15123 if (!
E->isInitCapture(
C))
15126 TransformedInitCapture &
Result = InitCaptures[
C -
E->capture_begin()];
15127 auto *OldVD = cast<VarDecl>(
C->getCapturedVar());
15129 auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
15130 std::optional<unsigned> NumExpansions) {
15131 ExprResult NewExprInitResult = getDerived().TransformInitializer(
15134 if (NewExprInitResult.isInvalid()) {
15135 Result.Expansions.push_back(InitCaptureInfoTy(
ExprError(), QualType()));
15138 Expr *NewExprInit = NewExprInitResult.get();
15140 QualType NewInitCaptureType =
15141 getSema().buildLambdaInitCaptureInitialization(
15142 C->getLocation(),
C->getCaptureKind() ==
LCK_ByRef,
15143 EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
15144 cast<VarDecl>(
C->getCapturedVar())->getInitStyle() !=
15147 Result.Expansions.push_back(
15148 InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
15152 if (OldVD->isParameterPack()) {
15153 PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
15155 .castAs<PackExpansionTypeLoc>();
15161 bool Expand =
true;
15162 bool RetainExpansion =
false;
15163 std::optional<unsigned> OrigNumExpansions =
15164 ExpansionTL.getTypePtr()->getNumExpansions();
15165 std::optional<unsigned> NumExpansions = OrigNumExpansions;
15166 if (getDerived().TryExpandParameterPacks(
15167 ExpansionTL.getEllipsisLoc(),
15168 OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
15169 RetainExpansion, NumExpansions))
15171 assert(!RetainExpansion &&
"Should not need to retain expansion after a "
15172 "capture since it cannot be extended");
15174 for (
unsigned I = 0; I != *NumExpansions; ++I) {
15175 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
15176 SubstInitCapture(SourceLocation(), std::nullopt);
15179 SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
15180 Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
15183 SubstInitCapture(SourceLocation(), std::nullopt);
15187 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
15188 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
15199 DeclContext *DC = getSema().CurContext;
15217 while (DC->isRequiresExprBody())
15218 DC = DC->getParent();
15219 if ((getSema().isUnevaluatedContext() ||
15220 getSema().isConstantEvaluatedContext()) &&
15221 (DC->isFileContext() || !DC->getParent()->isDependentContext()))
15224 CXXRecordDecl *OldClass =
E->getLambdaClass();
15225 CXXRecordDecl *
Class = getSema().createLambdaClosureType(
15226 E->getIntroducerRange(),
nullptr, DependencyKind,
15227 E->getCaptureDefault());
15228 getDerived().transformedLocalDecl(OldClass, {
Class});
15230 CXXMethodDecl *NewCallOperator =
15231 getSema().CreateLambdaCallOperator(
E->getIntroducerRange(),
Class);
15234 getSema().buildLambdaScope(LSI, NewCallOperator,
E->getIntroducerRange(),
15235 E->getCaptureDefault(),
E->getCaptureDefaultLoc(),
15236 E->hasExplicitParameters(),
E->isMutable());
15239 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
15246 CEnd =
E->capture_end();
15250 if (
C->isImplicit())
15254 if (
C->capturesThis()) {
15260 Sema::CXXThisScopeRAII ThisScope(
15262 dyn_cast_if_present<CXXRecordDecl>(
15263 getSema().getFunctionLevelDeclContext()),
15265 getSema().CheckCXXThisCapture(
C->getLocation(),
C->isExplicit(),
15272 if (
C->capturesVLAType())
15276 if (
E->isInitCapture(
C)) {
15277 TransformedInitCapture &NewC = InitCaptures[
C -
E->capture_begin()];
15279 auto *OldVD = cast<VarDecl>(
C->getCapturedVar());
15282 for (InitCaptureInfoTy &Info : NewC.Expansions) {
15284 QualType InitQualType = Info.second;
15285 if (
Init.isInvalid() || InitQualType.isNull()) {
15289 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
15290 OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
15291 OldVD->getIdentifier(), OldVD->getInitStyle(),
Init.get(),
15292 getSema().CurContext);
15297 NewVDs.push_back(NewVD);
15298 getSema().addInitCapture(LSI, NewVD,
C->getCaptureKind() ==
LCK_ByRef);
15303 if (NewC.EllipsisLoc.isInvalid())
15304 LSI->ContainsUnexpandedParameterPack |=
15305 Init.get()->containsUnexpandedParameterPack();
15311 getDerived().transformedLocalDecl(OldVD, NewVDs);
15315 assert(
C->capturesVariable() &&
"unexpected kind of lambda capture");
15323 SourceLocation EllipsisLoc;
15324 if (
C->isPackExpansion()) {
15326 bool ShouldExpand =
false;
15327 bool RetainExpansion =
false;
15328 std::optional<unsigned> NumExpansions;
15329 if (getDerived().TryExpandParameterPacks(
C->getEllipsisLoc(),
15332 ShouldExpand, RetainExpansion,
15338 if (ShouldExpand) {
15342 auto *Pack = cast<VarDecl>(
C->getCapturedVar());
15343 for (
unsigned I = 0; I != *NumExpansions; ++I) {
15344 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
15345 VarDecl *CapturedVar
15346 = cast_or_null<VarDecl>(getDerived().TransformDecl(
C->getLocation(),
15348 if (!CapturedVar) {
15354 getSema().tryCaptureVariable(CapturedVar,
C->getLocation(), Kind);
15362 EllipsisLoc =
C->getEllipsisLoc();
15366 auto *CapturedVar = cast_or_null<ValueDecl>(
15367 getDerived().TransformDecl(
C->getLocation(),
C->getCapturedVar()));
15368 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
15375 if (
auto *VD = dyn_cast<VarDecl>(CapturedVar); VD && !
C->isPackExpansion())
15376 LSI->ContainsUnexpandedParameterPack |= VD->isParameterPack();
15379 getSema().tryCaptureVariable(CapturedVar,
C->getLocation(), Kind,
15382 getSema().finishLambdaExplicitCaptures(LSI);
15386 auto TPL = getDerived().TransformTemplateParameterList(
15387 E->getTemplateParameterList());
15388 LSI->GLTemplateParameterList = TPL;
15390 getSema().AddTemplateParametersToLambdaCallOperator(NewCallOperator,
Class,
15392 LSI->ContainsUnexpandedParameterPack |=
15393 TPL->containsUnexpandedParameterPack();
15396 TypeLocBuilder NewCallOpTLBuilder;
15397 TypeLoc OldCallOpTypeLoc =
15398 E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
15399 QualType NewCallOpType =
15400 getDerived().TransformType(NewCallOpTLBuilder, OldCallOpTypeLoc);
15401 if (NewCallOpType.isNull())
15403 LSI->ContainsUnexpandedParameterPack |=
15404 NewCallOpType->containsUnexpandedParameterPack();
15405 TypeSourceInfo *NewCallOpTSI =
15406 NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType);
15410 auto FPTL = NewCallOpTSI->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>();
15411 assert(FPTL &&
"Not a FunctionProtoType?");
15413 getSema().CompleteLambdaCallOperator(
15414 NewCallOperator,
E->getCallOperator()->getLocation(),
15415 E->getCallOperator()->getInnerLocStart(),
15416 E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI,
15417 E->getCallOperator()->getConstexprKind(),
15418 E->getCallOperator()->getStorageClass(), FPTL.getParams(),
15419 E->hasExplicitResultType());
15421 getDerived().transformAttrs(
E->getCallOperator(), NewCallOperator);
15422 getDerived().transformedLocalDecl(
E->getCallOperator(), {NewCallOperator});
15426 Sema::ContextRAII ManglingContext(getSema(),
Class->getDeclContext());
15428 std::optional<CXXRecordDecl::LambdaNumbering> Numbering;
15429 if (getDerived().ReplacingOriginal()) {
15430 Numbering = OldClass->getLambdaNumbering();
15433 getSema().handleLambdaNumbering(
Class, NewCallOperator, Numbering);
15438 getSema().PushExpressionEvaluationContext(
15439 E->getCallOperator()->isConsteval() ?
15442 getSema().currentEvaluationContext().InImmediateEscalatingFunctionContext =
15443 getSema().getLangOpts().CPlusPlus20 &&
15444 E->getCallOperator()->isImmediateEscalating();
15446 Sema::CodeSynthesisContext
C;
15449 getSema().pushCodeSynthesisContext(
C);
15455 getSema().popCodeSynthesisContext();
15458 FuncScopeCleanup.disable();
15460 if (Body.isInvalid()) {
15461 SavedContext.pop();
15470 auto LSICopy = *LSI;
15471 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
15473 SavedContext.pop();
15508 DependencyKind = getDerived().ComputeLambdaDependency(&LSICopy);
15509 Class->setLambdaDependencyKind(DependencyKind);
15512 Class->setTypeForDecl(
nullptr);
15513 getSema().Context.getTypeDeclType(
Class);
15515 return getDerived().RebuildLambdaExpr(
E->
getBeginLoc(),
15516 Body.get()->getEndLoc(), &LSICopy);
15519template<
typename Derived>
15522 return TransformStmt(S);
15525template<
typename Derived>
15530 CEnd =
E->capture_end();
15534 if (!
C->isImplicit())
15538 if (
C->capturesThis()) {
15539 getSema().CheckCXXThisCapture(
C->getLocation(),
C->isExplicit(),
15546 if (
C->capturesVLAType())
15549 assert(
C->capturesVariable() &&
"unexpected kind of lambda capture");
15550 assert(!
E->isInitCapture(
C) &&
"implicit init-capture?");
15553 VarDecl *CapturedVar = cast_or_null<VarDecl>(
15554 getDerived().TransformDecl(
C->getLocation(),
C->getCapturedVar()));
15559 getSema().tryCaptureVariable(CapturedVar,
C->getLocation());
15565template<
typename Derived>
15570 getDerived().TransformTypeWithDeducedTST(
E->getTypeSourceInfo());
15574 bool ArgumentChanged =
false;
15576 Args.reserve(
E->getNumArgs());
15580 E->isListInitialization());
15581 if (getDerived().TransformExprs(
E->arg_begin(),
E->getNumArgs(),
true, Args,
15586 if (!getDerived().AlwaysRebuild() &&
15587 T ==
E->getTypeSourceInfo() &&
15592 return getDerived().RebuildCXXUnresolvedConstructExpr(
15593 T,
E->getLParenLoc(), Args,
E->getRParenLoc(),
E->isListInitialization());
15596template<
typename Derived>
15598TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
15599 CXXDependentScopeMemberExpr *
E) {
15604 QualType ObjectType;
15605 if (!
E->isImplicitAccess()) {
15606 OldBase =
E->getBase();
15607 Base = getDerived().TransformExpr(OldBase);
15608 if (
Base.isInvalid())
15613 bool MayBePseudoDestructor =
false;
15615 E->getOperatorLoc(),
15616 E->isArrow()? tok::arrow : tok::period,
15618 MayBePseudoDestructor);
15619 if (
Base.isInvalid())
15622 ObjectType = ObjectTy.get();
15623 BaseType = ((Expr*)
Base.get())->getType();
15626 BaseType = getDerived().TransformType(
E->getBaseType());
15632 NamedDecl *FirstQualifierInScope
15633 = getDerived().TransformFirstQualifierInScope(
15634 E->getFirstQualifierFoundInScope(),
15637 NestedNameSpecifierLoc QualifierLoc;
15638 if (
E->getQualifier()) {
15640 = getDerived().TransformNestedNameSpecifierLoc(
E->getQualifierLoc(),
15642 FirstQualifierInScope);
15647 SourceLocation TemplateKWLoc =
E->getTemplateKeywordLoc();
15653 DeclarationNameInfo NameInfo
15654 = getDerived().TransformDeclarationNameInfo(
E->getMemberNameInfo());
15655 if (!NameInfo.getName())
15658 if (!
E->hasExplicitTemplateArgs()) {
15661 if (!getDerived().AlwaysRebuild() &&
15662 Base.get() == OldBase &&
15663 BaseType ==
E->getBaseType() &&
15664 QualifierLoc ==
E->getQualifierLoc() &&
15665 NameInfo.getName() ==
E->getMember() &&
15666 FirstQualifierInScope ==
E->getFirstQualifierFoundInScope())
15669 return getDerived().RebuildCXXDependentScopeMemberExpr(
Base.get(),
15672 E->getOperatorLoc(),
15675 FirstQualifierInScope,
15680 TemplateArgumentListInfo TransArgs(
E->getLAngleLoc(),
E->getRAngleLoc());
15681 if (getDerived().TransformTemplateArguments(
E->getTemplateArgs(),
15682 E->getNumTemplateArgs(),
15686 return getDerived().RebuildCXXDependentScopeMemberExpr(
Base.get(),
15689 E->getOperatorLoc(),
15692 FirstQualifierInScope,
15697template <
typename Derived>
15698ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
15699 UnresolvedMemberExpr *Old) {
15703 if (!Old->isImplicitAccess()) {
15704 Base = getDerived().TransformExpr(Old->getBase());
15705 if (
Base.isInvalid())
15708 getSema().PerformMemberExprBaseConversion(
Base.get(), Old->isArrow());
15709 if (
Base.isInvalid())
15711 BaseType =
Base.get()->getType();
15713 BaseType = getDerived().TransformType(Old->getBaseType());
15716 NestedNameSpecifierLoc QualifierLoc;
15717 if (Old->getQualifierLoc()) {
15719 getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
15724 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
15729 if (TransformOverloadExprDecls(Old,
false, R))
15733 if (Old->getNamingClass()) {
15734 CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
15735 getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
15739 R.setNamingClass(NamingClass);
15742 TemplateArgumentListInfo TransArgs;
15743 if (Old->hasExplicitTemplateArgs()) {
15744 TransArgs.setLAngleLoc(Old->getLAngleLoc());
15745 TransArgs.setRAngleLoc(Old->getRAngleLoc());
15746 if (getDerived().TransformTemplateArguments(
15747 Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
15755 NamedDecl *FirstQualifierInScope =
nullptr;
15757 return getDerived().RebuildUnresolvedMemberExpr(
15758 Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
15759 TemplateKWLoc, FirstQualifierInScope, R,
15760 (Old->hasExplicitTemplateArgs() ? &TransArgs :
nullptr));
15763template<
typename Derived>
15765TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *
E) {
15768 ExprResult SubExpr = getDerived().TransformExpr(
E->getOperand());
15769 if (SubExpr.isInvalid())
15772 if (!getDerived().AlwaysRebuild() && SubExpr.get() ==
E->getOperand())
15775 return getDerived().RebuildCXXNoexceptExpr(
E->
getSourceRange(),SubExpr.get());
15778template<
typename Derived>
15780TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *
E) {
15781 ExprResult Pattern = getDerived().TransformExpr(
E->getPattern());
15782 if (Pattern.isInvalid())
15785 if (!getDerived().AlwaysRebuild() && Pattern.get() ==
E->getPattern())
15788 return getDerived().RebuildPackExpansion(Pattern.get(),
E->getEllipsisLoc(),
15789 E->getNumExpansions());
15792template<
typename Derived>
15794TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *
E) {
15804 TemplateArgument ArgStorage;
15807 if (
E->isPartiallySubstituted()) {
15808 PackArgs =
E->getPartialArguments();
15811 bool ShouldExpand =
false;
15812 bool RetainExpansion =
false;
15813 std::optional<unsigned> NumExpansions;
15814 if (getDerived().TryExpandParameterPacks(
E->getOperatorLoc(),
E->getPackLoc(),
15816 ShouldExpand, RetainExpansion,
15822 if (ShouldExpand) {
15823 auto *Pack =
E->getPack();
15824 if (
auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) {
15825 ArgStorage = getSema().Context.getPackExpansionType(
15827 }
else if (
auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) {
15828 ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
15830 auto *VD = cast<ValueDecl>(Pack);
15831 ExprResult DRE = getSema().BuildDeclRefExpr(
15832 VD, VD->getType().getNonLValueExprType(getSema().Context),
15835 if (DRE.isInvalid())
15837 ArgStorage =
new (getSema().Context)
15838 PackExpansionExpr(getSema().Context.DependentTy, DRE.get(),
15839 E->getPackLoc(), std::nullopt);
15841 PackArgs = ArgStorage;
15846 if (!PackArgs.size()) {
15847 auto *Pack = cast_or_null<NamedDecl>(
15848 getDerived().TransformDecl(
E->getPackLoc(),
E->getPack()));
15851 return getDerived().RebuildSizeOfPackExpr(
15852 E->getOperatorLoc(), Pack,
E->getPackLoc(),
E->getRParenLoc(),
15857 std::optional<unsigned>
Result = 0;
15858 for (
const TemplateArgument &Arg : PackArgs) {
15859 if (!Arg.isPackExpansion()) {
15864 TemplateArgumentLoc ArgLoc;
15865 InventTemplateArgumentLoc(Arg, ArgLoc);
15868 SourceLocation Ellipsis;
15869 std::optional<unsigned> OrigNumExpansions;
15870 TemplateArgumentLoc Pattern =
15871 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
15872 OrigNumExpansions);
15875 TemplateArgumentLoc OutPattern;
15876 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15877 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
15882 std::optional<unsigned> NumExpansions =
15883 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
15884 if (!NumExpansions) {
15897 return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(),
E->getPack(),
15899 E->getRParenLoc(), *
Result, {});
15901 TemplateArgumentListInfo TransformedPackArgs(
E->getPackLoc(),
15904 TemporaryBase Rebase(*
this,
E->getPackLoc(), getBaseEntity());
15905 typedef TemplateArgumentLocInventIterator<
15906 Derived,
const TemplateArgument*> PackLocIterator;
15907 if (TransformTemplateArguments(PackLocIterator(*
this, PackArgs.begin()),
15908 PackLocIterator(*
this, PackArgs.end()),
15909 TransformedPackArgs,
true))
15916 bool PartialSubstitution =
false;
15917 for (
auto &
Loc : TransformedPackArgs.arguments()) {
15918 Args.push_back(
Loc.getArgument());
15919 if (
Loc.getArgument().isPackExpansion())
15920 PartialSubstitution =
true;
15923 if (PartialSubstitution)
15924 return getDerived().RebuildSizeOfPackExpr(
15925 E->getOperatorLoc(),
E->getPack(),
E->getPackLoc(),
E->getRParenLoc(),
15926 std::nullopt, Args);
15928 return getDerived().RebuildSizeOfPackExpr(
E->getOperatorLoc(),
E->getPack(),
15929 E->getPackLoc(),
E->getRParenLoc(),
15933template <
typename Derived>
15935TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *
E) {
15942 EnterExpressionEvaluationContext ConstantContext(
15944 IndexExpr = getDerived().TransformExpr(
E->getIndexExpr());
15945 if (IndexExpr.isInvalid())
15950 bool FullySubstituted =
true;
15951 if (!
E->expandsToEmptyPack() &&
E->getExpressions().empty()) {
15952 Expr *Pattern =
E->getPackIdExpression();
15954 getSema().collectUnexpandedParameterPacks(
E->getPackIdExpression(),
15956 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
15960 bool ShouldExpand =
true;
15961 bool RetainExpansion =
false;
15962 std::optional<unsigned> OrigNumExpansions;
15963 std::optional<unsigned> NumExpansions = OrigNumExpansions;
15964 if (getDerived().TryExpandParameterPacks(
15966 ShouldExpand, RetainExpansion, NumExpansions))
15968 if (!ShouldExpand) {
15969 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15970 ExprResult Pack = getDerived().TransformExpr(Pattern);
15971 if (Pack.isInvalid())
15973 return getDerived().RebuildPackIndexingExpr(
15974 E->getEllipsisLoc(),
E->getRSquareLoc(), Pack.get(), IndexExpr.get(),
15977 for (
unsigned I = 0; I != *NumExpansions; ++I) {
15978 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
15979 ExprResult Out = getDerived().TransformExpr(Pattern);
15980 if (Out.isInvalid())
15982 if (Out.get()->containsUnexpandedParameterPack()) {
15983 Out = getDerived().RebuildPackExpansion(Out.get(),
E->getEllipsisLoc(),
15984 OrigNumExpansions);
15985 if (Out.isInvalid())
15987 FullySubstituted =
false;
15989 ExpandedExprs.push_back(Out.get());
15993 if (RetainExpansion) {
15994 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
15996 ExprResult Out = getDerived().TransformExpr(Pattern);
15997 if (Out.isInvalid())
16000 Out = getDerived().RebuildPackExpansion(Out.get(),
E->getEllipsisLoc(),
16001 OrigNumExpansions);
16002 if (Out.isInvalid())
16004 FullySubstituted =
false;
16005 ExpandedExprs.push_back(Out.get());
16007 }
else if (!
E->expandsToEmptyPack()) {
16008 if (getDerived().TransformExprs(
E->getExpressions().data(),
16009 E->getExpressions().size(),
false,
16014 return getDerived().RebuildPackIndexingExpr(
16015 E->getEllipsisLoc(),
E->getRSquareLoc(),
E->getPackIdExpression(),
16016 IndexExpr.get(), ExpandedExprs, FullySubstituted);
16019template<
typename Derived>
16021TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
16022 SubstNonTypeTemplateParmPackExpr *
E) {
16027template<
typename Derived>
16029TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
16030 SubstNonTypeTemplateParmExpr *
E) {
16035template<
typename Derived>
16037TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *
E) {
16042template<
typename Derived>
16044TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
16045 MaterializeTemporaryExpr *
E) {
16046 return getDerived().TransformExpr(
E->getSubExpr());
16049template<
typename Derived>
16051TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *
E) {
16052 UnresolvedLookupExpr *
Callee =
nullptr;
16053 if (Expr *OldCallee =
E->getCallee()) {
16054 ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
16055 if (CalleeResult.isInvalid())
16057 Callee = cast<UnresolvedLookupExpr>(CalleeResult.get());
16060 Expr *Pattern =
E->getPattern();
16063 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
16064 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
16068 bool Expand =
true;
16069 bool RetainExpansion =
false;
16070 std::optional<unsigned> OrigNumExpansions =
E->getNumExpansions(),
16071 NumExpansions = OrigNumExpansions;
16072 if (getDerived().TryExpandParameterPacks(
E->getEllipsisLoc(),
16075 Expand, RetainExpansion,
16082 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
16085 E->getLHS() ? getDerived().TransformExpr(
E->getLHS()) :
ExprResult();
16086 if (LHS.isInvalid())
16090 E->getRHS() ? getDerived().TransformExpr(
E->getRHS()) :
ExprResult();
16091 if (RHS.isInvalid())
16094 if (!getDerived().AlwaysRebuild() &&
16095 LHS.get() ==
E->getLHS() && RHS.get() ==
E->getRHS())
16098 return getDerived().RebuildCXXFoldExpr(
16100 E->getEllipsisLoc(), RHS.get(),
E->
getEndLoc(), NumExpansions);
16106 if (NumExpansions && SemaRef.
getLangOpts().BracketDepth < NumExpansions) {
16107 SemaRef.
Diag(
E->getEllipsisLoc(),
16108 clang::diag::err_fold_expression_limit_exceeded)
16109 << *NumExpansions << SemaRef.
getLangOpts().BracketDepth
16111 SemaRef.
Diag(
E->getEllipsisLoc(), diag::note_bracket_depth);
16120 bool LeftFold =
E->isLeftFold();
16124 if (!LeftFold && RetainExpansion) {
16125 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
16127 ExprResult Out = getDerived().TransformExpr(Pattern);
16128 if (Out.isInvalid())
16131 Result = getDerived().RebuildCXXFoldExpr(
16138 for (
unsigned I = 0; I != *NumExpansions; ++I) {
16139 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(
16140 getSema(), LeftFold ? I : *NumExpansions - I - 1);
16141 ExprResult Out = getDerived().TransformExpr(Pattern);
16142 if (Out.isInvalid())
16145 if (Out.get()->containsUnexpandedParameterPack()) {
16147 Result = getDerived().RebuildCXXFoldExpr(
16149 E->getOperator(),
E->getEllipsisLoc(),
16151 OrigNumExpansions);
16152 }
else if (
Result.isUsable()) {
16154 Expr *LHS = LeftFold ?
Result.get() : Out.get();
16155 Expr *RHS = LeftFold ? Out.get() :
Result.get();
16157 UnresolvedSet<16> Functions;
16158 Functions.append(
Callee->decls_begin(),
Callee->decls_end());
16159 Result = getDerived().RebuildCXXOperatorCallExpr(
16161 E->getEllipsisLoc(),
Callee->getBeginLoc(),
Callee->requiresADL(),
16162 Functions, LHS, RHS);
16164 Result = getDerived().RebuildBinaryOperator(
E->getEllipsisLoc(),
16165 E->getOperator(), LHS, RHS);
16176 if (LeftFold && RetainExpansion) {
16177 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
16179 ExprResult Out = getDerived().TransformExpr(Pattern);
16180 if (Out.isInvalid())
16183 Result = getDerived().RebuildCXXFoldExpr(
16185 E->getEllipsisLoc(), Out.get(),
E->
getEndLoc(), OrigNumExpansions);
16190 if (ParenExpr *PE = dyn_cast_or_null<ParenExpr>(
Result.get()))
16191 PE->setIsProducedByFoldExpansion();
16196 return getDerived().RebuildEmptyCXXFoldExpr(
E->getEllipsisLoc(),
16201template <
typename Derived>
16203TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *
E) {
16206 if (TransformExprs(InitExprs.data(), InitExprs.size(),
true,
16210 return getDerived().RebuildParenListExpr(
E->
getBeginLoc(), TransformedInits,
16214template<
typename Derived>
16216TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
16217 CXXStdInitializerListExpr *
E) {
16218 return getDerived().TransformExpr(
E->getSubExpr());
16221template<
typename Derived>
16223TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *
E) {
16227template<
typename Derived>
16229TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *
E) {
16233template<
typename Derived>
16235TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *
E) {
16236 ExprResult SubExpr = getDerived().TransformExpr(
E->getSubExpr());
16237 if (SubExpr.isInvalid())
16240 if (!getDerived().AlwaysRebuild() &&
16241 SubExpr.get() ==
E->getSubExpr())
16244 return getDerived().RebuildObjCBoxedExpr(
E->
getSourceRange(), SubExpr.get());
16247template<
typename Derived>
16249TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *
E) {
16252 bool ArgChanged =
false;
16253 if (getDerived().TransformExprs(
E->getElements(),
E->getNumElements(),
16254 false, Elements, &ArgChanged))
16257 if (!getDerived().AlwaysRebuild() && !ArgChanged)
16265template<
typename Derived>
16267TreeTransform<Derived>::TransformObjCDictionaryLiteral(
16268 ObjCDictionaryLiteral *
E) {
16271 bool ArgChanged =
false;
16272 for (
unsigned I = 0, N =
E->getNumElements(); I != N; ++I) {
16273 ObjCDictionaryElement OrigElement =
E->getKeyValueElement(I);
16275 if (OrigElement.isPackExpansion()) {
16278 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
16279 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
16280 assert(!Unexpanded.empty() &&
"Pack expansion without parameter packs?");
16284 bool Expand =
true;
16285 bool RetainExpansion =
false;
16286 std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
16287 std::optional<unsigned> NumExpansions = OrigNumExpansions;
16288 SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
16289 OrigElement.Value->getEndLoc());
16290 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc,
16291 PatternRange, Unexpanded, Expand,
16292 RetainExpansion, NumExpansions))
16299 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
16300 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16301 if (Key.isInvalid())
16304 if (Key.get() != OrigElement.Key)
16308 if (
Value.isInvalid())
16311 if (
Value.get() != OrigElement.Value)
16314 ObjCDictionaryElement Expansion = {
16315 Key.get(),
Value.get(), OrigElement.EllipsisLoc, NumExpansions
16317 Elements.push_back(Expansion);
16327 for (
unsigned I = 0; I != *NumExpansions; ++I) {
16328 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
16329 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16330 if (Key.isInvalid())
16334 if (
Value.isInvalid())
16337 ObjCDictionaryElement Element = {
16338 Key.get(),
Value.get(), SourceLocation(), NumExpansions
16344 if (Key.get()->containsUnexpandedParameterPack() ||
16345 Value.get()->containsUnexpandedParameterPack())
16346 Element.EllipsisLoc = OrigElement.EllipsisLoc;
16348 Elements.push_back(Element);
16358 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
16359 if (Key.isInvalid())
16362 if (Key.get() != OrigElement.Key)
16367 = getDerived().TransformExpr(OrigElement.Value);
16368 if (
Value.isInvalid())
16371 if (
Value.get() != OrigElement.Value)
16374 ObjCDictionaryElement Element = {Key.get(),
Value.get(), SourceLocation(),
16376 Elements.push_back(Element);
16379 if (!getDerived().AlwaysRebuild() && !ArgChanged)
16382 return getDerived().RebuildObjCDictionaryLiteral(
E->
getSourceRange(),
16386template<
typename Derived>
16388TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *
E) {
16389 TypeSourceInfo *EncodedTypeInfo
16390 = getDerived().TransformType(
E->getEncodedTypeSourceInfo());
16391 if (!EncodedTypeInfo)
16394 if (!getDerived().AlwaysRebuild() &&
16395 EncodedTypeInfo ==
E->getEncodedTypeSourceInfo())
16398 return getDerived().RebuildObjCEncodeExpr(
E->getAtLoc(),
16400 E->getRParenLoc());
16403template<
typename Derived>
16405TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *
E) {
16410 return getDerived().TransformExpr(
E->getSubExpr());
16413template<
typename Derived>
16415TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *
E) {
16416 TypeSourceInfo *TSInfo
16417 = getDerived().TransformType(
E->getTypeInfoAsWritten());
16425 if (!getDerived().AlwaysRebuild() &&
16426 TSInfo ==
E->getTypeInfoAsWritten() &&
16427 Result.get() ==
E->getSubExpr())
16431 E->getLParenLoc(),
E->getBridgeKind(),
E->getBridgeKeywordLoc(), TSInfo,
16435template <
typename Derived>
16436ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
16437 ObjCAvailabilityCheckExpr *
E) {
16441template<
typename Derived>
16443TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *
E) {
16445 bool ArgChanged =
false;
16447 Args.reserve(
E->getNumArgs());
16448 if (getDerived().TransformExprs(
E->getArgs(),
E->getNumArgs(),
false, Args,
16454 TypeSourceInfo *ReceiverTypeInfo
16455 = getDerived().TransformType(
E->getClassReceiverTypeInfo());
16456 if (!ReceiverTypeInfo)
16460 if (!getDerived().AlwaysRebuild() &&
16461 ReceiverTypeInfo ==
E->getClassReceiverTypeInfo() && !ArgChanged)
16466 E->getSelectorLocs(SelLocs);
16467 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
16470 E->getMethodDecl(),
16477 if (!
E->getMethodDecl())
16482 E->getSelectorLocs(SelLocs);
16483 return getDerived().RebuildObjCMessageExpr(
E->getSuperLoc(),
16486 E->getReceiverType(),
16487 E->getMethodDecl(),
16495 "Only class and instance messages may be instantiated");
16497 = getDerived().TransformExpr(
E->getInstanceReceiver());
16498 if (Receiver.isInvalid())
16502 if (!getDerived().AlwaysRebuild() &&
16503 Receiver.get() ==
E->getInstanceReceiver() && !ArgChanged)
16508 E->getSelectorLocs(SelLocs);
16509 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
16512 E->getMethodDecl(),
16518template<
typename Derived>
16520TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *
E) {
16524template<
typename Derived>
16526TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *
E) {
16530template<
typename Derived>
16532TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *
E) {
16535 if (
Base.isInvalid())
16541 if (!getDerived().AlwaysRebuild() &&
16542 Base.get() ==
E->getBase())
16545 return getDerived().RebuildObjCIvarRefExpr(
Base.get(),
E->getDecl(),
16547 E->isArrow(),
E->isFreeIvar());
16550template<
typename Derived>
16552TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *
E) {
16555 if (!
E->isObjectReceiver())
16560 if (
Base.isInvalid())
16566 if (!getDerived().AlwaysRebuild() &&
16567 Base.get() ==
E->getBase())
16570 if (
E->isExplicitProperty())
16571 return getDerived().RebuildObjCPropertyRefExpr(
Base.get(),
16572 E->getExplicitProperty(),
16575 return getDerived().RebuildObjCPropertyRefExpr(
Base.get(),
16577 E->getImplicitPropertyGetter(),
16578 E->getImplicitPropertySetter(),
16582template<
typename Derived>
16584TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *
E) {
16587 if (
Base.isInvalid())
16591 ExprResult Key = getDerived().TransformExpr(
E->getKeyExpr());
16592 if (Key.isInvalid())
16596 if (!getDerived().AlwaysRebuild() &&
16597 Key.get() ==
E->getKeyExpr() &&
Base.get() ==
E->getBaseExpr())
16600 return getDerived().RebuildObjCSubscriptRefExpr(
E->getRBracket(),
16601 Base.get(), Key.get(),
16602 E->getAtIndexMethodDecl(),
16603 E->setAtIndexMethodDecl());
16606template<
typename Derived>
16608TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *
E) {
16611 if (
Base.isInvalid())
16615 if (!getDerived().AlwaysRebuild() &&
16616 Base.get() ==
E->getBase())
16619 return getDerived().RebuildObjCIsaExpr(
Base.get(),
E->getIsaMemberLoc(),
16624template<
typename Derived>
16626TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *
E) {
16627 bool ArgumentChanged =
false;
16629 SubExprs.reserve(
E->getNumSubExprs());
16630 if (getDerived().TransformExprs(
E->getSubExprs(),
E->getNumSubExprs(),
false,
16631 SubExprs, &ArgumentChanged))
16634 if (!getDerived().AlwaysRebuild() &&
16638 return getDerived().RebuildShuffleVectorExpr(
E->getBuiltinLoc(),
16640 E->getRParenLoc());
16643template<
typename Derived>
16645TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *
E) {
16646 ExprResult SrcExpr = getDerived().TransformExpr(
E->getSrcExpr());
16647 if (SrcExpr.isInvalid())
16650 TypeSourceInfo *
Type = getDerived().TransformType(
E->getTypeSourceInfo());
16654 if (!getDerived().AlwaysRebuild() &&
16655 Type ==
E->getTypeSourceInfo() &&
16656 SrcExpr.get() ==
E->getSrcExpr())
16659 return getDerived().RebuildConvertVectorExpr(
E->getBuiltinLoc(),
16660 SrcExpr.get(), Type,
16661 E->getRParenLoc());
16664template<
typename Derived>
16666TreeTransform<Derived>::TransformBlockExpr(BlockExpr *
E) {
16667 BlockDecl *oldBlock =
E->getBlockDecl();
16670 BlockScopeInfo *blockScope = SemaRef.
getCurBlock();
16673 blockScope->TheDecl->setBlockMissingReturnType(
16674 oldBlock->blockMissingReturnType());
16679 const FunctionProtoType *exprFunctionType =
E->getFunctionType();
16682 Sema::ExtParameterInfoBuilder extParamInfos;
16683 if (getDerived().TransformFunctionTypeParams(
16684 E->getCaretLocation(), oldBlock->parameters(),
nullptr,
16685 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
16687 getSema().ActOnBlockError(
E->getCaretLocation(),
nullptr);
16691 QualType exprResultType =
16692 getDerived().TransformType(exprFunctionType->getReturnType());
16694 auto epi = exprFunctionType->getExtProtoInfo();
16695 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(paramTypes.size());
16698 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
16702 if (!params.empty())
16703 blockScope->TheDecl->setParams(params);
16705 if (!oldBlock->blockMissingReturnType()) {
16706 blockScope->HasImplicitReturnType =
false;
16707 blockScope->ReturnType = exprResultType;
16711 StmtResult body = getDerived().TransformStmt(
E->getBody());
16712 if (body.isInvalid()) {
16713 getSema().ActOnBlockError(
E->getCaretLocation(),
nullptr);
16721 for (
const auto &I : oldBlock->captures()) {
16722 VarDecl *oldCapture = I.getVariable();
16725 if (oldCapture->isParameterPack())
16728 VarDecl *newCapture =
16729 cast<VarDecl>(getDerived().TransformDecl(
E->getCaretLocation(),
16731 assert(blockScope->CaptureMap.count(newCapture));
16737 assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&
16738 "this pointer isn't captured in the old block");
16746template<
typename Derived>
16748TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *
E) {
16749 ExprResult SrcExpr = getDerived().TransformExpr(
E->getSrcExpr());
16750 if (SrcExpr.isInvalid())
16753 QualType
Type = getDerived().TransformType(
E->
getType());
16756 E->getRParenLoc());
16759template<
typename Derived>
16761TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *
E) {
16762 bool ArgumentChanged =
false;
16764 SubExprs.reserve(
E->getNumSubExprs());
16765 if (getDerived().TransformExprs(
E->getSubExprs(),
E->getNumSubExprs(),
false,
16766 SubExprs, &ArgumentChanged))
16769 if (!getDerived().AlwaysRebuild() &&
16773 return getDerived().RebuildAtomicExpr(
E->getBuiltinLoc(), SubExprs,
16774 E->getOp(),
E->getRParenLoc());
16781template<
typename Derived>
16785 getDerived().getBaseEntity());
16788template<
typename Derived>
16792 getDerived().getBaseEntity());
16795template<
typename Derived>
16798 bool WrittenAsLValue,
16801 Sigil, getDerived().getBaseEntity());
16804template<
typename Derived>
16810 getDerived().getBaseEntity());
16813template<
typename Derived>
16821 Decl, ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
16825template<
typename Derived>
16837 BaseType,
Loc, TypeArgsLAngleLoc, TypeArgs, TypeArgsRAngleLoc,
16838 ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
16843template<
typename Derived>
16850template <
typename Derived>
16853 Expr *SizeExpr,
unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16854 if (SizeExpr || !Size)
16856 IndexTypeQuals, BracketsRange,
16857 getDerived().getBaseEntity());
16865 for (
const auto &
T : Types)
16877 IndexTypeQuals, BracketsRange,
16878 getDerived().getBaseEntity());
16881template <
typename Derived>
16884 Expr *SizeExpr,
unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16885 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
16886 IndexTypeQuals, BracketsRange);
16889template <
typename Derived>
16893 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
nullptr,
16894 IndexTypeQuals, BracketsRange);
16897template <
typename Derived>
16900 unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16901 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
16903 IndexTypeQuals, BracketsRange);
16906template <
typename Derived>
16909 unsigned IndexTypeQuals,
SourceRange BracketsRange) {
16910 return getDerived().RebuildArrayType(ElementType, SizeMod,
nullptr,
16912 IndexTypeQuals, BracketsRange);
16915template <
typename Derived>
16922template <
typename Derived>
16924 unsigned NumElements,
16930template <
typename Derived>
16937template<
typename Derived>
16939 unsigned NumElements,
16942 NumElements,
true);
16949template<
typename Derived>
16957template <
typename Derived>
16959 QualType ElementType,
unsigned NumRows,
unsigned NumColumns) {
16964template <
typename Derived>
16972template<
typename Derived>
16978 getDerived().getBaseLocation(),
16979 getDerived().getBaseEntity(),
16983template<
typename Derived>
16988template<
typename Derived>
16991 assert(
D &&
"no decl found");
16995 if (
auto *UPD = dyn_cast<UsingPackDecl>(
D)) {
16999 if (UPD->expansions().empty()) {
17000 getSema().Diag(
Loc, diag::err_using_pack_expansion_empty)
17001 << UPD->isCXXClassMember() << UPD;
17010 for (
auto *
E : UPD->expansions()) {
17016 else if (
T.isNull())
17020 "mismatched resolved types in using pack expansion");
17022 return T.isNull() ? FallbackT :
T;
17023 }
else if (
auto *Using = dyn_cast<UsingDecl>(
D)) {
17024 assert(Using->hasTypename() &&
17025 "UnresolvedUsingTypenameDecl transformed to non-typename using");
17028 assert(++Using->shadow_begin() == Using->shadow_end());
17037 assert(isa<UnresolvedUsingTypenameDecl>(
D) &&
17038 "UnresolvedUsingTypenameDecl transformed to non-using decl");
17040 cast<UnresolvedUsingTypenameDecl>(
D));
17044template <
typename Derived>
17050template<
typename Derived>
17056template <
typename Derived>
17061template <
typename Derived>
17067 FullySubstituted, Expansions);
17070template<
typename Derived>
17077template<
typename Derived>
17085template<
typename Derived>
17091template<
typename Derived>
17099template <
typename Derived>
17110template <
typename Derived>
17116template<
typename Derived>
17125template<
typename Derived>
17133 bool AllowInjectedClassName) {
17137 getSema().ActOnTemplateName(
nullptr, SS, TemplateKWLoc,
17140 AllowInjectedClassName);
17141 return Template.
get();
17144template<
typename Derived>
17151 bool AllowInjectedClassName) {
17154 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
17155 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations);
17157 getSema().ActOnTemplateName(
17159 false, Template, AllowInjectedClassName);
17160 return Template.
get();
17163template <
typename Derived>
17168 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
17174 Opc,
First, Second);
17189 if (Op == OO_Subscript) {
17190 if (!
First->getType()->isOverloadableType() &&
17192 return getSema().CreateBuiltinArraySubscriptExpr(
First, CalleeLoc, Second,
17194 }
else if (Op == OO_Arrow) {
17197 if (
First->getType()->isDependentType())
17201 }
else if (Second ==
nullptr || isPostIncDec) {
17202 if (!
First->getType()->isOverloadableType() ||
17203 (Op == OO_Amp && getSema().isQualifiedMemberAccess(
First))) {
17210 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc,
First);
17214 !
First->getType()->isOverloadableType() &&
17229 if (!Second || isPostIncDec) {
17239 First, Second, RequiresADL);
17246template<
typename Derived>
17261 ->template getAs<RecordType>())){
17264 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType,
17265 CCLoc, TildeLoc, Destroyed);
17277 if (!ScopeType->getType()->getAs<
TagType>()) {
17278 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
17279 diag::err_expected_class_or_namespace)
17280 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
17288 return getSema().BuildMemberReferenceExpr(
Base, BaseType,
17289 OperatorLoc, isArrow,
17297template<
typename Derived>
17305 for (
unsigned I = 0; I < NumParams; ++I) {
17306 if (I != ContextParamPos) {
17312 Params.push_back(std::make_pair(StringRef(), QualType()));
17315 getSema().ActOnCapturedRegionStart(
Loc,
nullptr,
17316 S->getCapturedRegionKind(), Params);
17319 Sema::CompoundScopeRAII CompoundScope(getSema());
17320 Body = getDerived().TransformStmt(S->getCapturedStmt());
17323 if (Body.isInvalid()) {
17324 getSema().ActOnCapturedRegionError();
17328 return getSema().ActOnCapturedRegionEnd(Body.get());
17331template <
typename Derived>
17332ExprResult TreeTransform<Derived>::TransformHLSLOutArgExpr(HLSLOutArgExpr *
E) {
17335 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 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 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.