Lines Matching +full:tlb +full:- +full:split
1 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
66 /// transformation is performed for non-type template parameters and
69 /// This tree-transformation template uses static polymorphism to allow
75 /// Semantic tree transformations are split into two stages, either of which
86 /// most coarse-grained transformations involve replacing TransformType(),
91 /// For more fine-grained transformations, subclasses can replace any of the
106 /// default locations and entity names used for type-checking
110 /// Private RAII object that helps us forget and then re-remember
111 /// the template argument corresponding to a partially-substituted parameter
163 bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
180 /// By default, returns no source-location information. Subclasses can
225 /// to short-circuit evaluation when it is known that a given type will
227 /// non-dependent types.
247 return E->isDefaultArgument();
272 /// when extending explicitly-specified template argument packs per
296 /// "Forget" about the partially-substituted pack template argument,
305 /// "Remember" the partially-substituted pack template argument
327 /// Transforms the given type-with-location into a new
328 /// type-with-location.
337 /// Transform the given type-with-location into a new
341 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
395 // specific kind of statement attribute. Unlike the non-statement taking
414 // delegates to the non-statement taking version.
456 /// function-call arguments, and any arguments that should be dropped, will
462 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
480 return Known->second;
522 /// nested-name-specifier in a member access expression.
525 /// identifier in a nested-name-specifier of a member access expression, e.g.,
526 /// the \c T in \c x->T::member
538 /// Transform the given nested-name-specifier with source-location
542 /// nested-name-specifier. Subclasses may override this function to provide
570 /// \param SS The nested-name-specifier that qualifies the template
571 /// name. This nested-name-specifier must already have been transformed.
581 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
586 /// and nested-name-specifiers that occur within the template name.
615 /// should override the iterator-based member template version.
665 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
668 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
672 TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
677 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
684 QualType TransformAttributedType(TypeLocBuilder &TLB, AttributedTypeLoc TL,
695 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
700 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
706 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
715 /// LastParamTransformed, if non-null, will be set to the index of the last
759 /// Transforms a single function-type parameter. Return null
762 /// \param indexAdjustment - A number to add to the parameter's
769 /// Transform the body of a lambda-expression.
778 LSI->Lambda->getLambdaDependencyKind());
781 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
872 /// Build an Objective-C object type.
886 /// Build a new Objective-C object pointer type given the pointee type.
925 /// Build a new variable-length array type given the element type,
935 /// Build a new dependent-sized array type given the element type,
954 /// Build a new potentially dependently-sized extended vector type
970 /// Build a new potentially dependently-sized extended vector type
983 /// Build a new matrix type given the type and dependently-defined
1114 /// the nested-name-specifier and the named type.
1125 /// Build a new typename type that refers to a template-id.
1128 /// nested-name-specifier and the given type. Subclasses may override
1155 // Otherwise, make an elaborated type wrapping a non-dependent
1179 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1195 // We had a dependent elaborated-type-specifier that has been transformed
1196 // into a non-dependent elaborated-type-specifier. Find the tag we're
1219 llvm_unreachable("Tag lookup cannot find non-tags");
1239 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1254 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1258 // Build the elaborated-type-specifier type.
1286 /// Build a bit-precise int given its value type.
1290 /// Build a dependent bit-precise int given its value type.
1454 /// Build a new do-while statement.
1563 // This function rebuilds a coawait-expr given its operator.
1564 // For an explicit coawait-expr, the rebuild involves the full set
1567 // For an implicit coawait-expr, we need to rebuild the "operator
1606 /// Build a new Objective-C \@try statement.
1618 /// Rebuild an Objective-C exception declaration.
1625 TInfo, T, ExceptionDecl->getInnerLocStart(),
1626 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
1629 /// Build a new Objective-C \@catch statement.
1640 /// Build a new Objective-C \@finally statement.
1649 /// Build a new Objective-C \@throw statement.
2489 /// Rebuild the operand to an Objective-C \@synchronized statement.
2498 /// Build a new Objective-C \@synchronized statement.
2507 /// Build a new Objective-C \@autoreleasepool statement.
2516 /// Build a new Objective-C fast enumeration statement.
2546 getSema().CurContext->addDecl(Var);
2570 /// Build a new C++0x range-based for statement.
2579 // If we've just learned that the range is actually an Objective-C
2580 // collection, treat this as an Objective-C fast enumeration loop.
2582 if (RangeStmt->isSingleDecl()) {
2583 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2584 if (RangeVar->isInvalidDecl())
2587 Expr *RangeExpr = RangeVar->getInit();
2588 if (!RangeExpr->isTypeDependent() &&
2589 RangeExpr->getType()->isObjCObjectPointerType()) {
2590 // FIXME: Support init-statements in Objective-C++20 ranged for
2593 return SemaRef.Diag(Init->getBeginLoc(),
2595 << Init->getSourceRange();
2609 /// Build a new C++0x range-based for statement.
2622 /// Attach body to a C++0x range-based for statement.
2695 /// Build a new pseudo-destructor expression.
2863 if (!Member->getDeclName()) {
2867 assert(Member->getType()->isRecordType() &&
2879 // from the AST, so we need to re-insert them if needed (since
2881 if (!isArrow && Base->isPRValue()) {
2891 DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()),
2899 if (Base->containsErrors())
2902 QualType BaseType = Base->getType();
2904 if (isArrow && !BaseType->isPointerType())
2913 if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() &&
2916 ->getType()
2917 ->getPointeeType()
2918 ->getAsCXXRecordDecl()) {
2919 auto *Class = cast<CXXRecordDecl>(Member->getDeclContext());
2922 if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class))
2923 return getSema().BuildDeclRefExpr(Member, Member->getType(),
2924 VK_LValue, Member->getLocation());
2969 /// Build a new C-style cast expression.
3005 Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(),
3039 /// Build a new value-initialized expression.
3070 /// Build a new address-of-label expression.
3138 /// argument-dependent lookup, etc. Subclasses may override this routine to
3150 /// By default, this routine dispatches to one of the more-specific routines
3270 /// Build a new C++ functional-style cast expression.
3284 TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
3366 /// Build a new C++ default-argument expression.
3368 /// By default, builds a new default-argument expression, which does not
3377 /// Build a new C++11 default-initialization expression.
3387 /// Build a new C++ zero-initialization expression.
3492 /// Build a new template-id expression.
3505 /// Build a new object-construction expression.
3518 if (Constructor->isInheritingConstructor())
3519 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3546 /// Build a new object-construction expression.
3559 /// Build a new object-construction expression.
3659 /// Build a new Objective-C boxed expression.
3731 /// \brief Build a new Objective-C boxed expression.
3739 /// Build a new Objective-C array literal.
3757 /// Build a new Objective-C dictionary literal.
3766 /// Build a new Objective-C \@encode expression.
3777 /// Build a new Objective-C class message.
3786 ReceiverTypeInfo, ReceiverTypeInfo->getType(),
3791 /// Build a new Objective-C instance message.
3799 return SemaRef.ObjC().BuildInstanceMessage(Receiver, Receiver->getType(),
3805 /// Build a new Objective-C instance/class message to 'super'.
3814 return Method->isInstanceMethod()
3823 /// Build a new Objective-C ivar reference expression.
3831 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
3833 BaseArg, BaseArg->getType(),
3839 cast<ObjCIvarRefExpr>(Result.get())->setIsFreeIvar(IsFreeIvar);
3843 /// Build a new Objective-C property reference expression.
3851 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
3852 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
3862 /// Build a new Objective-C property reference expression.
3870 // Since these expressions can only be value-dependent, we do not
3878 /// Build a new Objective-C "isa" expression.
3886 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
3906 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name));
3914 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType());
3920 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(),
3921 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc,
3924 // Type-check the __builtin_shufflevector expression.
3976 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
3994 /// Build a new C++1z fold-expression.
4009 /// Build an empty C++1z fold-expression with the given operator.
4011 /// By default, produces the fallback value for the fold-expression, or
4071 QualType TransformDependentNameType(TypeLocBuilder &TLB,
4090 switch (S->getStmtClass()) {
4126 switch (S->getClauseKind()) {
4145 switch (E->getStmtClass()) {
4166 Init = FE->getSubExpr();
4169 OpaqueValueExpr *OVE = AIL->getCommonExpr();
4170 Init = OVE->getSourceExpr();
4174 Init = MTE->getSubExpr();
4177 Init = Binder->getSubExpr();
4180 Init = ICE->getSubExprAsWritten();
4184 return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
4186 // If this is copy-initialization, we only need to reconstruct
4187 // InitListExprs. Other forms of copy-initialization will be a no-op if
4190 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
4193 // Revert value-initialization back to empty parens.
4195 SourceRange Parens = VIE->getSourceRange();
4200 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
4212 if (Construct && Construct->isStdInitListInitialization())
4213 return TransformInitializer(Construct->getArg(0), NotCopyInit);
4215 // Enter a list-init context if this was list initialization.
4218 Construct->isListInitialization());
4223 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
4228 if (Construct->isListInitialization())
4229 return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
4230 Construct->getEndLoc());
4233 SourceRange Parens = Construct->getParenOrBraceRange();
4261 Expr *Pattern = Expansion->getPattern();
4271 std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
4273 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(),
4274 Pattern->getSourceRange(),
4284 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4290 Expansion->getEllipsisLoc(),
4313 if (Out.get()->containsUnexpandedParameterPack()) {
4315 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4324 // forgetting the partially-substituted parameter pack.
4333 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4363 getDerived().TransformDefinition(Var->getLocation(), Var));
4402 switch (QNNS->getKind()) {
4404 Sema::NestedNameSpecInfo IdInfo(QNNS->getAsIdentifier(),
4416 Q.getLocalBeginLoc(), QNNS->getAsNamespace()));
4424 Q.getLocalBeginLoc(), QNNS->getAsNamespaceAlias()));
4439 SourceLocation(), QNNS->getAsRecordDecl()));
4453 if (T->isDependentType() || T->isRecordType() ||
4454 (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) {
4455 if (T->isEnumeralType())
4468 // If the nested-name-specifier is an invalid type def, don't emit an
4471 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) {
4479 // The qualifier-in-scope and object type only apply to the leftmost entity.
4484 // Don't rebuild the nested-name-specifier if we don't have to.
4489 // If we can re-use the source-location data from the original
4490 // nested-name-specifier, do so.
4495 // Allocate new nested-name-specifier location information.
4539 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType());
4572 TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl();
4582 SS.getScopeRep() == QTN->getQualifier() &&
4586 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4598 SS.getScopeRep() == DTN->getQualifier() &&
4605 if (DTN->isIdentifier()) {
4608 *DTN->getIdentifier(),
4616 DTN->getOperator(), NameLoc,
4635 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
4636 SubstPack->getIndex(), SubstPack->getFinal());
4666 // argument. We get here when substituting into an already-substituted
4713 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
4786 const TemplateArgumentLoc *operator->() const { return &Arg; }
4810 pointer operator->() const { return pointer(**this); }
4882 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
4914 // forgetting the partially-substituted parameter pack.
4943 //===----------------------------------------------------------------------===//
4945 //===----------------------------------------------------------------------===//
4962 return NewDI->getType();
4968 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
4970 if (getDerived().AlreadyTransformed(DI->getType()))
4973 TypeLocBuilder TLB;
4975 TypeLoc TL = DI->getTypeLoc();
4976 TLB.reserve(TL.getFullDataSize());
4978 QualType Result = getDerived().TransformType(TLB, TL);
4982 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
4987 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
4992 return getDerived().Transform##CLASS##Type(TLB, \
5010 return NewDI ? NewDI->getType() : QualType();
5016 if (!isa<DependentNameType>(DI->getType()))
5020 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(),
5022 if (getDerived().AlreadyTransformed(DI->getType()))
5025 TypeLocBuilder TLB;
5027 TypeLoc TL = DI->getTypeLoc();
5028 TLB.reserve(TL.getFullDataSize());
5037 TLB, DNTL, /*DeducedTSTContext*/true);
5045 TLB.TypeWasModifiedSafely(Result);
5048 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
5053 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
5060 Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
5064 TLB, STTP, SuppressObjCLifetime);
5066 Result = getDerived().TransformType(TLB, UnqualTL);
5080 TLB.TypeWasModifiedSafely(Result);
5101 // [When] adding cv-qualifications on top of the function type [...] the
5102 // cv-qualifiers are ignored.
5103 if (T->isFunctionType()) {
5110 // when the cv-qualifiers are introduced through the use of a typedef-name
5111 // or decltype-specifier [...] the cv-qualifiers are ignored.
5112 // Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
5114 if (T->isReferenceType()) {
5121 // Suppress Objective-C lifetime qualifiers if they don't make sense for the
5124 if (!T->isObjCLifetimeType() && !T->isDependentType())
5127 // Objective-C ARC:
5131 if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) {
5133 QualType Deduced = AutoTy->getDeducedType();
5138 T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
5139 AutoTy->isDependentType(),
5141 AutoTy->getTypeConstraintConcept(),
5142 AutoTy->getTypeConstraintArguments());
5145 // already-qualified type.
5168 return TSI->getTypeLoc();
5178 if (getDerived().AlreadyTransformed(TSInfo->getType()))
5181 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType,
5192 TypeLocBuilder TLB;
5200 SS, SpecTL.getTypePtr()->getTemplateName(), SpecTL.getTemplateNameLoc(),
5205 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL,
5214 *SpecTL.getTypePtr()->getIdentifier(),
5221 Result = getDerived().TransformDependentTemplateSpecializationType(TLB,
5227 Result = getDerived().TransformType(TLB, TL);
5233 return TLB.getTypeSourceInfo(SemaRef.Context, Result);
5237 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
5238 TyLoc NewT = TLB.push<TyLoc>(T.getType());
5244 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
5246 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType());
5254 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
5257 return TransformTypeSpecType(TLB, T);
5261 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
5264 return getDerived().TransformType(TLB, TL.getOriginalLoc());
5268 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
5270 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
5278 TLB.push<DecayedTypeLoc>(Result);
5285 TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB,
5287 QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc());
5295 TLB.push<ArrayParameterTypeLoc>(Result);
5301 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
5304 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5309 if (PointeeType->getAs<ObjCObjectType>()) {
5311 // that an Objective-C class type is being replaced for 'T'. The
5316 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
5328 // Objective-C ARC can add lifetime qualifiers to the type that we're
5330 TLB.TypeWasModifiedSafely(Result->getPointeeType());
5332 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result);
5339 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
5342 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5355 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result);
5361 /// don't care whether the type itself is an l-value type or an r-value
5362 /// type; we only care if the type was *written* as an l-value type
5363 /// or an r-value type.
5366 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
5370 // Note that this works with the pointee-as-written.
5371 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5377 PointeeType != T->getPointeeTypeAsWritten()) {
5379 T->isSpelledAsLValue(),
5385 // Objective-C ARC can add lifetime qualifiers to the type that we're
5387 TLB.TypeWasModifiedSafely(
5388 Result->castAs<ReferenceType>()->getPointeeTypeAsWritten());
5390 // r-value references can be rebuilt as l-value references.
5393 NewTL = TLB.push<LValueReferenceTypeLoc>(Result);
5395 NewTL = TLB.push<RValueReferenceTypeLoc>(Result);
5403 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
5405 return TransformReferenceType(TLB, TL);
5410 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
5412 return TransformReferenceType(TLB, TL);
5417 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
5419 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5432 QualType OldClsType = QualType(T->getClass(), 0);
5435 NewClsType = NewClsTInfo->getType();
5444 PointeeType != T->getPointeeType() ||
5454 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
5455 if (MPT && PointeeType != MPT->getPointeeType()) {
5456 assert(isa<AdjustedType>(MPT->getPointeeType()));
5457 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType());
5460 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result);
5469 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
5472 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5479 OldSize = const_cast<Expr*>(T->getSizeExpr());
5490 ElementType != T->getElementType() ||
5491 (T->getSizeExpr() && NewSize != OldSize)) {
5493 T->getSizeModifier(),
5494 T->getSize(), NewSize,
5495 T->getIndexTypeCVRQualifiers(),
5505 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5515 TypeLocBuilder &TLB,
5518 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5524 ElementType != T->getElementType()) {
5526 T->getSizeModifier(),
5527 T->getIndexTypeCVRQualifiers(),
5533 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result);
5543 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
5546 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5554 SizeResult = getDerived().TransformExpr(T->getSizeExpr());
5567 ElementType != T->getElementType() ||
5568 Size != T->getSizeExpr()) {
5570 T->getSizeModifier(),
5572 T->getIndexTypeCVRQualifiers(),
5580 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5590 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
5593 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5606 if (!origSize) origSize = T->getSizeExpr();
5618 ElementType != T->getElementType() ||
5621 T->getSizeModifier(),
5623 T->getIndexTypeCVRQualifiers(),
5631 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result);
5641 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
5643 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5650 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
5656 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5657 Size.get() != T->getSizeExpr()) {
5659 ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
5667 TLB.push<DependentVectorTypeLoc>(Result);
5670 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5679 TypeLocBuilder &TLB,
5684 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5692 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
5699 ElementType != T->getElementType() ||
5700 Size.get() != T->getSizeExpr()) {
5703 T->getAttributeLoc());
5711 = TLB.push<DependentSizedExtVectorTypeLoc>(Result);
5714 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5723 TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
5726 QualType ElementType = getDerived().TransformType(T->getElementType());
5731 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
5733 ElementType, T->getNumRows(), T->getNumColumns());
5738 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(Result);
5749 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
5752 QualType ElementType = getDerived().TransformType(T->getElementType());
5763 origRows = T->getRowExpr();
5766 origColumns = T->getColumnExpr();
5782 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
5785 ElementType, rows, columns, T->getAttributeLoc());
5793 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(Result);
5803 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
5806 QualType pointeeType = getDerived().TransformType(T->getPointeeType());
5815 ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
5821 if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
5822 AddrSpace.get() != T->getAddrSpaceExpr()) {
5824 pointeeType, AddrSpace.get(), T->getAttributeLoc());
5832 TLB.push<DependentAddressSpaceTypeLoc>(Result);
5841 TransformType(TLB, DI->getTypeLoc());
5848 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
5851 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5857 ElementType != T->getElementType()) {
5858 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
5859 T->getVectorKind());
5864 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result);
5871 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
5874 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
5880 ElementType != T->getElementType()) {
5882 T->getNumElements(),
5888 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result);
5898 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
5901 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) {
5904 TypeLoc OldTL = OldDI->getTypeLoc();
5907 TypeLocBuilder TLB;
5908 TypeLoc NewTL = OldDI->getTypeLoc();
5909 TLB.reserve(NewTL.getFullDataSize());
5911 QualType Result = getDerived().TransformType(TLB,
5924 = TLB.push<PackExpansionTypeLoc>(Result);
5926 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result);
5936 OldParm->getDeclContext(),
5937 OldParm->getInnerLocStart(),
5938 OldParm->getLocation(),
5939 OldParm->getIdentifier(),
5940 NewDI->getType(),
5942 OldParm->getStorageClass(),
5944 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
5945 OldParm->getFunctionScopeIndex() + indexAdjustment);
5966 assert(OldParm->getFunctionScopeIndex() == i);
5970 if (OldParm->isParameterPack()) {
5975 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
5985 OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
5998 Pattern.getType().getTypePtr()->getContainedAutoType();
5999 assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&
6020 OutParamTypes.push_back(NewParm->getType());
6022 PVars->push_back(NewParm);
6026 // forgetting the partially-substituted parameter pack.
6039 OutParamTypes.push_back(NewParm->getType());
6041 PVars->push_back(NewParm);
6045 // last thing we pushed, but we post-incremented indexAdjustment
6048 indexAdjustment--;
6056 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6061 assert(NewParm->isParameterPack() &&
6075 OutParamTypes.push_back(NewParm->getType());
6077 PVars->push_back(NewParm);
6091 QualType Pattern = Expansion->getPattern();
6115 if (NewType->containsUnexpandedParameterPack()) {
6127 PVars->push_back(nullptr);
6135 // forgetting the partially-substituted parameter pack.
6146 PVars->push_back(nullptr);
6151 OldType = Expansion->getPattern();
6153 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6170 PVars->push_back(nullptr);
6175 for (unsigned i = 0, e = PVars->size(); i != e; ++i)
6177 assert(parm->getFunctionScopeIndex() == i);
6186 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
6190 TLB, TL, nullptr, Qualifiers(),
6199 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
6216 if (T->hasTrailingReturn()) {
6219 TL.getTypePtr()->param_type_begin(),
6220 T->getExtParameterInfosOrNull(),
6228 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
6229 // and the end of the function-definition, member-declarator, or
6235 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
6241 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
6247 TL.getTypePtr()->param_type_begin(),
6248 T->getExtParameterInfosOrNull(),
6253 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
6293 // The condition expression has been transformed, and re-evaluated.
6314 NewFX->insert(NewEC, Errs);
6323 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
6324 T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) {
6330 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result);
6354 SemaRef, Method ? Method->getParent() : nullptr,
6355 Method ? Method->getMethodQualifiers() : Qualifiers{},
6381 T->getAs<PackExpansionType>()) {
6386 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
6395 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
6407 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6408 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6422 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6447 TypeLocBuilder &TLB,
6450 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
6455 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
6458 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result);
6469 TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
6471 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
6476 if (getDerived().AlwaysRebuild() || D != T->getDecl()) {
6484 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result);
6491 QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
6496 TL.getLocalSourceRange().getBegin(), T->getFoundDecl()));
6500 QualType Underlying = getDerived().TransformType(T->desugar());
6505 if (getDerived().AlwaysRebuild() || Found != T->getFoundDecl() ||
6506 Underlying != T->getUnderlyingType()) {
6512 TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc());
6517 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
6522 T->getDecl()));
6528 Typedef != T->getDecl()) {
6534 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result);
6541 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
6557 TypeOfKind Kind = Result->castAs<TypeOfExprType>()->getKind();
6565 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result);
6574 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
6582 TypeOfKind Kind = Result->castAs<TypeOfType>()->getKind();
6584 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
6589 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result);
6599 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
6608 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
6618 E.get() != T->getUnderlyingExpr()) {
6625 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
6633 TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,
6643 llvm::ArrayRef<QualType> Types = PIT->getExpansions();
6652 if (!T->containsUnexpandedParameterPack()) {
6674 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6679 QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc());
6690 PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(Out);
6705 // forgetting the partially-substituted parameter pack.
6719 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
6720 QualType Result = getDerived().TransformType(TLB, TL.getPatternLoc());
6728 PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(Out);
6735 TypeLocBuilder &TLB,
6738 if (Result->isDependentType()) {
6745 QualType NewBase = NewBaseTSI->getType();
6748 T->getUTTKind(),
6754 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
6763 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
6768 SS, T->getTemplateName(), TL.getTemplateNameLoc());
6772 QualType OldDeduced = T->getDeducedType();
6786 TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
6793 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
6798 T->getDecl()));
6804 Record != T->getDecl()) {
6810 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result);
6817 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
6822 T->getDecl()));
6828 Enum != T->getDecl()) {
6834 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result);
6842 TypeLocBuilder &TLB,
6845 TL.getTypePtr()->getDecl());
6849 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc());
6855 TypeLocBuilder &TLB,
6858 TLB, TL,
6864 TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) {
6865 return TransformTypeSpecType(TLB, TL);
6870 TypeLocBuilder &TLB,
6875 getDerived().TransformDecl(TL.getNameLoc(), T->getAssociatedDecl());
6881 QualType Replacement = getDerived().TransformType(T->getReplacementType());
6886 Replacement, NewReplaced, T->getIndex(), T->getPackIndex());
6888 // Propagate type-source information.
6890 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
6898 TypeLocBuilder &TLB,
6901 TLB, TL, /*SuppressObjCLifetime=*/false);
6906 TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) {
6907 return TransformTypeSpecType(TLB, TL);
6912 TypeLocBuilder &TLB,
6916 // The nested-name-specifier never matters in a TemplateSpecializationType,
6917 // because we can't have a dependent nested-name-specifier anyway.
6920 = getDerived().TransformTemplateName(SS, T->getTemplateName(),
6925 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template);
6929 QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
6931 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
6943 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result);
6952 QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
6954 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
6960 const PipeType *PT = Result->castAs<PipeType>();
6961 bool isReadPipe = PT->isReadOnly();
6967 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(Result);
6974 QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
6980 Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
6981 EIT->getNumBits(), TL.getNameLoc());
6986 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
6993 TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
6998 ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
7006 if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
7008 EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());
7015 DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(Result);
7018 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result);
7046 const TemplateArgumentLoc *operator->() const {
7070 return Container->getArgLoc(Index);
7073 pointer operator->() const {
7074 return pointer(Container->getArgLoc(Index));
7089 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
7092 QualType OldDeduced = T->getDeducedType();
7103 if (T->isConstrained()) {
7106 TL.getConceptNameLoc(), T->getTypeConstraintConcept()));
7127 T->isDependentType() || T->isConstrained()) {
7133 Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
7139 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
7144 if (T->isConstrained()) {
7146 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(),
7148 TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());
7151 TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(),
7161 TypeLocBuilder &TLB,
7188 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
7201 = TLB.push<TemplateSpecializationTypeLoc>(Result);
7215 TypeLocBuilder &TLB,
7233 TL.getTypePtr()->getKeyword(), DTN->getQualifier(),
7234 DTN->getIdentifier(), NewTemplateArgs.arguments());
7237 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
7255 /// FIXME: Wrap this in an elaborated-type-specifier?
7257 = TLB.push<TemplateSpecializationTypeLoc>(Result);
7271 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
7284 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
7289 // If the identifier resolves to a typedef-name or the simple-template-id
7291 // elaborated-type-specifier is ill-formed.
7292 if (T->getKeyword() != ElaboratedTypeKeyword::None &&
7293 T->getKeyword() != ElaboratedTypeKeyword::Typename) {
7295 NamedT->getAs<TemplateSpecializationType>()) {
7296 TemplateName Template = TST->getTemplateName();
7303 ElaboratedType::getTagTypeKindForKeyword(T->getKeyword()));
7304 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at);
7312 NamedT != T->getNamedType()) {
7314 T->getKeyword(),
7320 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
7329 TypeLocBuilder &TLB, AttributedTypeLoc TL, Fn TransformModifiedTypeFn) {
7331 QualType modifiedType = TransformModifiedTypeFn(TLB, TL.getModifiedLoc());
7345 modifiedType != oldType->getModifiedType()) {
7355 if (auto nullability = oldType->getImmediateNullability()) {
7356 if (!modifiedType->canHaveNullability()) {
7357 SemaRef.Diag((TL.getAttr() ? TL.getAttr()->getLocation()
7370 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result);
7376 QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB,
7379 TLB, TL, [&](TypeLocBuilder &TLB, TypeLoc ModifiedLoc) -> QualType {
7380 return getDerived().TransformType(TLB, ModifiedLoc);
7386 TypeLocBuilder &TLB, CountAttributedTypeLoc TL) {
7388 QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());
7402 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() ||
7406 InnerTy, NewCount, OldTy->isCountInBytes(), OldTy->isOrNull());
7409 TLB.push<CountAttributedTypeLoc>(Result);
7415 TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
7422 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
7424 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7436 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
7444 TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
7446 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
7458 MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(Result);
7465 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
7466 return TransformDependentNameType(TLB, TL, false);
7471 TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext) {
7480 = getDerived().RebuildDependentNameType(T->getKeyword(),
7483 T->getIdentifier(),
7489 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) {
7490 QualType NamedT = ElabT->getNamedType();
7491 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc());
7493 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
7497 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result);
7507 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
7518 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc);
7523 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
7540 T->getKeyword(), QualifierLoc, TL.getTemplateKeywordLoc(),
7541 T->getIdentifier(), TL.getTemplateNameLoc(), NewTemplateArgs,
7547 QualType NamedT = ElabT->getNamedType();
7551 = TLB.push<TemplateSpecializationTypeLoc>(NamedT);
7560 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result);
7565 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
7576 = TLB.push<TemplateSpecializationTypeLoc>(Result);
7588 QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
7591 = getDerived().TransformType(TLB, TL.getPatternLoc());
7601 TL.getTypePtr()->getNumExpansions());
7606 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result);
7613 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
7616 TLB.pushFullCopy(TL);
7622 TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
7626 getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
7632 OTP != T->getDecl()) {
7635 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7641 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(Result);
7653 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
7656 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
7666 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
7667 QualType TypeArg = TypeArgInfo->getType();
7673 ->castAs<PackExpansionType>();
7675 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
7684 std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
7694 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
7705 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
7756 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
7763 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(Result);
7778 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
7780 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
7793 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result);
7798 //===----------------------------------------------------------------------===//
7800 //===----------------------------------------------------------------------===//
7819 if (S->hasStoredFPFeatures())
7821 S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts()));
7823 const Stmt *ExprResult = S->getStmtExprResult();
7827 for (auto *B : S->body()) {
7853 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
7855 S->getRBracLoc(),
7867 // Transform the left-hand case value.
7868 LHS = getDerived().TransformExpr(S->getLHS());
7869 LHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), LHS);
7873 // Transform the right-hand case value (for the GNU case-range extension).
7874 RHS = getDerived().TransformExpr(S->getRHS());
7875 RHS = SemaRef.ActOnCaseExpr(S->getCaseLoc(), RHS);
7883 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
7885 S->getEllipsisLoc(),
7887 S->getColonLoc());
7893 getDerived().TransformStmt(S->getSubStmt());
7905 getDerived().TransformStmt(S->getSubStmt());
7910 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
7917 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
7921 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
7922 S->getDecl());
7926 // If we're transforming "in-place" (we're not creating new local
7929 if (LD == S->getDecl())
7930 S->getDecl()->setStmt(nullptr);
7933 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
7943 switch (R->getKind()) {
7960 switch (R->getKind()) {
7974 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
7982 for (const auto *I : S->getAttrs()) {
7984 getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I);
7990 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
7998 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
8006 StmtResult Init = getDerived().TransformStmt(S->getInit());
8011 if (!S->isConsteval()) {
8014 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
8015 S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
8023 if (S->isConstexpr())
8032 S->isNonNegatedConsteval());
8034 Then = getDerived().TransformStmt(S->getThen());
8042 CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc());
8051 S->isNegatedConsteval());
8053 Else = getDerived().TransformStmt(S->getElse());
8056 } else if (S->getElse() && ConstexprConditionValue &&
8062 CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc());
8066 Init.get() == S->getInit() &&
8067 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8068 Then.get() == S->getThen() &&
8069 Else.get() == S->getElse())
8073 S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
8074 S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
8081 StmtResult Init = getDerived().TransformStmt(S->getInit());
8087 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
8094 getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
8095 Init.get(), Cond, S->getRParenLoc());
8100 StmtResult Body = getDerived().TransformStmt(S->getBody());
8105 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
8114 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
8120 StmtResult Body = getDerived().TransformStmt(S->getBody());
8125 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8126 Body.get() == S->getBody())
8129 return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
8130 Cond, S->getRParenLoc(), Body.get());
8137 StmtResult Body = getDerived().TransformStmt(S->getBody());
8142 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8147 Cond.get() == S->getCond() &&
8148 Body.get() == S->getBody())
8151 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
8152 /*FIXME:*/S->getWhileLoc(), Cond.get(),
8153 S->getRParenLoc());
8163 StmtResult Init = getDerived().TransformStmt(S->getInit());
8170 getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(),
8175 S->getForLoc(), S->getConditionVariable(), S->getCond(),
8181 ExprResult Inc = getDerived().TransformExpr(S->getInc());
8186 if (S->getInc() && !FullInc.get())
8190 StmtResult Body = getDerived().TransformStmt(S->getBody());
8195 Init.get() == S->getInit() &&
8196 Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
8197 Inc.get() == S->getInc() &&
8198 Body.get() == S->getBody())
8201 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
8203 S->getRParenLoc(), Body.get());
8209 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
8210 S->getLabel());
8215 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
8222 ExprResult Target = getDerived().TransformExpr(S->getTarget());
8228 Target.get() == S->getTarget())
8231 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
8250 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
8257 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
8265 for (auto *D : S->decls()) {
8266 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
8279 return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
8296 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
8297 Names.push_back(S->getOutputIdentifier(I));
8300 Constraints.push_back(S->getOutputConstraintLiteral(I));
8303 Expr *OutputExpr = S->getOutputExpr(I);
8314 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
8315 Names.push_back(S->getInputIdentifier(I));
8318 Constraints.push_back(S->getInputConstraintLiteral(I));
8321 Expr *InputExpr = S->getInputExpr(I);
8332 for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
8333 Names.push_back(S->getLabelIdentifier(I));
8335 ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(I));
8338 ExprsChanged |= Result.get() != S->getLabelExpr(I);
8345 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I)
8346 Clobbers.push_back(S->getClobberStringLiteral(I));
8349 AsmString = S->getAsmString();
8350 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
8351 S->isVolatile(), S->getNumOutputs(),
8352 S->getNumInputs(), Names.data(),
8354 Clobbers, S->getNumLabels(),
8355 S->getRParenLoc());
8361 ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks());
8365 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
8382 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
8383 AsmToks, S->getAsmString(),
8384 S->getNumOutputs(), S->getNumInputs(),
8385 S->getAllConstraints(), S->getClobbers(),
8386 TransformedExprs, S->getEndLoc());
8395 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
8396 ScopeInfo->NeedsCoroutineSuspends &&
8397 ScopeInfo->CoroutineSuspends.first == nullptr &&
8398 ScopeInfo->CoroutineSuspends.second == nullptr &&
8401 // Set that we have (possibly-invalid) suspend points before we do anything
8403 ScopeInfo->setNeedsCoroutineSuspends(false);
8405 // We re-build the coroutine promise object (and the coroutine parameters its
8411 if (!SemaRef.buildCoroutineParameterMoves(FD->getLocation()))
8413 auto *Promise = SemaRef.buildCoroutinePromise(FD->getLocation());
8416 getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
8417 ScopeInfo->CoroutinePromise = Promise;
8422 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
8426 getDerived().TransformStmt(S->getFinalSuspendStmt());
8430 ScopeInfo->setCoroutineSuspends(InitSuspend.get(), FinalSuspend.get());
8433 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
8441 Expr *ReturnObject = S->getReturnValueInit();
8452 if (S->hasDependentPromiseType()) {
8455 if (!Promise->getType()->isDependentType()) {
8456 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
8457 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
8463 if (auto *OnFallthrough = S->getFallthroughHandler()) {
8470 if (auto *OnException = S->getExceptionHandler()) {
8477 if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
8485 assert(S->getAllocate() && S->getDeallocate() &&
8487 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
8492 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
8497 if (auto *ResultDecl = S->getResultDecl()) {
8504 if (auto *ReturnStmt = S->getReturnStmt()) {
8518 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
8525 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
8526 S->isImplicit());
8531 ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
8536 // Rebuild the common-expr from the operand rather than transforming it
8543 getSema().getCurScope(), E->getKeywordLoc());
8548 E->getKeywordLoc(), Operand.get(),
8549 cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit());
8555 ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
8561 E->getOperatorCoawaitLookup());
8569 E->getKeywordLoc(), OperandResult.get(),
8576 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
8583 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
8586 // Objective-C Statements.
8592 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
8599 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
8600 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
8603 if (Catch.get() != S->getCatchStmt(I))
8610 if (S->getFinallyStmt()) {
8611 Finally = getDerived().TransformStmt(S->getFinallyStmt());
8618 TryBody.get() == S->getTryBody() &&
8620 Finally.get() == S->getFinallyStmt())
8624 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
8633 if (VarDecl *FromVar = S->getCatchParamDecl()) {
8635 if (FromVar->getTypeSourceInfo()) {
8636 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
8643 T = TSInfo->getType();
8645 T = getDerived().TransformType(FromVar->getType());
8655 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
8659 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
8660 S->getRParenLoc(),
8668 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
8674 Body.get() == S->getFinallyBody())
8678 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
8686 if (S->getThrowExpr()) {
8687 Operand = getDerived().TransformExpr(S->getThrowExpr());
8693 Operand.get() == S->getThrowExpr())
8696 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
8704 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
8708 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
8714 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
8720 Object.get() == S->getSynchExpr() &&
8721 Body.get() == S->getSynchBody())
8725 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
8734 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
8740 Body.get() == S->getSubStmt())
8745 S->getAtLoc(), Body.get());
8754 getDerived().TransformStmt(S->getElement(), SDK_NotDiscarded);
8759 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
8764 StmtResult Body = getDerived().TransformStmt(S->getBody());
8770 Element.get() == S->getElement() &&
8771 Collection.get() == S->getCollection() &&
8772 Body.get() == S->getBody())
8776 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
8779 S->getRParenLoc(),
8787 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
8789 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
8794 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
8795 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
8796 if (!Var || Var->isInvalidDecl())
8801 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
8806 Handler.get() == S->getHandlerBlock())
8809 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
8815 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
8822 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
8823 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I));
8827 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
8831 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
8835 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
8848 // P2718R0 - Lifetime extension in range-based for loops.
8854 S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
8858 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
8868 StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
8871 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
8875 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8879 Cond = SemaRef.CheckBooleanCondition(S->getColonLoc(), Cond.get());
8885 ExprResult Inc = getDerived().TransformExpr(S->getInc());
8891 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
8897 Init.get() != S->getInit() ||
8898 Range.get() != S->getRangeStmt() ||
8899 Begin.get() != S->getBeginStmt() ||
8900 End.get() != S->getEndStmt() ||
8901 Cond.get() != S->getCond() ||
8902 Inc.get() != S->getInc() ||
8903 LoopVar.get() != S->getLoopVarStmt()) {
8905 S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
8907 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
8908 if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
8911 cast<DeclStmt>(LoopVar.get())->getSingleDecl());
8916 StmtResult Body = getDerived().TransformStmt(S->getBody());
8920 // Body has changed but we didn't rebuild the for-range statement. Rebuild
8922 if (Body.get() != S->getBody() && NewStmt.get() == S) {
8924 S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
8926 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
8941 // Transform the nested-name-specifier, if any.
8943 if (S->getQualifierLoc()) {
8945 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
8951 DeclarationNameInfo NameInfo = S->getNameInfo();
8960 QualifierLoc == S->getQualifierLoc() &&
8961 NameInfo.getName() == S->getNameInfo().getName())
8970 if (S->isIfExists())
8973 return new (getSema().Context) NullStmt(S->getKeywordLoc());
8976 if (S->isIfNotExists())
8979 return new (getSema().Context) NullStmt(S->getKeywordLoc());
8990 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
8999 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
9000 S->isIfExists(),
9010 if (E->getQualifierLoc()) {
9012 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
9018 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
9022 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
9027 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
9029 QualifierLoc, E->getMemberLoc());
9035 auto BaseRes = getDerived().TransformExpr(E->getBase());
9038 auto IdxRes = getDerived().TransformExpr(E->getIdx());
9043 BaseRes.get() == E->getBase() &&
9044 IdxRes.get() == E->getIdx())
9048 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
9053 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9057 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
9061 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9062 Handler.get() == S->getHandler())
9065 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
9071 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
9075 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
9080 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
9084 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
9088 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
9106 //===----------------------------------------------------------------------===//
9108 //===----------------------------------------------------------------------===//
9116 return getDerived().TransformStmt(L->getLoopStmt());
9125 ArrayRef<OMPClause *> Clauses = D->clauses();
9130 getDerived().getSema().OpenMP().StartOpenMPClause((*I)->getClauseKind());
9140 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
9142 D->getDirectiveKind(),
9148 if (D->getDirectiveKind() == OMPD_atomic ||
9149 D->getDirectiveKind() == OMPD_critical ||
9150 D->getDirectiveKind() == OMPD_section ||
9151 D->getDirectiveKind() == OMPD_master)
9152 CS = D->getAssociatedStmt();
9154 CS = D->getRawStmt();
9156 if (Body.isUsable() && isOpenMPLoopDirective(D->getDirectiveKind()) &&
9172 if (D->getDirectiveKind() == OMPD_critical) {
9173 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName();
9177 if (D->getDirectiveKind() == OMPD_cancellation_point) {
9178 CancelRegion = cast<OMPCancellationPointDirective>(D)->getCancelRegion();
9179 } else if (D->getDirectiveKind() == OMPD_cancel) {
9180 CancelRegion = cast<OMPCancelDirective>(D)->getCancelRegion();
9184 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
9185 AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc(),
9186 D->getMappedDirective());
9193 SemaRef.Diag(D->getBeginLoc(), diag::err_omp_instantiation_not_supported)
9194 << getOpenMPDirectiveName(D->getDirectiveKind());
9203 OMPD_parallel, DirName, nullptr, D->getBeginLoc());
9214 OMPD_simd, DirName, nullptr, D->getBeginLoc());
9225 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
9236 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
9247 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
9258 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
9269 OMPD_for, DirName, nullptr, D->getBeginLoc());
9280 OMPD_for_simd, DirName, nullptr, D->getBeginLoc());
9291 OMPD_sections, DirName, nullptr, D->getBeginLoc());
9302 OMPD_section, DirName, nullptr, D->getBeginLoc());
9313 OMPD_scope, DirName, nullptr, D->getBeginLoc());
9324 OMPD_single, DirName, nullptr, D->getBeginLoc());
9335 OMPD_master, DirName, nullptr, D->getBeginLoc());
9345 OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
9356 OMPD_parallel_for, DirName, nullptr, D->getBeginLoc());
9367 OMPD_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
9378 OMPD_parallel_master, DirName, nullptr, D->getBeginLoc());
9389 OMPD_parallel_masked, DirName, nullptr, D->getBeginLoc());
9400 OMPD_parallel_sections, DirName, nullptr, D->getBeginLoc());
9411 OMPD_task, DirName, nullptr, D->getBeginLoc());
9422 OMPD_taskyield, DirName, nullptr, D->getBeginLoc());
9433 OMPD_barrier, DirName, nullptr, D->getBeginLoc());
9444 OMPD_taskwait, DirName, nullptr, D->getBeginLoc());
9455 OMPD_error, DirName, nullptr, D->getBeginLoc());
9466 OMPD_taskgroup, DirName, nullptr, D->getBeginLoc());
9477 OMPD_flush, DirName, nullptr, D->getBeginLoc());
9488 OMPD_depobj, DirName, nullptr, D->getBeginLoc());
9499 OMPD_scan, DirName, nullptr, D->getBeginLoc());
9510 OMPD_ordered, DirName, nullptr, D->getBeginLoc());
9521 OMPD_atomic, DirName, nullptr, D->getBeginLoc());
9532 OMPD_target, DirName, nullptr, D->getBeginLoc());
9543 OMPD_target_data, DirName, nullptr, D->getBeginLoc());
9554 OMPD_target_enter_data, DirName, nullptr, D->getBeginLoc());
9565 OMPD_target_exit_data, DirName, nullptr, D->getBeginLoc());
9576 OMPD_target_parallel, DirName, nullptr, D->getBeginLoc());
9587 OMPD_target_parallel_for, DirName, nullptr, D->getBeginLoc());
9598 OMPD_target_update, DirName, nullptr, D->getBeginLoc());
9609 OMPD_teams, DirName, nullptr, D->getBeginLoc());
9620 OMPD_cancellation_point, DirName, nullptr, D->getBeginLoc());
9631 OMPD_cancel, DirName, nullptr, D->getBeginLoc());
9642 OMPD_taskloop, DirName, nullptr, D->getBeginLoc());
9653 OMPD_taskloop_simd, DirName, nullptr, D->getBeginLoc());
9664 OMPD_master_taskloop, DirName, nullptr, D->getBeginLoc());
9675 OMPD_masked_taskloop, DirName, nullptr, D->getBeginLoc());
9686 OMPD_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
9697 OMPD_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
9708 OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc());
9719 OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc());
9731 OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
9743 OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
9754 OMPD_distribute, DirName, nullptr, D->getBeginLoc());
9765 OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
9777 OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
9788 OMPD_distribute_simd, DirName, nullptr, D->getBeginLoc());
9799 OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
9810 OMPD_target_simd, DirName, nullptr, D->getBeginLoc());
9821 OMPD_teams_distribute, DirName, nullptr, D->getBeginLoc());
9832 OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
9844 D->getBeginLoc());
9855 OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
9866 OMPD_target_teams, DirName, nullptr, D->getBeginLoc());
9877 OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
9890 D->getBeginLoc());
9903 D->getBeginLoc());
9915 OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
9926 OMPD_interop, DirName, nullptr, D->getBeginLoc());
9937 OMPD_dispatch, DirName, nullptr, D->getBeginLoc());
9948 OMPD_masked, DirName, nullptr, D->getBeginLoc());
9959 OMPD_loop, DirName, nullptr, D->getBeginLoc());
9970 OMPD_teams_loop, DirName, nullptr, D->getBeginLoc());
9981 OMPD_target_teams_loop, DirName, nullptr, D->getBeginLoc());
9992 OMPD_parallel_loop, DirName, nullptr, D->getBeginLoc());
10004 OMPD_target_parallel_loop, DirName, nullptr, D->getBeginLoc());
10010 //===----------------------------------------------------------------------===//
10012 //===----------------------------------------------------------------------===//
10015 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
10019 C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
10020 C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
10025 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
10028 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
10029 C->getLParenLoc(), C->getEndLoc());
10035 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads());
10039 NumThreads.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10045 ExprResult E = getDerived().TransformExpr(C->getSafelen());
10049 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10055 ExprResult E = getDerived().TransformExpr(C->getAllocator());
10059 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10065 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
10069 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10075 TransformedSizes.reserve(C->getNumSizes());
10077 for (Expr *E : C->getSizesRefs()) {
10093 return RebuildOMPSizesClause(TransformedSizes, C->getBeginLoc(),
10094 C->getLParenLoc(), C->getEndLoc());
10101 return RebuildOMPFullClause(C->getBeginLoc(), C->getEndLoc());
10107 ExprResult T = getDerived().TransformExpr(C->getFactor());
10111 bool Changed = Factor != C->getFactor();
10115 return RebuildOMPPartialClause(Factor, C->getBeginLoc(), C->getLParenLoc(),
10116 C->getEndLoc());
10122 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
10126 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10133 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getBeginLoc(),
10134 C->getLParenLoc(), C->getEndLoc());
10141 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
10142 C->getLParenLoc(), C->getEndLoc());
10148 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
10152 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
10153 C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
10154 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
10155 C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
10162 if (auto *Num = C->getNumForLoops()) {
10167 return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
10168 C->getLParenLoc(), E.get());
10175 if (Expr *Evt = C->getEventHandler()) {
10180 return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
10181 C->getLParenLoc(), C->getEndLoc());
10187 // No need to rebuild this clause, no template-dependent parameters.
10194 // No need to rebuild this clause, no template-dependent parameters.
10201 // No need to rebuild this clause, no template-dependent parameters.
10207 // No need to rebuild this clause, no template-dependent parameters.
10213 // No need to rebuild this clause, no template-dependent parameters.
10220 // No need to rebuild this clause, no template-dependent parameters.
10227 // No need to rebuild this clause, no template-dependent parameters.
10234 // No need to rebuild this clause, no template-dependent parameters.
10240 // No need to rebuild this clause, no template-dependent parameters.
10247 // No need to rebuild this clause, no template-dependent parameters.
10254 // No need to rebuild this clause, no template-dependent parameters.
10261 // No need to rebuild this clause, no template-dependent parameters.
10268 // No need to rebuild this clause, no template-dependent parameters.
10275 // No need to rebuild this clause, no template-dependent parameters.
10281 // No need to rebuild this clause, no template-dependent parameters.
10288 // No need to rebuild this clause, no template-dependent parameters.
10294 // No need to rebuild this clause, no template-dependent parameters.
10301 // No need to rebuild this clause, no template-dependent parameters.
10307 ExprResult IVR = getDerived().TransformExpr(C->getInteropVar());
10311 OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync());
10312 InteropInfo.PreferTypes.reserve(C->varlist_size() - 1);
10313 for (Expr *E : llvm::drop_begin(C->varlists())) {
10320 C->getBeginLoc(), C->getLParenLoc(),
10321 C->getVarLoc(), C->getEndLoc());
10326 ExprResult ER = getDerived().TransformExpr(C->getInteropVar());
10329 return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(),
10330 C->getLParenLoc(), C->getVarLoc(),
10331 C->getEndLoc());
10338 if (Expr *IV = C->getInteropVar()) {
10343 return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(),
10344 C->getLParenLoc(), C->getVarLoc(),
10345 C->getEndLoc());
10351 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
10355 Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10361 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
10365 Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10371 ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
10374 return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
10375 C->getLParenLoc(), C->getEndLoc());
10380 ExprResult E = getDerived().TransformExpr(C->getAlignment());
10383 return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(),
10384 C->getLParenLoc(), C->getEndLoc());
10422 return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(),
10423 C->getBeginLoc(), C->getLParenLoc(),
10424 C->getEndLoc());
10431 C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(),
10432 C->getLParenLoc(), C->getEndLoc());
10438 ExprResult E = getDerived().TransformExpr(C->getMessageString());
10442 C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(),
10443 C->getEndLoc());
10450 Vars.reserve(C->varlist_size());
10451 for (auto *VE : C->varlists()) {
10458 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10465 Vars.reserve(C->varlist_size());
10466 for (auto *VE : C->varlists()) {
10473 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10480 Vars.reserve(C->varlist_size());
10481 for (auto *VE : C->varlists()) {
10488 Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
10489 C->getLParenLoc(), C->getEndLoc());
10496 Vars.reserve(C->varlist_size());
10497 for (auto *VE : C->varlists()) {
10503 return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
10504 C->getLParenLoc(), C->getEndLoc());
10511 Vars.reserve(C->varlist_size());
10512 for (auto *VE : C->varlists()) {
10519 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
10521 DeclarationNameInfo NameInfo = C->getNameInfo();
10530 for (auto *E : C->reduction_ops()) {
10535 for (auto *D : ULE->decls()) {
10537 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
10538 Decls.addDecl(InstD, InstD->getAccess());
10549 Vars, C->getModifier(), C->getBeginLoc(), C->getLParenLoc(),
10550 C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(),
10558 Vars.reserve(C->varlist_size());
10559 for (auto *VE : C->varlists()) {
10566 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
10568 DeclarationNameInfo NameInfo = C->getNameInfo();
10577 for (auto *E : C->reduction_ops()) {
10582 for (auto *D : ULE->decls()) {
10584 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
10585 Decls.addDecl(InstD, InstD->getAccess());
10596 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
10597 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10604 Vars.reserve(C->varlist_size());
10605 for (auto *VE : C->varlists()) {
10612 ReductionIdScopeSpec.Adopt(C->getQualifierLoc());
10614 DeclarationNameInfo NameInfo = C->getNameInfo();
10623 for (auto *E : C->reduction_ops()) {
10628 for (auto *D : ULE->decls()) {
10630 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
10631 Decls.addDecl(InstD, InstD->getAccess());
10642 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
10643 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
10650 Vars.reserve(C->varlist_size());
10651 for (auto *VE : C->varlists()) {
10657 ExprResult Step = getDerived().TransformExpr(C->getStep());
10661 Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
10662 C->getModifierLoc(), C->getColonLoc(), C->getStepModifierLoc(),
10663 C->getEndLoc());
10670 Vars.reserve(C->varlist_size());
10671 for (auto *VE : C->varlists()) {
10677 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
10681 Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
10682 C->getColonLoc(), C->getEndLoc());
10689 Vars.reserve(C->varlist_size());
10690 for (auto *VE : C->varlists()) {
10696 return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
10697 C->getLParenLoc(), C->getEndLoc());
10704 Vars.reserve(C->varlist_size());
10705 for (auto *VE : C->varlists()) {
10712 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10718 Vars.reserve(C->varlist_size());
10719 for (auto *VE : C->varlists()) {
10725 return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
10726 C->getLParenLoc(), C->getEndLoc());
10732 ExprResult E = getDerived().TransformExpr(C->getDepobj());
10735 return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(),
10736 C->getLParenLoc(), C->getEndLoc());
10743 Expr *DepModifier = C->getModifier();
10750 Vars.reserve(C->varlist_size());
10751 for (auto *VE : C->varlists()) {
10758 {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(),
10759 C->getOmpAllMemoryLoc()},
10760 DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10766 ExprResult E = getDerived().TransformExpr(C->getDevice());
10770 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
10771 C->getModifierLoc(), C->getEndLoc());
10781 Vars.reserve(C->varlist_size());
10782 for (auto *VE : C->varlists()) {
10790 if (C->getMapperQualifierLoc()) {
10792 C->getMapperQualifierLoc());
10797 MapperIdInfo = C->getMapperIdInfo();
10804 // the previous user-defined mapper lookup in dependent environment.
10805 for (auto *E : C->mapperlists()) {
10810 for (auto *D : ULE->decls()) {
10812 cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
10813 Decls.addDecl(InstD, InstD->getAccess());
10829 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10831 Expr *IteratorModifier = C->getIteratorModifier();
10845 IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(),
10846 MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(),
10847 C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10853 Expr *Allocator = C->getAllocator();
10861 Vars.reserve(C->varlist_size());
10862 for (auto *VE : C->varlists()) {
10869 Allocator, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
10870 C->getEndLoc());
10876 ExprResult E = getDerived().TransformExpr(C->getNumTeams());
10880 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10886 ExprResult E = getDerived().TransformExpr(C->getThreadLimit());
10890 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10896 ExprResult E = getDerived().TransformExpr(C->getPriority());
10900 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10906 ExprResult E = getDerived().TransformExpr(C->getGrainsize());
10910 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
10911 C->getModifierLoc(), C->getEndLoc());
10917 ExprResult E = getDerived().TransformExpr(C->getNumTasks());
10921 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
10922 C->getModifierLoc(), C->getEndLoc());
10927 ExprResult E = getDerived().TransformExpr(C->getHint());
10930 return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
10931 C->getLParenLoc(), C->getEndLoc());
10937 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
10941 C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
10942 C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
10949 // defaultmap(none:variable-category) after template initialization.
10950 return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(),
10951 C->getDefaultmapKind(),
10952 C->getBeginLoc(),
10953 C->getLParenLoc(),
10954 C->getDefaultmapModifierLoc(),
10955 C->getDefaultmapKindLoc(),
10956 C->getEndLoc());
10961 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10970 C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
10971 MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10976 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
10985 C->getMotionModifiers(), C->getMotionModifiersLoc(), MapperIdScopeSpec,
10986 MapperIdInfo, C->getColonLoc(), Vars, Locs, UnresolvedMappers);
10993 Vars.reserve(C->varlist_size());
10994 for (auto *VE : C->varlists()) {
11000 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11008 Vars.reserve(C->varlist_size());
11009 for (auto *VE : C->varlists()) {
11015 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11023 Vars.reserve(C->varlist_size());
11024 for (auto *VE : C->varlists()) {
11030 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11038 Vars.reserve(C->varlist_size());
11039 for (auto *VE : C->varlists()) {
11045 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11053 Vars.reserve(C->varlist_size());
11054 for (auto *VE : C->varlists()) {
11061 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11068 Vars.reserve(C->varlist_size());
11069 for (auto *VE : C->varlists()) {
11076 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11083 Vars.reserve(C->varlist_size());
11084 for (auto *VE : C->varlists()) {
11091 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11098 Data.reserve(C->getNumberOfAllocators());
11099 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
11100 OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
11117 Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11124 Locators.reserve(C->varlist_size());
11126 if (Expr *Modifier = C->getModifier()) {
11131 for (Expr *E : C->varlists()) {
11138 C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(),
11145 C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(),
11146 C->getEndLoc(), C->getModifier(), C->getModifierKwLoc());
11152 C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(),
11153 C->getLParenLoc(), C->getEndLoc());
11159 ExprResult Size = getDerived().TransformExpr(C->getSize());
11163 Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11170 Vars.reserve(C->varlist_size());
11171 for (auto *VE : C->varlists()) {
11178 C->getDependenceType(), C->getDependenceLoc(), C->getColonLoc(), Vars,
11179 C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11186 for (auto *A : C->getAttrs())
11189 NewAttrs, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11194 return getDerived().RebuildOMPXBareClause(C->getBeginLoc(), C->getEndLoc());
11197 //===----------------------------------------------------------------------===//
11199 //===----------------------------------------------------------------------===//
11256 Cond->getExprLoc(), /*Var=*/nullptr, Cond, Sema::ConditionKind::Boolean);
11276 Self.TransformCondition(Cond->getExprLoc(), /*Var=*/nullptr, Cond,
11628 DirKind, OldClause->getClauseKind(), OldClause->getBeginLoc());
11629 ParsedClause.setEndLoc(OldClause->getEndLoc());
11632 ParsedClause.setLParenLoc(WithParms->getLParenLoc());
11657 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
11659 if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(),
11660 C->getBeginLoc()))
11664 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
11665 C->clauses());
11668 C->getDirectiveKind());
11669 StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock());
11671 C->getBeginLoc(), C->getDirectiveKind(), StrBlock);
11674 C->getDirectiveKind(), C->getBeginLoc(), C->getDirectiveLoc(),
11675 C->getEndLoc(), TransformedClauses, StrBlock);
11682 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
11684 if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(),
11685 C->getBeginLoc()))
11689 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
11690 C->clauses());
11694 C->getDirectiveKind());
11695 StmtResult Loop = getDerived().TransformStmt(C->getLoop());
11696 Loop = getSema().OpenACC().ActOnAssociatedStmt(C->getBeginLoc(),
11697 C->getDirectiveKind(), Loop);
11700 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
11704 //===----------------------------------------------------------------------===//
11706 //===----------------------------------------------------------------------===//
11710 return TransformExpr(E->getSubExpr());
11716 if (!E->isTypeDependent())
11719 TypeSourceInfo *NewT = getDerived().TransformType(E->getTypeSourceInfo());
11724 if (!getDerived().AlwaysRebuild() && E->getTypeSourceInfo() == NewT)
11728 E->getLocation(), E->getLParenLocation(), E->getRParenLocation(), NewT);
11734 if (!E->isTypeDependent())
11737 return getDerived().RebuildPredefinedExpr(E->getLocation(),
11738 E->getIdentKind());
11745 if (E->getQualifierLoc()) {
11747 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
11753 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
11754 E->getDecl()));
11759 if (E->getFoundDecl() != E->getDecl()) {
11761 getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
11766 DeclarationNameInfo NameInfo = E->getNameInfo();
11774 !E->isCapturedByCopyInLambdaWithExplicitObjectParameter() &&
11775 QualifierLoc == E->getQualifierLoc() && ND == E->getDecl() &&
11776 Found == E->getFoundDecl() &&
11777 NameInfo.getName() == E->getDecl()->getDeclName() &&
11778 !E->hasExplicitTemplateArgs()) {
11781 // FIXME: this is a bit instantiation-specific.
11788 if (E->hasExplicitTemplateArgs()) {
11790 TransArgs.setLAngleLoc(E->getLAngleLoc());
11791 TransArgs.setRAngleLoc(E->getRAngleLoc());
11792 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
11793 E->getNumTemplateArgs(),
11849 if (E->isExprPredicate())
11850 ControllingExpr = getDerived().TransformExpr(E->getControllingExpr());
11852 ControllingType = getDerived().TransformType(E->getControllingType());
11859 for (const GenericSelectionExpr::Association Assoc : E->associations()) {
11878 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
11879 E->getDefaultLoc(),
11880 E->getRParenLoc(),
11885 E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(),
11892 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
11896 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
11899 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
11900 E->getRParen());
11903 /// The operand of a unary address-of operator has special rules: it's
11904 /// allowed to refer to a non-static member of a class even if there's no 'this'
11923 if (E->getOpcode() == UO_AddrOf)
11924 SubExpr = TransformAddressOfOperand(E->getSubExpr());
11926 SubExpr = TransformExpr(E->getSubExpr());
11930 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
11933 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
11934 E->getOpcode(),
11942 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
11948 // FIXME: It would be slightly more efficient in the non-dependent case to
11955 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
11956 const OffsetOfNode &ON = E->getComponent(I);
11963 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
11993 Type == E->getTypeSourceInfo() &&
11998 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type,
11999 Components, E->getRParenLoc());
12005 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
12020 for (Expr *C : E->subExpressions()) {
12030 return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
12031 Children, E->getType());
12038 // opaque-value expressions in it, so strip those away and rebuild
12047 // If that gives us a pseudo-object result back, the pseudo-object
12048 // expression must have been an lvalue-to-rvalue conversion which we
12050 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject))
12060 if (E->isArgumentType()) {
12061 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
12070 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
12071 E->getKind(),
12072 E->getSourceRange());
12086 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr());
12088 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr)
12092 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
12096 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
12100 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
12104 E->getOperatorLoc(),
12105 E->getKind(),
12106 E->getSourceRange());
12112 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
12116 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
12122 LHS.get() == E->getLHS() &&
12123 RHS.get() == E->getRHS())
12128 /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
12134 ExprResult Base = getDerived().TransformExpr(E->getBase());
12138 ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
12142 ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx());
12146 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
12147 RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx())
12151 Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc());
12157 ExprResult Base = getDerived().TransformExpr(E->getBase());
12162 if (E->getLowerBound()) {
12163 LowerBound = getDerived().TransformExpr(E->getLowerBound());
12169 if (E->getLength()) {
12170 Length = getDerived().TransformExpr(E->getLength());
12176 if (E->isOMPArraySection()) {
12177 if (Expr *Str = E->getStride()) {
12184 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
12185 LowerBound.get() == E->getLowerBound() &&
12186 Length.get() == E->getLength() &&
12187 (E->isOpenACCArraySection() || Stride.get() == E->getStride()))
12191 E->isOMPArraySection(), Base.get(), E->getBase()->getEndLoc(),
12192 LowerBound.get(), E->getColonLocFirst(),
12193 E->isOMPArraySection() ? E->getColonLocSecond() : SourceLocation{},
12194 Length.get(), Stride.get(), E->getRBracketLoc());
12200 ExprResult Base = getDerived().TransformExpr(E->getBase());
12206 for (Expr *Dim : E->getDimensions()) {
12217 return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
12218 E->getRParenLoc(), Dims,
12219 E->getBracketsRanges());
12225 unsigned NumIterators = E->numOfIterators();
12231 auto *D = cast<VarDecl>(E->getIteratorDecl(I));
12232 Data[I].DeclIdent = D->getIdentifier();
12233 Data[I].DeclIdentLoc = D->getLocation();
12234 if (D->getLocation() == D->getBeginLoc()) {
12235 assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) &&
12238 TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo());
12239 QualType DeclTy = getDerived().TransformType(D->getType());
12242 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
12247 !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() &&
12255 Data[I].AssignLoc = E->getAssignLoc(I);
12256 Data[I].ColonLoc = E->getColonLoc(I);
12257 Data[I].SecColonLoc = E->getSecondColonLoc(I);
12260 (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() !=
12261 D->getType().getTypePtrOrNull()) ||
12271 E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data);
12276 getDerived().transformedLocalDecl(E->getIteratorDecl(I),
12277 IE->getIteratorDecl(I));
12285 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
12292 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
12297 Callee.get() == E->getCallee() &&
12303 = ((Expr *)Callee.get())->getSourceRange().getBegin();
12306 if (E->hasStoredFPFeatures()) {
12307 FPOptionsOverride NewOverrides = E->getFPFeatures();
12315 E->getRParenLoc());
12321 ExprResult Base = getDerived().TransformExpr(E->getBase());
12326 if (E->hasQualifier()) {
12328 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
12333 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
12336 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
12337 E->getMemberDecl()));
12341 NamedDecl *FoundDecl = E->getFoundDecl();
12342 if (FoundDecl == E->getMemberDecl()) {
12346 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
12352 Base.get() == E->getBase() &&
12353 QualifierLoc == E->getQualifierLoc() &&
12354 Member == E->getMemberDecl() &&
12355 FoundDecl == E->getFoundDecl() &&
12356 !E->hasExplicitTemplateArgs()) {
12358 // Skip for member expression of (this->f), rebuilt thisi->f is needed
12360 if (!(isa<CXXThisExpr>(E->getBase()) &&
12364 // FIXME: this is a bit instantiation-specific.
12371 if (E->hasExplicitTemplateArgs()) {
12372 TransArgs.setLAngleLoc(E->getLAngleLoc());
12373 TransArgs.setRAngleLoc(E->getRAngleLoc());
12374 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
12375 E->getNumTemplateArgs(),
12382 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd());
12385 // first-qualifier-in-scope here, just in case we had a dependent
12387 // nested-name-qualifier (and therefore could do the lookup).
12389 DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
12397 E->isArrow(),
12403 (E->hasExplicitTemplateArgs()
12411 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
12416 getDerived().TransformInitializer(E->getRHS(), /*NotCopyInit=*/false);
12421 LHS.get() == E->getLHS() &&
12422 RHS.get() == E->getRHS())
12425 if (E->isCompoundAssignmentOp())
12428 E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
12430 FPOptionsOverride NewOverrides(E->getFPFeatures());
12434 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
12441 CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();
12451 // Extract the already-resolved callee declarations so that we can restrict
12455 Expr *PossibleBinOps[] = {E->getSemanticForm(),
12458 auto *Op = dyn_cast<CXXOperatorCallExpr>(PossibleBinOp->IgnoreImplicit());
12461 auto *Callee = dyn_cast<DeclRefExpr>(Op->getCallee()->IgnoreImplicit());
12462 if (!Callee || isa<CXXMethodDecl>(Callee->getDecl()))
12468 E->getOperatorLoc(), Callee->getFoundDecl()));
12471 if (Found != Callee->getFoundDecl())
12480 // function calls, and/or there might be a user-defined conversion sequence
12482 // FIXME: this is a bit instantiation-specific.
12489 E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
12497 FPOptionsOverride NewOverrides(E->getFPFeatures());
12510 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
12514 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
12519 commonExpr.get() == e->getCommon() &&
12520 rhs.get() == e->getFalseExpr())
12524 e->getQuestionLoc(),
12526 e->getColonLoc(),
12533 ExprResult Cond = getDerived().TransformExpr(E->getCond());
12537 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
12541 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
12546 Cond.get() == E->getCond() &&
12547 LHS.get() == E->getLHS() &&
12548 RHS.get() == E->getRHS())
12552 E->getQuestionLoc(),
12554 E->getColonLoc(),
12563 return getDerived().TransformExpr(E->getSubExprAsWritten());
12569 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
12574 = getDerived().TransformExpr(E->getSubExprAsWritten());
12579 Type == E->getTypeInfoAsWritten() &&
12580 SubExpr.get() == E->getSubExpr())
12583 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
12585 E->getRParenLoc(),
12592 TypeSourceInfo *OldT = E->getTypeSourceInfo();
12597 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
12603 Init.get() == E->getInitializer())
12607 // type-as-written, but that's okay, because it should always be
12611 E->getLParenLoc(), NewT,
12612 /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
12618 ExprResult Base = getDerived().TransformExpr(E->getBase());
12623 Base.get() == E->getBase())
12628 SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc());
12630 Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(),
12631 E->getAccessor());
12637 if (InitListExpr *Syntactic = E->getSyntacticForm())
12646 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
12657 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
12658 E->getRBraceLoc());
12667 ExprResult Init = getDerived().TransformExpr(E->getInit());
12674 for (const DesignatedInitExpr::Designator &D : E->designators()) {
12683 if (Field->isAnonymousStructOrUnion())
12697 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
12704 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
12711 = getDerived().TransformExpr(E->getArrayRangeStart(D));
12715 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
12722 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
12723 End.get() != E->getArrayRangeEnd(D);
12730 Init.get() == E->getInit() &&
12735 E->getEqualOrColonLoc(),
12736 E->usesGNUSyntax(), Init.get());
12776 TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());
12780 QualType T = getDerived().TransformType(E->getType());
12785 T == E->getType())
12794 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
12798 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
12803 TInfo == E->getWrittenTypeInfo() &&
12804 SubExpr.get() == E->getSubExpr())
12807 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
12808 TInfo, E->getRParenLoc());
12816 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits,
12820 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
12822 E->getRParenLoc());
12825 /// Transform an address-of-label expression.
12827 /// By default, the transformation of an address-of-label expression always
12833 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
12834 E->getLabel());
12838 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
12847 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
12853 unsigned OldDepth = E->getTemplateDepth();
12857 SubStmt.get() == E->getSubStmt()) {
12863 return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
12864 E->getRParenLoc(), NewDepth);
12870 ExprResult Cond = getDerived().TransformExpr(E->getCond());
12874 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
12878 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
12883 Cond.get() == E->getCond() &&
12884 LHS.get() == E->getLHS() &&
12885 RHS.get() == E->getRHS())
12888 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
12890 E->getRParenLoc());
12902 switch (E->getOperator()) {
12912 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
12915 ExprResult Object = getDerived().TransformExpr(E->getArg(0));
12921 static_cast<Expr *>(Object.get())->getEndLoc());
12925 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
12929 if (E->getOperator() == OO_Subscript)
12931 Args, E->getEndLoc());
12934 E->getEndLoc());
12953 if (E->getNumArgs() == 1 && E->getOperator() == OO_Amp)
12954 First = getDerived().TransformAddressOfOperand(E->getArg(0));
12956 First = getDerived().TransformExpr(E->getArg(0));
12961 if (E->getNumArgs() == 2) {
12963 getDerived().TransformInitializer(E->getArg(1), /*NotCopyInit=*/false);
12969 FPOptionsOverride NewOverrides(E->getFPFeatures());
12974 Expr *Callee = E->getCallee();
12976 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
12978 if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R))
12982 E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(),
12983 ULE->requiresADL(), R.asUnresolvedSet(), First.get(), Second.get());
12988 Callee = ICE->getSubExprAsWritten();
12989 NamedDecl *DR = cast<DeclRefExpr>(Callee)->getDecl();
12991 getDerived().TransformDecl(DR->getLocation(), DR));
12999 E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(),
13011 bool NeedRebuildFunc = SourceLocExpr::MayBeDependent(E->getIdentKind()) &&
13012 getSema().CurContext != E->getParentContext();
13017 return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(),
13018 E->getBeginLoc(), E->getEndLoc(),
13031 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
13036 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
13043 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
13048 Callee.get() == E->getCallee() &&
13054 = ((Expr *)Callee.get())->getSourceRange().getBegin();
13057 E->getRParenLoc(), EC.get());
13063 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
13068 = getDerived().TransformExpr(E->getSubExprAsWritten());
13073 Type == E->getTypeInfoAsWritten() &&
13074 SubExpr.get() == E->getSubExpr())
13077 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
13078 Type, E->getAngleBrackets().getEnd(),
13080 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
13087 getDerived().TransformType(BCE->getTypeInfoAsWritten());
13091 ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
13095 return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
13096 Sub.get(), BCE->getEndLoc());
13135 getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
13140 = getDerived().TransformExpr(E->getSubExprAsWritten());
13145 Type == E->getTypeInfoAsWritten() &&
13146 SubExpr.get() == E->getSubExpr())
13150 E->getLParenLoc(),
13152 E->getRParenLoc(),
13153 E->isListInitialization());
13159 if (E->isTypeOperand()) {
13161 = getDerived().TransformType(E->getTypeOperandSourceInfo());
13166 TInfo == E->getTypeOperandSourceInfo())
13169 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
13170 TInfo, E->getEndLoc());
13175 // semantic processing can re-transform an already transformed operand.
13176 Expr *Op = E->getExprOperand();
13178 if (E->isGLValue())
13179 if (auto *RecordT = Op->getType()->getAs<RecordType>())
13180 if (cast<CXXRecordDecl>(RecordT->getDecl())->isPolymorphic())
13191 SubExpr.get() == E->getExprOperand())
13194 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
13195 SubExpr.get(), E->getEndLoc());
13201 if (E->isTypeOperand()) {
13203 = getDerived().TransformType(E->getTypeOperandSourceInfo());
13208 TInfo == E->getTypeOperandSourceInfo())
13211 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
13212 TInfo, E->getEndLoc());
13218 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
13223 SubExpr.get() == E->getExprOperand())
13226 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
13227 SubExpr.get(), E->getEndLoc());
13258 if (E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
13261 return getDerived().TransformType(E->getType());
13265 if (!getDerived().AlwaysRebuild() && T == E->getType()) {
13267 // FIXME: this is a bit instantiation-specific.
13272 return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
13278 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
13283 SubExpr.get() == E->getSubExpr())
13286 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
13287 E->isThrownVariableInScope());
13294 getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
13299 if (E->hasRewrittenInit()) {
13300 InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
13305 if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
13306 E->getUsedContext() == SemaRef.CurContext &&
13307 InitRes.get() == E->getRewrittenExpr())
13310 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
13318 getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
13322 if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
13323 E->getUsedContext() == SemaRef.CurContext)
13326 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field);
13333 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
13338 T == E->getTypeSourceInfo())
13342 /*FIXME:*/T->getTypeLoc().getEndLoc(),
13343 E->getRParenLoc());
13351 getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
13357 if (E->isArray()) {
13359 if (std::optional<Expr *> OldArraySize = E->getArraySize()) {
13370 if (getDerived().TransformExprs(E->getPlacementArgs(),
13371 E->getNumPlacementArgs(), true,
13376 Expr *OldInit = E->getInitializer();
13385 if (E->getOperatorNew()) {
13387 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
13393 if (E->getOperatorDelete()) {
13395 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
13401 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
13402 ArraySize == E->getArraySize() &&
13404 OperatorNew == E->getOperatorNew() &&
13405 OperatorDelete == E->getOperatorDelete() &&
13408 // FIXME: instantiation-specific.
13410 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorNew);
13412 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);
13414 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
13416 = SemaRef.Context.getBaseElementType(E->getAllocatedType());
13417 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) {
13418 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl());
13420 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Destructor);
13428 QualType AllocType = AllocTypeInfo->getType();
13434 // dependently-sized array types.
13440 ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(),
13442 /*FIXME:*/ E->getBeginLoc());
13443 AllocType = ConsArrayT->getElementType();
13446 if (DepArrayT->getSizeExpr()) {
13447 ArraySize = DepArrayT->getSizeExpr();
13448 AllocType = DepArrayT->getElementType();
13454 E->getBeginLoc(), E->isGlobalNew(),
13455 /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
13456 /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
13457 AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
13463 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
13469 if (E->getOperatorDelete()) {
13471 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
13477 Operand.get() == E->getArgument() &&
13478 OperatorDelete == E->getOperatorDelete()) {
13480 // FIXME: instantiation-specific.
13482 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), OperatorDelete);
13484 if (!E->getArgument()->isTypeDependent()) {
13486 E->getDestroyedType());
13487 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
13488 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
13489 SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
13498 E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
13505 ExprResult Base = getDerived().TransformExpr(E->getBase());
13512 E->getOperatorLoc(),
13513 E->isArrow()? tok::arrow : tok::period,
13520 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
13531 if (E->getDestroyedTypeInfo()) {
13533 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(),
13538 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
13541 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
13542 E->getDestroyedTypeLoc());
13546 *E->getDestroyedTypeIdentifier(), E->getDestroyedTypeLoc(),
13553 E->getDestroyedTypeLoc());
13557 if (E->getScopeTypeInfo()) {
13560 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS);
13566 E->getOperatorLoc(),
13567 E->isArrow(),
13570 E->getColonColonLoc(),
13571 E->getTildeLoc(),
13581 for (auto *OldD : Old->decls()) {
13582 Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
13598 Decls = UPD->expansions();
13603 for (auto *SD : UD->shadows())
13614 // The program is ill-formed, no diagnostic required, if [...] lookup for
13615 // a name in the template definition found a using-declaration, but the
13617 // any declarations because the using-declaration was a pack expansion and
13620 getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
13621 << isa<UnresolvedMemberExpr>(Old) << Old->getName();
13629 if (Old->hasTemplateKeyword() && !R.empty()) {
13630 NamedDecl *FoundDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
13635 // If a 'template' keyword was used, a lookup that finds only non-template
13639 << R.getLookupName() << Old->getQualifierLoc().getSourceRange()
13640 << Old->hasTemplateKeyword() << Old->getTemplateKeywordLoc();
13641 getSema().Diag(FoundDecl->getLocation(),
13661 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
13665 if (TransformOverloadExprDecls(Old, Old->requiresADL(), R))
13668 // Rebuild the nested-name qualifier, if present.
13670 if (Old->getQualifierLoc()) {
13672 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
13679 if (Old->getNamingClass()) {
13682 Old->getNameLoc(),
13683 Old->getNamingClass()));
13693 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
13694 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
13695 if (Old->hasExplicitTemplateArgs() &&
13696 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
13697 Old->getNumTemplateArgs(),
13704 // a non-static data member is named in an unevaluated operand, or when
13711 Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr,
13716 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid())
13717 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
13719 // If we have template arguments, then rebuild the template-id expression.
13721 Old->requiresADL(), &TransArgs);
13729 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
13730 TypeSourceInfo *From = E->getArg(I);
13731 TypeLoc FromTL = From->getTypeLoc();
13733 TypeLocBuilder TLB;
13734 TLB.reserve(FromTL.getFullDataSize());
13735 QualType To = getDerived().TransformType(TLB, FromTL);
13739 if (To == From->getType())
13742 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
13761 ExpansionTL.getTypePtr()->getNumExpansions();
13774 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
13776 TypeLocBuilder TLB;
13777 TLB.reserve(From->getTypeLoc().getFullDataSize());
13779 QualType To = getDerived().TransformType(TLB, PatternTL);
13791 = TLB.push<PackExpansionTypeLoc>(To);
13793 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
13801 TypeLocBuilder TLB;
13802 TLB.reserve(PatternTL.getFullDataSize());
13803 QualType To = getDerived().TransformType(TLB, PatternTL);
13807 if (To->containsUnexpandedParameterPack()) {
13816 = TLB.push<PackExpansionTypeLoc>(To);
13820 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
13827 // forgetting the partially-substituted parameter pack.
13830 TypeLocBuilder TLB;
13831 TLB.reserve(From->getTypeLoc().getFullDataSize());
13833 QualType To = getDerived().TransformType(TLB, PatternTL);
13845 = TLB.push<PackExpansionTypeLoc>(To);
13847 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
13853 return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
13854 E->getEndLoc());
13861 const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
13862 TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
13863 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
13864 Old->NumTemplateArgs, TransArgs))
13868 E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
13869 E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
13881 // Expressions appearing within a requirement-body are unevaluated operands.
13888 E->getBody()->getBeginLoc());
13893 E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body,
13894 E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);
13898 Param->setDeclContext(Body);
13908 if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
13914 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
13915 ER->getReturnTypeRequirement()
13916 .getTypeConstraintTemplateParameterList()->getParam(0)
13917 ->setDeclContext(Body);
13923 E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams,
13924 E->getRParenLoc(), TransReqs, E->getRBraceLoc());
13951 if (Req->isSubstitutionFailure()) {
13954 Req->getSubstitutionDiagnostic());
13957 TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
13967 if (Req->isExprSubstitutionFailure())
13968 TransExpr = Req->getExprSubstitutionDiagnostic();
13970 ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
13971 if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType())
13979 const auto &RetReq = Req->getReturnTypeRequirement();
13995 return getDerived().RebuildExprRequirement(E, Req->isSimple(),
13996 Req->getNoexceptLoc(),
14000 Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
14007 if (Req->hasInvalidConstraint()) {
14010 Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction());
14014 getDerived().TransformExpr(Req->getConstraintExpr());
14023 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
14028 T == E->getQueriedTypeSourceInfo())
14035 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
14039 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression())
14043 return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
14044 SubExpr.get(), E->getEndLoc());
14054 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
14058 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
14062 return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
14063 SubExpr.get(), E->getEndLoc());
14080 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
14081 PE->getRParen());
14095 assert(E->getQualifierLoc());
14097 getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
14100 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
14102 // TODO: If this is a conversion-function-id, verify that the
14107 getDerived().TransformDeclarationNameInfo(E->getNameInfo());
14111 if (!E->hasExplicitTemplateArgs()) {
14112 if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() &&
14115 NameInfo.getName() == E->getDeclName())
14123 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
14125 E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs))
14136 // CXXConstructExprs other than for list-initialization and
14138 // a 1-argument construction we just transform that argument.
14140 ((E->getNumArgs() == 1 ||
14141 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) &&
14142 (!getDerived().DropCallArgument(E->getArg(0))) &&
14143 !E->isListInitialization()))
14144 return getDerived().TransformInitializer(E->getArg(0),
14147 TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());
14149 QualType T = getDerived().TransformType(E->getType());
14154 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
14163 E->isListInitialization());
14164 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
14170 T == E->getType() &&
14171 Constructor == E->getConstructor() &&
14174 // FIXME: Instantiation-specific
14175 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
14180 T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
14181 E->hadMultipleCandidates(), E->isListInitialization(),
14182 E->isStdInitListInitialization(), E->requiresZeroInitialization(),
14183 E->getConstructionKind(), E->getParenOrBraceRange());
14189 QualType T = getDerived().TransformType(E->getType());
14194 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
14199 T == E->getType() &&
14200 Constructor == E->getConstructor()) {
14202 // FIXME: Instantiation-specific
14203 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
14208 T, E->getLocation(), Constructor,
14209 E->constructsVBase(), E->inheritedFromVBase());
14212 /// Transform a C++ temporary-binding expression.
14219 if (auto *Dtor = E->getTemporary()->getDestructor())
14220 SemaRef.MarkFunctionReferenced(E->getBeginLoc(),
14222 return getDerived().TransformExpr(E->getSubExpr());
14233 return getDerived().TransformExpr(E->getSubExpr());
14241 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
14246 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
14252 Args.reserve(E->getNumArgs());
14256 E->isListInitialization());
14257 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
14263 T == E->getTypeSourceInfo() &&
14264 Constructor == E->getConstructor() &&
14266 // FIXME: Instantiation-specific
14267 SemaRef.MarkFunctionReferenced(E->getBeginLoc(), Constructor);
14271 // FIXME: We should just pass E->isListInitialization(), but we're not
14272 // prepared to handle list-initialization without a child InitListExpr.
14273 SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
14275 T, LParenLoc, Args, E->getEndLoc(),
14282 // Transform any init-capture expressions before entering the scope of the
14288 // Zero or more expansions of the init-capture.
14292 InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
14293 for (LambdaExpr::capture_iterator C = E->capture_begin(),
14294 CEnd = E->capture_end();
14296 if (!E->isInitCapture(C))
14299 TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
14300 auto *OldVD = cast<VarDecl>(C->getCapturedVar());
14305 OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);
14315 C->getLocation(), C->getCaptureKind() == LCK_ByRef,
14316 EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
14317 cast<VarDecl>(C->getCapturedVar())->getInitStyle() !=
14324 // If this is an init-capture pack, consider expanding the pack now.
14325 if (OldVD->isParameterPack()) {
14326 PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
14327 ->getTypeLoc()
14330 SemaRef.collectUnexpandedParameterPacks(OldVD->getInit(), Unexpanded);
14337 ExpansionTL.getTypePtr()->getNumExpansions();
14341 OldVD->getInit()->getSourceRange(), Unexpanded, Expand,
14368 // - as parameter types are not instantiated from within a function's DC. We
14390 while (DC->isRequiresExprBody())
14391 DC = DC->getParent();
14394 (DC->isFileContext() || !DC->getParent()->isDependentContext()))
14397 CXXRecordDecl *OldClass = E->getLambdaClass();
14399 E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind,
14400 E->getCaptureDefault());
14404 getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class);
14405 NewCallOperator->setLexicalDeclContext(getSema().CurContext);
14408 getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(),
14409 E->getCaptureDefault(), E->getCaptureDefaultLoc(),
14410 E->hasExplicitParameters(), E->isMutable());
14419 for (LambdaExpr::capture_iterator C = E->capture_begin(),
14420 CEnd = E->capture_end();
14424 if (C->isImplicit())
14428 if (C->capturesThis()) {
14433 // Otherwise, leave the type of 'this' as-is.
14439 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
14441 C->getCaptureKind() == LCK_StarThis);
14446 if (C->capturesVLAType())
14449 // Rebuild init-captures, including the implied field declaration.
14450 if (E->isInitCapture(C)) {
14451 TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];
14453 auto *OldVD = cast<VarDecl>(C->getCapturedVar());
14464 OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
14465 OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(),
14472 getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef);
14482 assert(C->capturesVariable() && "unexpected kind of lambda capture");
14486 = C->isImplicit()? Sema::TryCapture_Implicit
14487 : C->getCaptureKind() == LCK_ByCopy
14491 if (C->isPackExpansion()) {
14492 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
14496 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(),
14497 C->getLocation(),
14509 auto *Pack = cast<VarDecl>(C->getCapturedVar());
14513 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
14521 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
14529 EllipsisLoc = C->getEllipsisLoc();
14534 getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
14535 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
14541 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
14549 E->getTemplateParameterList());
14550 LSI->GLTemplateParameterList = TPL;
14562 E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
14565 [this](TypeLocBuilder &TLB, FunctionProtoTypeLoc FPTL) -> QualType {
14567 return this->TransformFunctionProtoType(
14568 TLB, FPTL, nullptr, Qualifiers(),
14579 NewCallOpType = this->TransformAttributedType(
14581 [&](TypeLocBuilder &TLB, TypeLoc TL) -> QualType {
14583 TLB, TL.castAs<FunctionProtoTypeLoc>());
14597 if (auto ATL = NewCallOpTSI->getTypeLoc().getAs<AttributedTypeLoc>()) {
14600 auto FPTL = NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>();
14605 NewCallOperator, E->getCallOperator()->getLocation(),
14606 E->getCallOperator()->getInnerLocStart(),
14607 E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI,
14608 E->getCallOperator()->getConstexprKind(),
14609 E->getCallOperator()->getStorageClass(), Params,
14610 E->hasExplicitResultType());
14612 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
14613 getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
14617 Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext());
14621 Numbering = OldClass->getLambdaNumbering();
14627 // FIXME: Sema's lambda-building mechanism expects us to push an expression
14630 E->getCallOperator()->isConsteval() ?
14635 E->getCallOperator()->isImmediateEscalating();
14639 C.PointOfInstantiation = E->getBody()->getBeginLoc();
14644 Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody());
14653 getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
14700 Class->setLambdaDependencyKind(DependencyKind);
14701 // Clean up the type cache created previously. Then, we re-create a type for
14703 Class->setTypeForDecl(nullptr);
14706 return getSema().BuildLambdaExpr(E->getBeginLoc(), Body.get()->getEndLoc(),
14720 for (LambdaExpr::capture_iterator C = E->capture_begin(),
14721 CEnd = E->capture_end();
14725 if (!C->isImplicit())
14729 if (C->capturesThis()) {
14730 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
14732 C->getCaptureKind() == LCK_StarThis);
14737 if (C->capturesVLAType())
14740 assert(C->capturesVariable() && "unexpected kind of lambda capture");
14741 assert(!E->isInitCapture(C) && "implicit init-capture?");
14745 getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
14746 if (!CapturedVar || CapturedVar->isInvalidDecl())
14750 getSema().tryCaptureVariable(CapturedVar, C->getLocation());
14761 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
14767 Args.reserve(E->getNumArgs());
14771 E->isListInitialization());
14772 if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args,
14778 T == E->getTypeSourceInfo() &&
14784 T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
14796 if (!E->isImplicitAccess()) {
14797 OldBase = E->getBase();
14806 E->getOperatorLoc(),
14807 E->isArrow()? tok::arrow : tok::period,
14814 BaseType = ((Expr*) Base.get())->getType();
14817 BaseType = getDerived().TransformType(E->getBaseType());
14818 ObjectType = BaseType->castAs<PointerType>()->getPointeeType();
14821 // Transform the first part of the nested-name-specifier that qualifies
14825 E->getFirstQualifierFoundInScope(),
14826 E->getQualifierLoc().getBeginLoc());
14829 if (E->getQualifier()) {
14831 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
14838 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
14840 // TODO: If this is a conversion-function-id, verify that the
14845 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
14849 if (!E->hasExplicitTemplateArgs()) {
14850 // This is a reference to a member without an explicitly-specified
14854 BaseType == E->getBaseType() &&
14855 QualifierLoc == E->getQualifierLoc() &&
14856 NameInfo.getName() == E->getMember() &&
14857 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
14862 E->isArrow(),
14863 E->getOperatorLoc(),
14871 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
14872 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
14873 E->getNumTemplateArgs(),
14879 E->isArrow(),
14880 E->getOperatorLoc(),
14894 if (!Old->isImplicitAccess()) {
14895 Base = getDerived().TransformExpr(Old->getBase());
14899 getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow());
14902 BaseType = Base.get()->getType();
14904 BaseType = getDerived().TransformType(Old->getBaseType());
14908 if (Old->getQualifierLoc()) {
14910 getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
14915 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
14917 LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName);
14924 if (Old->getNamingClass()) {
14926 getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
14934 if (Old->hasExplicitTemplateArgs()) {
14935 TransArgs.setLAngleLoc(Old->getLAngleLoc());
14936 TransArgs.setRAngleLoc(Old->getRAngleLoc());
14938 Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
14943 // first-qualifier-in-scope here, just in case we had a dependent
14945 // nested-name-qualifier (and therefore could do the lookup).
14949 Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
14951 (Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr));
14959 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
14963 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
14966 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
14972 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
14976 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
14979 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
14980 E->getNumExpansions());
14986 // If E is not value-dependent, then nothing will change when we transform it.
14987 // Note: This is an instantiation-centric view.
14988 if (!E->isValueDependent())
14998 if (E->isPartiallySubstituted()) {
14999 PackArgs = E->getPartialArguments();
15000 } else if (E->isValueDependent()) {
15001 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
15005 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(),
15014 auto *Pack = E->getPack();
15023 VD, VD->getType().getNonLValueExprType(getSema().Context),
15024 VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
15025 E->getPackLoc());
15030 E->getPackLoc(), std::nullopt);
15039 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
15043 E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(),
15067 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15089 E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
15092 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
15093 E->getPackLoc());
15095 TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
15104 // Check whether we managed to fully-expand the pack.
15116 E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
15119 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
15120 E->getPackLoc(), E->getRParenLoc(),
15127 if (!E->isValueDependent())
15131 ExprResult IndexExpr = getDerived().TransformExpr(E->getIndexExpr());
15136 if (!E->expandsToEmptyPack() && E->getExpressions().empty()) {
15137 Expr *Pattern = E->getPackIdExpression();
15139 getSema().collectUnexpandedParameterPacks(E->getPackIdExpression(),
15150 E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded,
15154 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15159 E->getEllipsisLoc(), E->getRSquareLoc(), Pack.get(), IndexExpr.get(),
15167 if (Out.get()->containsUnexpandedParameterPack()) {
15168 Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
15176 // forgetting the partially-substituted parameter pack.
15184 Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
15190 } else if (!E->expandsToEmptyPack()) {
15191 if (getDerived().TransformExprs(E->getExpressions().data(),
15192 E->getExpressions().size(), false,
15198 E->getEllipsisLoc(), E->getRSquareLoc(), E->getPackIdExpression(),
15230 return getDerived().TransformExpr(E->getSubExpr());
15237 if (Expr *OldCallee = E->getCallee()) {
15244 Expr *Pattern = E->getPattern();
15254 std::optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
15256 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(),
15257 Pattern->getSourceRange(),
15266 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15269 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
15274 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
15279 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
15283 Callee, E->getBeginLoc(), LHS.get(), E->getOperator(),
15284 E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions);
15291 SemaRef.Diag(E->getEllipsisLoc(),
15294 << E->getSourceRange();
15295 SemaRef.Diag(E->getEllipsisLoc(), diag::note_bracket_depth);
15301 ExprResult Result = getDerived().TransformExpr(E->getInit());
15304 bool LeftFold = E->isLeftFold();
15316 Callee, E->getBeginLoc(), Out.get(), E->getOperator(),
15317 E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions);
15324 getSema(), LeftFold ? I : *NumExpansions - I - 1);
15329 if (Out.get()->containsUnexpandedParameterPack()) {
15332 Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
15333 E->getOperator(), E->getEllipsisLoc(),
15334 LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
15342 Functions.append(Callee->decls_begin(), Callee->decls_end());
15344 BinaryOperator::getOverloadedOperator(E->getOperator()),
15345 E->getEllipsisLoc(), Callee->getBeginLoc(), Callee->requiresADL(),
15348 Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(),
15349 E->getOperator(), LHS, RHS);
15368 Callee, E->getBeginLoc(), Result.get(), E->getOperator(),
15369 E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions);
15377 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
15378 E->getOperator());
15387 ArrayRef<Expr *> InitExprs = E->getInitExprs();
15392 return getDerived().RebuildParenListExpr(E->getBeginLoc(), TransformedInits,
15393 E->getEndLoc());
15400 return getDerived().TransformExpr(E->getSubExpr());
15418 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
15423 SubExpr.get() == E->getSubExpr())
15426 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
15435 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
15442 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
15454 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
15455 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I);
15470 SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
15471 OrigElement.Value->getEndLoc());
15481 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
15526 if (Key.get()->containsUnexpandedParameterPack() ||
15527 Value.get()->containsUnexpandedParameterPack())
15564 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
15572 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
15577 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
15580 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
15582 E->getRParenLoc());
15592 return getDerived().TransformExpr(E->getSubExpr());
15599 = getDerived().TransformType(E->getTypeInfoAsWritten());
15603 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
15608 TSInfo == E->getTypeInfoAsWritten() &&
15609 Result.get() == E->getSubExpr())
15613 E->getLParenLoc(), E->getBridgeKind(), E->getBridgeKeywordLoc(), TSInfo,
15629 Args.reserve(E->getNumArgs());
15630 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
15634 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
15637 = getDerived().TransformType(E->getClassReceiverTypeInfo());
15643 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
15648 E->getSelectorLocs(SelLocs);
15650 E->getSelector(),
15652 E->getMethodDecl(),
15653 E->getLeftLoc(),
15655 E->getRightLoc());
15657 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
15658 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
15659 if (!E->getMethodDecl())
15664 E->getSelectorLocs(SelLocs);
15665 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
15666 E->getSelector(),
15668 E->getReceiverType(),
15669 E->getMethodDecl(),
15670 E->getLeftLoc(),
15672 E->getRightLoc());
15676 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
15679 = getDerived().TransformExpr(E->getInstanceReceiver());
15685 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
15690 E->getSelectorLocs(SelLocs);
15692 E->getSelector(),
15694 E->getMethodDecl(),
15695 E->getLeftLoc(),
15697 E->getRightLoc());
15716 ExprResult Base = getDerived().TransformExpr(E->getBase());
15724 Base.get() == E->getBase())
15727 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
15728 E->getLocation(),
15729 E->isArrow(), E->isFreeIvar());
15737 if (!E->isObjectReceiver())
15741 ExprResult Base = getDerived().TransformExpr(E->getBase());
15749 Base.get() == E->getBase())
15752 if (E->isExplicitProperty())
15754 E->getExplicitProperty(),
15755 E->getLocation());
15759 E->getImplicitPropertyGetter(),
15760 E->getImplicitPropertySetter(),
15761 E->getLocation());
15768 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
15773 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
15779 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
15782 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
15784 E->getAtIndexMethodDecl(),
15785 E->setAtIndexMethodDecl());
15792 ExprResult Base = getDerived().TransformExpr(E->getBase());
15798 Base.get() == E->getBase())
15801 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
15802 E->getOpLoc(),
15803 E->isArrow());
15811 SubExprs.reserve(E->getNumSubExprs());
15812 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
15820 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
15822 E->getRParenLoc());
15828 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
15832 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
15837 Type == E->getTypeSourceInfo() &&
15838 SrcExpr.get() == E->getSrcExpr())
15841 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
15843 E->getRParenLoc());
15849 BlockDecl *oldBlock = E->getBlockDecl();
15851 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr);
15854 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
15855 blockScope->TheDecl->setBlockMissingReturnType(
15856 oldBlock->blockMissingReturnType());
15861 const FunctionProtoType *exprFunctionType = E->getFunctionType();
15866 E->getCaretLocation(), oldBlock->parameters(), nullptr,
15867 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, ¶ms,
15869 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
15874 getDerived().TransformType(exprFunctionType->getReturnType());
15876 auto epi = exprFunctionType->getExtProtoInfo();
15881 blockScope->FunctionType = functionType;
15885 blockScope->TheDecl->setParams(params);
15887 if (!oldBlock->blockMissingReturnType()) {
15888 blockScope->HasImplicitReturnType = false;
15889 blockScope->ReturnType = exprResultType;
15893 StmtResult body = getDerived().TransformStmt(E->getBody());
15895 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
15903 for (const auto &I : oldBlock->captures()) {
15907 if (oldCapture->isParameterPack())
15911 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
15913 assert(blockScope->CaptureMap.count(newCapture));
15919 assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) &&
15924 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(),
15931 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
15935 QualType Type = getDerived().TransformType(E->getType());
15937 return SemaRef.BuildAsTypeExpr(SrcExpr.get(), Type, E->getBuiltinLoc(),
15938 E->getRParenLoc());
15946 SubExprs.reserve(E->getNumSubExprs());
15947 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
15955 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
15956 E->getOp(), E->getRParenLoc());
15959 //===----------------------------------------------------------------------===//
15961 //===----------------------------------------------------------------------===//
16048 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) {
16174 if (D->isInvalidDecl()) return QualType();
16181 if (UPD->expansions().empty()) {
16183 << UPD->isCXXClassMember() << UPD;
16192 for (auto *E : UPD->expansions()) {
16196 else if (ThisT->getAs<UnresolvedUsingType>())
16206 assert(Using->hasTypename() &&
16207 "UnresolvedUsingTypenameDecl transformed to non-typename using");
16210 assert(++Using->shadow_begin() == Using->shadow_end());
16212 UsingShadowDecl *Shadow = *Using->shadow_begin();
16213 if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), Loc))
16217 cast<TypeDecl>(Shadow->getTargetDecl())));
16220 "UnresolvedUsingTypenameDecl transformed to non-using decl");
16352 if (First->getObjectKind() == OK_ObjCProperty) {
16363 if (Second && Second->getObjectKind() == OK_ObjCProperty) {
16372 if (!First->getType()->isOverloadableType() &&
16373 !Second->getType()->isOverloadableType())
16379 if (First->getType()->isDependentType())
16381 // -> is never a builtin operation.
16384 if (!First->getType()->isOverloadableType() ||
16387 // of the form &Class::member, so try to create a built-in unary
16395 if (!First->isTypeDependent() && !Second->isTypeDependent() &&
16396 !First->getType()->isOverloadableType() &&
16397 !Second->getType()->isOverloadableType()) {
16398 // Neither of the arguments is type-dependent or has an overloadable
16399 // type, so try to create a built-in binary operation.
16438 QualType BaseType = Base->getType();
16439 if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
16440 (!isArrow && !BaseType->getAs<RecordType>()) ||
16441 (isArrow && BaseType->getAs<PointerType>() &&
16442 !BaseType->castAs<PointerType>()->getPointeeType()
16443 ->template getAs<RecordType>())){
16444 // This pseudo-destructor expression is still a pseudo-destructor.
16452 SemaRef.Context.getCanonicalType(DestroyedType->getType())));
16459 if (!ScopeType->getType()->getAs<TagType>()) {
16460 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
16462 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
16465 SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(),
16482 SourceLocation Loc = S->getBeginLoc();
16483 CapturedDecl *CD = S->getCapturedDecl();
16484 unsigned NumParams = CD->getNumParams();
16485 unsigned ContextParamPos = CD->getContextParamPosition();
16491 CD->getParam(I)->getName(),
16492 getDerived().TransformType(CD->getParam(I)->getType())));
16498 S->getCapturedRegionKind(), Params);
16502 Body = getDerived().TransformStmt(S->getCapturedStmt());