diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Sema/TreeTransform.h')
| -rw-r--r-- | contrib/llvm-project/clang/lib/Sema/TreeTransform.h | 2086 |
1 files changed, 1401 insertions, 685 deletions
diff --git a/contrib/llvm-project/clang/lib/Sema/TreeTransform.h b/contrib/llvm-project/clang/lib/Sema/TreeTransform.h index d8a5b6ad4f94..2f012cade6b9 100644 --- a/contrib/llvm-project/clang/lib/Sema/TreeTransform.h +++ b/contrib/llvm-project/clang/lib/Sema/TreeTransform.h @@ -19,8 +19,8 @@ #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" -#include "clang/AST/ExprConcepts.h" #include "clang/AST/ExprCXX.h" +#include "clang/AST/ExprConcepts.h" #include "clang/AST/ExprObjC.h" #include "clang/AST/ExprOpenMP.h" #include "clang/AST/OpenMPClause.h" @@ -31,6 +31,7 @@ #include "clang/Basic/DiagnosticParse.h" #include "clang/Basic/OpenMPKinds.h" #include "clang/Sema/Designator.h" +#include "clang/Sema/EnterExpressionEvaluationContext.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/Ownership.h" #include "clang/Sema/ParsedTemplate.h" @@ -40,6 +41,7 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/Support/ErrorHandling.h" #include <algorithm> +#include <optional> using namespace llvm::omp; @@ -161,7 +163,7 @@ public: /// Wether CXXConstructExpr can be skipped when they are implicit. /// They will be reconstructed when used if needed. - /// This is usefull when the user that cause rebuilding of the + /// This is useful when the user that cause rebuilding of the /// CXXConstructExpr is outside of the expression at which the TreeTransform /// started. bool AllowSkippingCXXConstructExpr() { return true; } @@ -279,9 +281,8 @@ public: bool TryExpandParameterPacks(SourceLocation EllipsisLoc, SourceRange PatternRange, ArrayRef<UnexpandedParameterPack> Unexpanded, - bool &ShouldExpand, - bool &RetainExpansion, - Optional<unsigned> &NumExpansions) { + bool &ShouldExpand, bool &RetainExpansion, + std::optional<unsigned> &NumExpansions) { ShouldExpand = false; return false; } @@ -377,22 +378,43 @@ public: /// By default, this routine transforms a statement by delegating to the /// appropriate TransformXXXAttr function to transform a specific kind /// of attribute. Subclasses may override this function to transform - /// attributed statements using some other mechanism. + /// attributed statements/types using some other mechanism. /// /// \returns the transformed attribute const Attr *TransformAttr(const Attr *S); -/// Transform the specified attribute. -/// -/// Subclasses should override the transformation of attributes with a pragma -/// spelling to transform expressions stored within the attribute. -/// -/// \returns the transformed attribute. -#define ATTR(X) -#define PRAGMA_SPELLING_ATTR(X) \ + // Transform the given statement attribute. + // + // Delegates to the appropriate TransformXXXAttr function to transform a + // specific kind of statement attribute. Unlike the non-statement taking + // version of this, this implements all attributes, not just pragmas. + const Attr *TransformStmtAttr(const Stmt *OrigS, const Stmt *InstS, + const Attr *A); + + // Transform the specified attribute. + // + // Subclasses should override the transformation of attributes with a pragma + // spelling to transform expressions stored within the attribute. + // + // \returns the transformed attribute. +#define ATTR(X) \ const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; } #include "clang/Basic/AttrList.inc" + // Transform the specified attribute. + // + // Subclasses should override the transformation of attributes to do + // transformation and checking of statement attributes. By default, this + // delegates to the non-statement taking version. + // + // \returns the transformed attribute. +#define ATTR(X) \ + const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \ + const X##Attr *A) { \ + return getDerived().Transform##X##Attr(A); \ + } +#include "clang/Basic/AttrList.inc" + /// Transform the given expression. /// /// By default, this routine transforms an expression by delegating to the @@ -522,12 +544,13 @@ public: /// /// By default, transforms the types of conversion function, constructor, /// and destructor names and then (if needed) rebuilds the declaration name. - /// Identifiers and selectors are returned unmodified. Sublcasses may + /// Identifiers and selectors are returned unmodified. Subclasses may /// override this function to provide alternate behavior. DeclarationNameInfo TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); - bool TransformRequiresExprRequirements(ArrayRef<concepts::Requirement *> Reqs, + bool TransformRequiresExprRequirements( + ArrayRef<concepts::Requirement *> Reqs, llvm::SmallVectorImpl<concepts::Requirement *> &Transformed); concepts::TypeRequirement * TransformTypeRequirement(concepts::TypeRequirement *Req); @@ -636,6 +659,14 @@ public: QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T); #include "clang/AST/TypeLocNodes.def" + QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB, + TemplateTypeParmTypeLoc TL, + bool SuppressObjCLifetime); + QualType + TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB, + SubstTemplateTypeParmPackTypeLoc TL, + bool SuppressObjCLifetime); + template<typename Fn> QualType TransformFunctionProtoType(TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, @@ -643,6 +674,10 @@ public: Qualifiers ThisTypeQuals, Fn TransformExceptionSpec); + template <typename Fn> + QualType TransformAttributedType(TypeLocBuilder &TLB, AttributedTypeLoc TL, + Fn TransformModifiedType); + bool TransformExceptionSpec(SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI, SmallVectorImpl<QualType> &Exceptions, @@ -671,13 +706,49 @@ public: /// The result vectors should be kept in sync; null entries in the /// variables vector are acceptable. /// + /// LastParamTransformed, if non-null, will be set to the index of the last + /// parameter on which transfromation was started. In the event of an error, + /// this will contain the parameter which failed to instantiate. + /// /// Return true on error. bool TransformFunctionTypeParams( SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, const QualType *ParamTypes, const FunctionProtoType::ExtParameterInfo *ParamInfos, SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars, - Sema::ExtParameterInfoBuilder &PInfos); + Sema::ExtParameterInfoBuilder &PInfos, unsigned *LastParamTransformed); + + bool TransformFunctionTypeParams( + SourceLocation Loc, ArrayRef<ParmVarDecl *> Params, + const QualType *ParamTypes, + const FunctionProtoType::ExtParameterInfo *ParamInfos, + SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars, + Sema::ExtParameterInfoBuilder &PInfos) { + return getDerived().TransformFunctionTypeParams( + Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos, nullptr); + } + + /// Transforms the parameters of a requires expresison into the given vectors. + /// + /// The result vectors should be kept in sync; null entries in the + /// variables vector are acceptable. + /// + /// Returns an unset ExprResult on success. Returns an ExprResult the 'not + /// satisfied' RequiresExpr if subsitution failed, OR an ExprError, both of + /// which are cases where transformation shouldn't continue. + ExprResult TransformRequiresTypeParams( + SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE, + RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params, + SmallVectorImpl<QualType> &PTypes, + SmallVectorImpl<ParmVarDecl *> &TransParams, + Sema::ExtParameterInfoBuilder &PInfos) { + if (getDerived().TransformFunctionTypeParams( + KWLoc, Params, /*ParamTypes=*/nullptr, + /*ParamInfos=*/nullptr, PTypes, &TransParams, PInfos)) + return ExprError(); + + return ExprResult{}; + } /// Transforms a single function-type parameter. Return null /// on error. @@ -686,7 +757,7 @@ public: /// scope index; can be negative ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - Optional<unsigned> NumExpansions, + std::optional<unsigned> NumExpansions, bool ExpectParameterPack); /// Transform the body of a lambda-expression. @@ -811,12 +882,9 @@ public: /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. /// Also by default, all of the other Rebuild*Array - QualType RebuildArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - const llvm::APInt *Size, - Expr *SizeExpr, - unsigned IndexTypeQuals, - SourceRange BracketsRange); + QualType RebuildArrayType(QualType ElementType, ArraySizeModifier SizeMod, + const llvm::APInt *Size, Expr *SizeExpr, + unsigned IndexTypeQuals, SourceRange BracketsRange); /// Build a new constant array type given the element type, size /// modifier, (known) size of the array, and index type qualifiers. @@ -824,9 +892,8 @@ public: /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. QualType RebuildConstantArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - const llvm::APInt &Size, - Expr *SizeExpr, + ArraySizeModifier SizeMod, + const llvm::APInt &Size, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange); @@ -836,7 +903,7 @@ public: /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. QualType RebuildIncompleteArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, + ArraySizeModifier SizeMod, unsigned IndexTypeQuals, SourceRange BracketsRange); @@ -846,8 +913,7 @@ public: /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. QualType RebuildVariableArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - Expr *SizeExpr, + ArraySizeModifier SizeMod, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange); @@ -857,7 +923,7 @@ public: /// By default, performs semantic analysis when building the array type. /// Subclasses may override this routine to provide different behavior. QualType RebuildDependentSizedArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, + ArraySizeModifier SizeMod, Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange); @@ -868,7 +934,7 @@ public: /// By default, performs semantic analysis when building the vector type. /// Subclasses may override this routine to provide different behavior. QualType RebuildVectorType(QualType ElementType, unsigned NumElements, - VectorType::VectorKind VecKind); + VectorKind VecKind); /// Build a new potentially dependently-sized extended vector type /// given the element type and number of elements. @@ -876,8 +942,7 @@ public: /// By default, performs semantic analysis when building the vector type. /// Subclasses may override this routine to provide different behavior. QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr, - SourceLocation AttributeLoc, - VectorType::VectorKind); + SourceLocation AttributeLoc, VectorKind); /// Build a new extended vector type given the element type and /// number of elements. @@ -933,6 +998,11 @@ public: /// the UnresolvedUsingTypenameDecl was transformed to. QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D); + /// Build a new type found via an alias. + QualType RebuildUsingType(UsingShadowDecl *Found, QualType Underlying) { + return SemaRef.Context.getUsingType(Found, Underlying); + } + /// Build a new typedef type. QualType RebuildTypedefType(TypedefNameDecl *Typedef) { return SemaRef.Context.getTypeDeclType(Typedef); @@ -958,12 +1028,13 @@ public: /// /// By default, performs semantic analysis when building the typeof type. /// Subclasses may override this routine to provide different behavior. - QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc); + QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc, + TypeOfKind Kind); /// Build a new typeof(type) type. /// /// By default, builds a new TypeOfType with the given underlying type. - QualType RebuildTypeOfType(QualType Underlying); + QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind); /// Build a new unary transform type. QualType RebuildUnaryTransformType(QualType BaseType, @@ -1056,23 +1127,18 @@ public: // If it's still dependent, make a dependent specialization. if (InstName.getAsDependentTemplateName()) - return SemaRef.Context.getDependentTemplateSpecializationType(Keyword, - QualifierLoc.getNestedNameSpecifier(), - Name, - Args); + return SemaRef.Context.getDependentTemplateSpecializationType( + Keyword, QualifierLoc.getNestedNameSpecifier(), Name, + Args.arguments()); // Otherwise, make an elaborated type wrapping a non-dependent // specialization. QualType T = - getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); - if (T.isNull()) return QualType(); - - if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr) - return T; - - return SemaRef.Context.getElaboratedType(Keyword, - QualifierLoc.getNestedNameSpecifier(), - T); + getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); + if (T.isNull()) + return QualType(); + return SemaRef.Context.getElaboratedType( + Keyword, QualifierLoc.getNestedNameSpecifier(), T); } /// Build a new typename type that refers to an identifier. @@ -1097,7 +1163,8 @@ public: Id); } - if (Keyword == ETK_None || Keyword == ETK_Typename) { + if (Keyword == ElaboratedTypeKeyword::None || + Keyword == ElaboratedTypeKeyword::Typename) { return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc, *Id, IdLoc, DeducedTSTContext); } @@ -1146,14 +1213,15 @@ public: case LookupResult::FoundUnresolvedValue: { NamedDecl *SomeDecl = Result.getRepresentativeDecl(); Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind); - SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl - << NTK << Kind; + SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) + << SomeDecl << NTK << llvm::to_underlying(Kind); SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at); break; } default: SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope) - << Kind << Id << DC << QualifierLoc.getSourceRange(); + << llvm::to_underlying(Kind) << Id << DC + << QualifierLoc.getSourceRange(); break; } return QualType(); @@ -1177,10 +1245,9 @@ public: /// /// By default, builds a new PackExpansionType type from the given pattern. /// Subclasses may override this routine to provide different behavior. - QualType RebuildPackExpansionType(QualType Pattern, - SourceRange PatternRange, + QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, NumExpansions); } @@ -1195,12 +1262,12 @@ public: QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc, bool isReadPipe); - /// Build an extended int given its value type. - QualType RebuildExtIntType(bool IsUnsigned, unsigned NumBits, + /// Build a bit-precise int given its value type. + QualType RebuildBitIntType(bool IsUnsigned, unsigned NumBits, SourceLocation Loc); - /// Build a dependent extended int given its value type. - QualType RebuildDependentExtIntType(bool IsUnsigned, Expr *NumBitsExpr, + /// Build a dependent bit-precise int given its value type. + QualType RebuildDependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc); /// Build a new template name given a nested name specifier, a flag @@ -1247,9 +1314,11 @@ public: /// be resolved to a specific template, then builds the appropriate kind of /// template name. Subclasses may override this routine to provide different /// behavior. - TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param, - const TemplateArgument &ArgPack) { - return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack); + TemplateName RebuildTemplateName(const TemplateArgument &ArgPack, + Decl *AssociatedDecl, unsigned Index, + bool Final) { + return getSema().Context.getSubstTemplateTemplateParmPack( + ArgPack, AssociatedDecl, Index, Final); } /// Build a new compound statement. @@ -1313,6 +1382,8 @@ public: StmtResult RebuildAttributedStmt(SourceLocation AttrLoc, ArrayRef<const Attr *> Attrs, Stmt *SubStmt) { + if (SemaRef.CheckRebuiltStmtAttributes(Attrs)) + return StmtError(); return SemaRef.BuildAttributedStmt(AttrLoc, Attrs, SubStmt); } @@ -1320,12 +1391,12 @@ public: /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr, + StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind, SourceLocation LParenLoc, Sema::ConditionResult Cond, SourceLocation RParenLoc, Stmt *Init, Stmt *Then, SourceLocation ElseLoc, Stmt *Else) { - return getSema().ActOnIfStmt(IfLoc, IsConstexpr, LParenLoc, Init, Cond, - RParenLoc, Then, ElseLoc, Else); + return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc, + Then, ElseLoc, Else); } /// Start building a new switch statement. @@ -1465,9 +1536,28 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result, + ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand, + UnresolvedLookupExpr *OpCoawaitLookup, bool IsImplicit) { - return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit); + // This function rebuilds a coawait-expr given its operator. + // For an explicit coawait-expr, the rebuild involves the full set + // of transformations performed by BuildUnresolvedCoawaitExpr(), + // including calling await_transform(). + // For an implicit coawait-expr, we need to rebuild the "operator + // coawait" but not await_transform(), so use BuildResolvedCoawaitExpr(). + // This mirrors how the implicit CoawaitExpr is originally created + // in Sema::ActOnCoroutineBodyStart(). + if (IsImplicit) { + ExprResult Suspend = getSema().BuildOperatorCoawaitCall( + CoawaitLoc, Operand, OpCoawaitLookup); + if (Suspend.isInvalid()) + return ExprError(); + return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand, + Suspend.get(), true); + } + + return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand, + OpCoawaitLookup); } /// Build a new co_await expression. @@ -1558,14 +1648,15 @@ public: /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind, - DeclarationNameInfo DirName, - OpenMPDirectiveKind CancelRegion, - ArrayRef<OMPClause *> Clauses, - Stmt *AStmt, SourceLocation StartLoc, - SourceLocation EndLoc) { + StmtResult RebuildOMPExecutableDirective( + OpenMPDirectiveKind Kind, DeclarationNameInfo DirName, + OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, + Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc, + OpenMPDirectiveKind PrevMappedDirective = OMPD_unknown) { + return getSema().ActOnOpenMPExecutableDirective( - Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc); + Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc, + PrevMappedDirective); } /// Build a new OpenMP 'if' clause. @@ -1819,16 +1910,14 @@ public: /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, - SourceLocation StartLoc, - SourceLocation LParenLoc, - OpenMPLinearClauseKind Modifier, - SourceLocation ModifierLoc, - SourceLocation ColonLoc, - SourceLocation EndLoc) { + OMPClause *RebuildOMPLinearClause( + ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc, + SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, + SourceLocation ModifierLoc, SourceLocation ColonLoc, + SourceLocation StepModifierLoc, SourceLocation EndLoc) { return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, - EndLoc); + StepModifierLoc, EndLoc); } /// Build a new OpenMP 'aligned' clause. @@ -1895,14 +1984,13 @@ public: /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. - OMPClause * - RebuildOMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind, - SourceLocation DepLoc, SourceLocation ColonLoc, - ArrayRef<Expr *> VarList, SourceLocation StartLoc, - SourceLocation LParenLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPDependClause(DepModifier, DepKind, DepLoc, - ColonLoc, VarList, StartLoc, - LParenLoc, EndLoc); + OMPClause *RebuildOMPDependClause(OMPDependClause::DependDataTy Data, + Expr *DepModifier, ArrayRef<Expr *> VarList, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPDependClause(Data, DepModifier, VarList, + StartLoc, LParenLoc, EndLoc); } /// Build a new OpenMP 'device' clause. @@ -1923,16 +2011,17 @@ public: /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. OMPClause *RebuildOMPMapClause( - ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, + Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapTypeModifiers, ArrayRef<SourceLocation> MapTypeModifiersLoc, CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId, OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) { - return getSema().ActOnOpenMPMapClause(MapTypeModifiers, MapTypeModifiersLoc, - MapperIdScopeSpec, MapperId, MapType, - IsMapTypeImplicit, MapLoc, ColonLoc, - VarList, Locs, UnresolvedMappers); + return getSema().ActOnOpenMPMapClause( + IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc, + MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc, + ColonLoc, VarList, Locs, + /*NoDiagnose=*/false, UnresolvedMappers); } /// Build a new OpenMP 'allocate' clause. @@ -1986,22 +2075,26 @@ public: /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc, + OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier, + Expr *Device, SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation ModifierLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc, - EndLoc); + return getSema().ActOnOpenMPGrainsizeClause(Modifier, Device, StartLoc, + LParenLoc, ModifierLoc, EndLoc); } /// Build a new OpenMP 'num_tasks' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc, + OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier, + Expr *NumTasks, SourceLocation StartLoc, SourceLocation LParenLoc, + SourceLocation ModifierLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc, - EndLoc); + return getSema().ActOnOpenMPNumTasksClause(Modifier, NumTasks, StartLoc, + LParenLoc, ModifierLoc, EndLoc); } /// Build a new OpenMP 'hint' clause. @@ -2096,6 +2189,15 @@ public: return getSema().ActOnOpenMPIsDevicePtrClause(VarList, Locs); } + /// Build a new OpenMP 'has_device_addr' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPHasDeviceAddrClause(ArrayRef<Expr *> VarList, + const OMPVarListLocTy &Locs) { + return getSema().ActOnOpenMPHasDeviceAddrClause(VarList, Locs); + } + /// Build a new OpenMP 'defaultmap' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. @@ -2175,28 +2277,25 @@ public: /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPOrderClause(OpenMPOrderClauseKind Kind, - SourceLocation KindKwLoc, - SourceLocation StartLoc, - SourceLocation LParenLoc, - SourceLocation EndLoc) { - return getSema().ActOnOpenMPOrderClause(Kind, KindKwLoc, StartLoc, - LParenLoc, EndLoc); + OMPClause *RebuildOMPOrderClause( + OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc, + SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, + OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) { + return getSema().ActOnOpenMPOrderClause(Modifier, Kind, StartLoc, LParenLoc, + ModifierKwLoc, KindKwLoc, EndLoc); } /// Build a new OpenMP 'init' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. - OMPClause *RebuildOMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs, - bool IsTarget, bool IsTargetSync, + OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc) { - return getSema().ActOnOpenMPInitClause(InteropVar, PrefExprs, IsTarget, - IsTargetSync, StartLoc, LParenLoc, - VarLoc, EndLoc); + return getSema().ActOnOpenMPInitClause(InteropVar, InteropInfo, StartLoc, + LParenLoc, VarLoc, EndLoc); } /// Build a new OpenMP 'use' clause. @@ -2256,6 +2355,109 @@ public: EndLoc); } + /// Build a new OpenMP 'bind' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPBindClause(OpenMPBindClauseKind Kind, + SourceLocation KindLoc, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPBindClause(Kind, KindLoc, StartLoc, LParenLoc, + EndLoc); + } + + /// Build a new OpenMP 'ompx_dyn_cgroup_mem' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc, LParenLoc, + EndLoc); + } + + /// Build a new OpenMP 'ompx_attribute' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPXAttributeClause(ArrayRef<const Attr *> Attrs, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPXAttributeClause(Attrs, StartLoc, LParenLoc, + EndLoc); + } + + /// Build a new OpenMP 'ompx_bare' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPXBareClause(SourceLocation StartLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPXBareClause(StartLoc, EndLoc); + } + + /// Build a new OpenMP 'align' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc, EndLoc); + } + + /// Build a new OpenMP 'at' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KwLoc, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPAtClause(Kind, KwLoc, StartLoc, LParenLoc, + EndLoc); + } + + /// Build a new OpenMP 'severity' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPSeverityClause(OpenMPSeverityClauseKind Kind, + SourceLocation KwLoc, + SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPSeverityClause(Kind, KwLoc, StartLoc, LParenLoc, + EndLoc); + } + + /// Build a new OpenMP 'message' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause *RebuildOMPMessageClause(Expr *MS, SourceLocation StartLoc, + SourceLocation LParenLoc, + SourceLocation EndLoc) { + return getSema().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc, EndLoc); + } + + /// Build a new OpenMP 'doacross' clause. + /// + /// By default, performs semantic analysis to build the new OpenMP clause. + /// Subclasses may override this routine to provide different behavior. + OMPClause * + RebuildOMPDoacrossClause(OpenMPDoacrossClauseModifier DepType, + SourceLocation DepLoc, SourceLocation ColonLoc, + ArrayRef<Expr *> VarList, SourceLocation StartLoc, + SourceLocation LParenLoc, SourceLocation EndLoc) { + return getSema().ActOnOpenMPDoacrossClause( + DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc); + } + /// Rebuild the operand to an Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. @@ -2424,8 +2626,7 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildPredefinedExpr(SourceLocation Loc, - PredefinedExpr::IdentKind IK) { + ExprResult RebuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK) { return getSema().BuildPredefinedExpr(Loc, IK); } @@ -2601,6 +2802,13 @@ public: /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig); } + ExprResult RebuildCxxSubscriptExpr(Expr *Callee, SourceLocation LParenLoc, + MultiExprArg Args, + SourceLocation RParenLoc) { + return getSema().ActOnArraySubscriptExpr( + /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc); + } + /// Build a new member access expression. /// /// By default, performs semantic analysis to build the new expression. @@ -2652,6 +2860,21 @@ public: R.addDecl(FoundDecl); R.resolveKind(); + if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() && + isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(Member)) { + if (auto *ThisClass = cast<CXXThisExpr>(Base) + ->getType() + ->getPointeeType() + ->getAsCXXRecordDecl()) { + auto *Class = cast<CXXRecordDecl>(Member->getDeclContext()); + // In unevaluated contexts, an expression supposed to be a member access + // might reference a member in an unrelated class. + if (!ThisClass->Equals(Class) && !ThisClass->isDerivedFrom(Class)) + return getSema().BuildDeclRefExpr(Member, Member->getType(), + VK_LValue, Member->getLocation()); + } + } + return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow, SS, TemplateKWLoc, FirstQualifierInScope, @@ -2721,20 +2944,18 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildExtVectorElementExpr(Expr *Base, - SourceLocation OpLoc, - SourceLocation AccessorLoc, - IdentifierInfo &Accessor) { + ExprResult RebuildExtVectorElementExpr(Expr *Base, SourceLocation OpLoc, + bool IsArrow, + SourceLocation AccessorLoc, + IdentifierInfo &Accessor) { CXXScopeSpec SS; DeclarationNameInfo NameInfo(&Accessor, AccessorLoc); - return getSema().BuildMemberReferenceExpr(Base, Base->getType(), - OpLoc, /*IsArrow*/ false, - SS, SourceLocation(), - /*FirstQualifierInScope*/ nullptr, - NameInfo, - /* TemplateArgs */ nullptr, - /*S*/ nullptr); + return getSema().BuildMemberReferenceExpr( + Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(), + /*FirstQualifierInScope*/ nullptr, NameInfo, + /* TemplateArgs */ nullptr, + /*S*/ nullptr); } /// Build a new initializer list expression. @@ -2828,7 +3049,7 @@ public: RParenLoc); } - /// Build a new generic selection expression. + /// Build a new generic selection expression with an expression predicate. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2839,9 +3060,25 @@ public: ArrayRef<TypeSourceInfo *> Types, ArrayRef<Expr *> Exprs) { return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, + /*PredicateIsExpr=*/true, ControllingExpr, Types, Exprs); } + /// Build a new generic selection expression with a type predicate. + /// + /// By default, performs semantic analysis to build the new expression. + /// Subclasses may override this routine to provide different behavior. + ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc, + SourceLocation DefaultLoc, + SourceLocation RParenLoc, + TypeSourceInfo *ControllingType, + ArrayRef<TypeSourceInfo *> Types, + ArrayRef<Expr *> Exprs) { + return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, + /*PredicateIsExpr=*/false, + ControllingType, Types, Exprs); + } + /// Build a new overloaded operator call expression. /// /// By default, performs semantic analysis to build the new expression. @@ -2851,10 +3088,11 @@ public: /// argument-dependent lookup, etc. Subclasses may override this routine to /// provide different behavior. ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, - SourceLocation OpLoc, - Expr *Callee, - Expr *First, - Expr *Second); + SourceLocation OpLoc, + SourceLocation CalleeLoc, + bool RequiresADL, + const UnresolvedSetImpl &Functions, + Expr *First, Expr *Second); /// Build a new C++ "named" cast expression, such as static_cast or /// reinterpret_cast. @@ -2988,6 +3226,13 @@ public: Expr *Sub, SourceLocation RParenLoc, bool ListInitialization) { + // If Sub is a ParenListExpr, then Sub is the syntatic form of a + // CXXParenListInitExpr. Pass its expanded arguments so that the + // CXXParenListInitExpr can be rebuilt. + if (auto *PLE = dyn_cast<ParenListExpr>(Sub)) + return getSema().BuildCXXTypeConstructExpr( + TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()), + RParenLoc, ListInitialization); return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc, MultiExprArg(&Sub, 1), RParenLoc, ListInitialization); @@ -3072,9 +3317,10 @@ public: /// By default, builds a new default-argument expression, which does not /// require any semantic analysis. Subclasses may override this routine to /// provide different behavior. - ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param) { + ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param, + Expr *RewrittenExpr) { return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param, - getSema().CurContext); + RewrittenExpr, getSema().CurContext); } /// Build a new C++11 default-initialization expression. @@ -3084,8 +3330,7 @@ public: /// routine to provide different behavior. ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) { - return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field, - getSema().CurContext); + return getSema().BuildCXXDefaultInitExpr(Loc, Field); } /// Build a new C++ zero-initialization expression. @@ -3095,25 +3340,23 @@ public: ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo, SourceLocation LParenLoc, SourceLocation RParenLoc) { - return getSema().BuildCXXTypeConstructExpr( - TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false); + return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, std::nullopt, + RParenLoc, + /*ListInitialization=*/false); } /// Build a new C++ "new" expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, - bool UseGlobal, + ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, - SourceRange TypeIdParens, - QualType AllocatedType, + SourceRange TypeIdParens, QualType AllocatedType, TypeSourceInfo *AllocatedTypeInfo, - Optional<Expr *> ArraySize, - SourceRange DirectInitRange, - Expr *Initializer) { + std::optional<Expr *> ArraySize, + SourceRange DirectInitRange, Expr *Initializer) { return getSema().BuildCXXNew(StartLoc, UseGlobal, PlacementLParen, PlacementArgs, @@ -3212,17 +3455,12 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildCXXConstructExpr(QualType T, - SourceLocation Loc, - CXXConstructorDecl *Constructor, - bool IsElidable, - MultiExprArg Args, - bool HadMultipleCandidates, - bool ListInitialization, - bool StdInitListInitialization, - bool RequiresZeroInit, - CXXConstructExpr::ConstructionKind ConstructKind, - SourceRange ParenRange) { + ExprResult RebuildCXXConstructExpr( + QualType T, SourceLocation Loc, CXXConstructorDecl *Constructor, + bool IsElidable, MultiExprArg Args, bool HadMultipleCandidates, + bool ListInitialization, bool StdInitListInitialization, + bool RequiresZeroInit, CXXConstructionKind ConstructKind, + SourceRange ParenRange) { // Reconstruct the constructor we originally found, which might be // different if this is a call to an inherited constructor. CXXConstructorDecl *FoundCtor = Constructor; @@ -3335,11 +3573,10 @@ public: } /// Build a new expression to compute the length of a parameter pack. - ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, - NamedDecl *Pack, + ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - Optional<unsigned> Length, + std::optional<unsigned> Length, ArrayRef<TemplateArgument> PartialArgs) { return SizeOfPackExpr::Create(SemaRef.Context, OperatorLoc, Pack, PackLoc, RParenLoc, Length, PartialArgs); @@ -3350,11 +3587,12 @@ public: /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. - ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind, + ExprResult RebuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext) { - return getSema().BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, ParentContext); + return getSema().BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc, + ParentContext); } /// Build a new Objective-C boxed expression. @@ -3382,11 +3620,14 @@ public: /// Subclasses may override this routine to provide different behavior. ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, + SourceLocation LParenLoc, ArrayRef<ParmVarDecl *> LocalParameters, + SourceLocation RParenLoc, ArrayRef<concepts::Requirement *> Requirements, SourceLocation ClosingBraceLoc) { - return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body, - LocalParameters, Requirements, ClosingBraceLoc); + return RequiresExpr::Create(SemaRef.Context, RequiresKWLoc, Body, LParenLoc, + LocalParameters, RParenLoc, Requirements, + ClosingBraceLoc); } concepts::TypeRequirement * @@ -3416,9 +3657,10 @@ public: } concepts::NestedRequirement * - RebuildNestedRequirement( - concepts::Requirement::SubstitutionDiagnostic *SubstDiag) { - return SemaRef.BuildNestedRequirement(SubstDiag); + RebuildNestedRequirement(StringRef InvalidConstraintEntity, + const ASTConstraintSatisfaction &Satisfaction) { + return SemaRef.BuildNestedRequirement(InvalidConstraintEntity, + Satisfaction); } concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) { @@ -3641,9 +3883,9 @@ public: /// By default, performs semantic analysis to build a new pack expansion /// for a template argument. Subclasses may override this routine to provide /// different behavior. - TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, - SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + TemplateArgumentLoc + RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc, + std::optional<unsigned> NumExpansions) { switch (Pattern.getArgument().getKind()) { case TemplateArgument::Expression: { ExprResult Result @@ -3666,6 +3908,7 @@ public: case TemplateArgument::Null: case TemplateArgument::Integral: case TemplateArgument::Declaration: + case TemplateArgument::StructuralValue: case TemplateArgument::Pack: case TemplateArgument::TemplateExpansion: case TemplateArgument::NullPtr: @@ -3690,7 +3933,7 @@ public: /// for an expression. Subclasses may override this routine to provide /// different behavior. ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } @@ -3703,7 +3946,7 @@ public: BinaryOperatorKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator, EllipsisLoc, RHS, RParenLoc, NumExpansions); @@ -3840,8 +4083,10 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, if (auto *FE = dyn_cast<FullExpr>(Init)) Init = FE->getSubExpr(); - if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) - Init = AIL->getCommonExpr(); + if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Init)) { + OpaqueValueExpr *OVE = AIL->getCommonExpr(); + Init = OVE->getSourceExpr(); + } if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init)) Init = MTE->getSubExpr(); @@ -3866,13 +4111,13 @@ ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, // Revert value-initialization back to empty parens. if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { SourceRange Parens = VIE->getSourceRange(); - return getDerived().RebuildParenListExpr(Parens.getBegin(), None, + return getDerived().RebuildParenListExpr(Parens.getBegin(), std::nullopt, Parens.getEnd()); } // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. if (isa<ImplicitValueInitExpr>(Init)) - return getDerived().RebuildParenListExpr(SourceLocation(), None, + return getDerived().RebuildParenListExpr(SourceLocation(), std::nullopt, SourceLocation()); // Revert initialization by constructor back to a parenthesized or braced list @@ -3940,8 +4185,8 @@ bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs, // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -4046,7 +4291,8 @@ Sema::ConditionResult TreeTransform<Derived>::TransformCondition( if (CondExpr.isInvalid()) return Sema::ConditionError(); - return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind); + return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind, + /*MissingOK=*/true); } return Sema::ConditionResult(); @@ -4057,9 +4303,13 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc( NestedNameSpecifierLoc NNS, QualType ObjectType, NamedDecl *FirstQualifierInScope) { SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; - for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; - Qualifier = Qualifier.getPrefix()) - Qualifiers.push_back(Qualifier); + + auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) { + for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; + Qualifier = Qualifier.getPrefix()) + Qualifiers.push_back(Qualifier); + }; + insertNNS(NNS); CXXScopeSpec SS; while (!Qualifiers.empty()) { @@ -4116,24 +4366,27 @@ NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc( if (!TL) return NestedNameSpecifierLoc(); - if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || - (SemaRef.getLangOpts().CPlusPlus11 && - TL.getType()->isEnumeralType())) { - assert(!TL.getType().hasLocalQualifiers() && - "Can't get cv-qualifiers here"); - if (TL.getType()->isEnumeralType()) + QualType T = TL.getType(); + if (T->isDependentType() || T->isRecordType() || + (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) { + if (T->isEnumeralType()) SemaRef.Diag(TL.getBeginLoc(), diag::warn_cxx98_compat_enum_nested_name_spec); + + if (const auto ETL = TL.getAs<ElaboratedTypeLoc>()) { + SS.Adopt(ETL.getQualifierLoc()); + TL = ETL.getNamedTypeLoc(); + } SS.Extend(SemaRef.Context, /*FIXME:*/ SourceLocation(), TL, Q.getLocalEndLoc()); break; } // If the nested-name-specifier is an invalid type def, don't emit an // error because a previous error should have already been emitted. - TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>(); + TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>(); if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) - << TL.getType() << SS.getRange(); + << T << SS.getRange(); } return NestedNameSpecifierLoc(); } @@ -4232,7 +4485,7 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName) { if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { - TemplateDecl *Template = QTN->getTemplateDecl(); + TemplateDecl *Template = QTN->getUnderlyingTemplate().getAsTemplateDecl(); assert(Template && "qualified template name must refer to a template"); TemplateDecl *TransTemplate @@ -4296,18 +4549,9 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, if (SubstTemplateTemplateParmPackStorage *SubstPack = Name.getAsSubstTemplateTemplateParmPack()) { - TemplateTemplateParmDecl *TransParam - = cast_or_null<TemplateTemplateParmDecl>( - getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); - if (!TransParam) - return TemplateName(); - - if (!getDerived().AlwaysRebuild() && - TransParam == SubstPack->getParameterPack()) - return Name; - - return getDerived().RebuildTemplateName(TransParam, - SubstPack->getArgumentPack()); + return getDerived().RebuildTemplateName( + SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(), + SubstPack->getIndex(), SubstPack->getFinal()); } // These should be getting filtered out before they reach the AST. @@ -4334,7 +4578,8 @@ bool TreeTransform<Derived>::TransformTemplateArgument( case TemplateArgument::Integral: case TemplateArgument::NullPtr: - case TemplateArgument::Declaration: { + case TemplateArgument::Declaration: + case TemplateArgument::StructuralValue: { // Transform a resolved template argument straight to a resolved template // argument. We get here when substituting into an already-substituted // template type argument during concept satisfaction checking. @@ -4361,9 +4606,15 @@ bool TreeTransform<Derived>::TransformTemplateArgument( else if (Arg.getKind() == TemplateArgument::NullPtr) Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true), TemplateArgumentLocInfo()); - else + else if (Arg.getKind() == TemplateArgument::Declaration) Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT), TemplateArgumentLocInfo()); + else if (Arg.getKind() == TemplateArgument::StructuralValue) + Output = TemplateArgumentLoc( + TemplateArgument(getSema().Context, NewT, Arg.getAsStructuralValue()), + TemplateArgumentLocInfo()); + else + llvm_unreachable("unexpected template argument kind"); return false; } @@ -4410,7 +4661,7 @@ bool TreeTransform<Derived>::TransformTemplateArgument( getSema(), Uneval ? Sema::ExpressionEvaluationContext::Unevaluated : Sema::ExpressionEvaluationContext::ConstantEvaluated, - /*LambdaContextDecl=*/nullptr, /*ExprContext=*/ + Sema::ReuseLambdaContextDecl, /*ExprContext=*/ Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument); Expr *InputExpr = Input.getSourceExpression(); @@ -4521,7 +4772,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments( // We have a pack expansion, for which we will be substituting into // the pattern. SourceLocation Ellipsis; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; TemplateArgumentLoc Pattern = getSema().getTemplateArgumentPackExpansionPattern( In, Ellipsis, OrigNumExpansions); @@ -4534,7 +4785,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments( // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Ellipsis, Pattern.getSourceRange(), Unexpanded, @@ -4721,7 +4972,20 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, QualifiedTypeLoc T) { - QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); + QualType Result; + TypeLoc UnqualTL = T.getUnqualifiedLoc(); + auto SuppressObjCLifetime = + T.getType().getLocalQualifiers().hasObjCLifetime(); + if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) { + Result = getDerived().TransformTemplateTypeParmType(TLB, TTP, + SuppressObjCLifetime); + } else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) { + Result = getDerived().TransformSubstTemplateTypeParmPackType( + TLB, STTP, SuppressObjCLifetime); + } else { + Result = getDerived().TransformType(TLB, UnqualTL); + } + if (Result.isNull()) return QualType(); @@ -4745,8 +5009,8 @@ QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T, SourceLocation Loc = TL.getBeginLoc(); Qualifiers Quals = TL.getType().getLocalQualifiers(); - if (((T.getAddressSpace() != LangAS::Default && - Quals.getAddressSpace() != LangAS::Default)) && + if ((T.getAddressSpace() != LangAS::Default && + Quals.getAddressSpace() != LangAS::Default) && T.getAddressSpace() != Quals.getAddressSpace()) { SemaRef.Diag(Loc, diag::err_address_space_mismatch_templ_inst) << TL.getType() << T; @@ -4784,16 +5048,7 @@ QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T, // A lifetime qualifier applied to a substituted template parameter // overrides the lifetime qualifier from the template argument. const AutoType *AutoTy; - if (const SubstTemplateTypeParmType *SubstTypeParam - = dyn_cast<SubstTemplateTypeParmType>(T)) { - QualType Replacement = SubstTypeParam->getReplacementType(); - Qualifiers Qs = Replacement.getQualifiers(); - Qs.removeObjCLifetime(); - Replacement = SemaRef.Context.getQualifiedType( - Replacement.getUnqualifiedType(), Qs); - T = SemaRef.Context.getSubstTemplateTypeParmType( - SubstTypeParam->getReplacedParameter(), Replacement); - } else if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) { + if ((AutoTy = dyn_cast<AutoType>(T)) && AutoTy->isDeduced()) { // 'auto' types behave the same way as template parameters. QualType Deduced = AutoTy->getDeducedType(); Qualifiers Qs = Deduced.getQualifiers(); @@ -5246,6 +5501,9 @@ TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, EnterExpressionEvaluationContext Unevaluated( SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); + // If we have a VLA then it won't be a constant. + SemaRef.ExprEvalContexts.back().InConditionallyConstantEvaluateContext = true; + // Prefer the expression from the TypeLoc; the other may have been uniqued. Expr *origSize = TL.getSizeExpr(); if (!origSize) origSize = T->getSizeExpr(); @@ -5538,8 +5796,8 @@ QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, template <typename Derived> ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( - ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, - bool ExpectParameterPack) { + ParmVarDecl *OldParm, int indexAdjustment, + std::optional<unsigned> NumExpansions, bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = nullptr; @@ -5599,15 +5857,18 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( const FunctionProtoType::ExtParameterInfo *ParamInfos, SmallVectorImpl<QualType> &OutParamTypes, SmallVectorImpl<ParmVarDecl *> *PVars, - Sema::ExtParameterInfoBuilder &PInfos) { + Sema::ExtParameterInfoBuilder &PInfos, + unsigned *LastParamTransformed) { int indexAdjustment = 0; unsigned NumParams = Params.size(); for (unsigned i = 0; i != NumParams; ++i) { + if (LastParamTransformed) + *LastParamTransformed = i; if (ParmVarDecl *OldParm = Params[i]) { assert(OldParm->getFunctionScopeIndex() == i); - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; ParmVarDecl *NewParm = nullptr; if (OldParm->isParameterPack()) { // We have a function parameter pack that may need to be expanded. @@ -5622,7 +5883,7 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( // Determine whether we should expand the parameter packs. bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; if (Unexpanded.size() > 0) { OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); NumExpansions = OrigNumExpansions; @@ -5705,7 +5966,8 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( "transformation."); } else { NewParm = getDerived().TransformFunctionTypeParam( - OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); + OldParm, indexAdjustment, std::nullopt, + /*ExpectParameterPack=*/false); } if (!NewParm) @@ -5721,9 +5983,10 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( // Deal with the possibility that we don't have a parameter // declaration for this parameter. + assert(ParamTypes); QualType OldType = ParamTypes[i]; bool IsPackExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; QualType NewType; if (const PackExpansionType *Expansion = dyn_cast<PackExpansionType>(OldType)) { @@ -5753,8 +6016,8 @@ bool TreeTransform<Derived>::TransformFunctionTypeParams( return true; if (NewType->containsUnexpandedParameterPack()) { - NewType = - getSema().getASTContext().getPackExpansionType(NewType, None); + NewType = getSema().getASTContext().getPackExpansionType( + NewType, std::nullopt); if (NewType.isNull()) return true; @@ -5826,12 +6089,11 @@ QualType TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, FunctionProtoTypeLoc TL) { SmallVector<QualType, 4> ExceptionStorage; - TreeTransform *This = this; // Work around gcc.gnu.org/PR56135. return getDerived().TransformFunctionProtoType( TLB, TL, nullptr, Qualifiers(), [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { - return This->getDerived().TransformExceptionSpec( - TL.getBeginLoc(), ESI, ExceptionStorage, Changed); + return getDerived().TransformExceptionSpec(TL.getBeginLoc(), ESI, + ExceptionStorage, Changed); }); } @@ -5899,8 +6161,8 @@ QualType TreeTransform<Derived>::TransformFunctionProtoType( if (auto NewExtParamInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size())) { if (!EPI.ExtParameterInfos || - llvm::makeArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) - != llvm::makeArrayRef(NewExtParamInfos, ParamTypes.size())) { + llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) != + llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) { EPIChanged = true; } EPI.ExtParameterInfos = NewExtParamInfos; @@ -5911,7 +6173,7 @@ QualType TreeTransform<Derived>::TransformFunctionProtoType( QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || - T->getParamTypes() != llvm::makeArrayRef(ParamTypes) || EPIChanged) { + T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) { Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI); if (Result.isNull()) return QualType(); @@ -5937,6 +6199,13 @@ bool TreeTransform<Derived>::TransformExceptionSpec( // Instantiate a dynamic noexcept expression, if any. if (isComputedNoexcept(ESI.Type)) { + // Update this scrope because ContextDecl in Sema will be used in + // TransformExpr. + auto *Method = dyn_cast_if_present<CXXMethodDecl>(ESI.SourceTemplate); + Sema::CXXThisScopeRAII ThisScope( + SemaRef, Method ? Method->getParent() : nullptr, + Method ? Method->getMethodQualifiers() : Qualifiers{}, + Method != nullptr); EnterExpressionEvaluationContext Unevaluated( getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated); ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr); @@ -5945,7 +6214,7 @@ bool TreeTransform<Derived>::TransformExceptionSpec( ExceptionSpecificationType EST = ESI.Type; NoexceptExpr = - getSema().ActOnNoexceptSpec(Loc, NoexceptExpr.get(), EST); + getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST); if (NoexceptExpr.isInvalid()) return true; @@ -5975,7 +6244,7 @@ bool TreeTransform<Derived>::TransformExceptionSpec( // be expanded. bool Expand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); + std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); // FIXME: Track the location of the ellipsis (and track source location // information for the types in the exception specification in general). if (getDerived().TryExpandParameterPacks( @@ -6047,9 +6316,9 @@ QualType TreeTransform<Derived>::TransformFunctionNoProtoType( return Result; } -template<typename Derived> QualType -TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, - UnresolvedUsingTypeLoc TL) { +template <typename Derived> +QualType TreeTransform<Derived>::TransformUnresolvedUsingType( + TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) { const UnresolvedUsingType *T = TL.getTypePtr(); Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); if (!D) @@ -6070,6 +6339,32 @@ TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, return Result; } +template <typename Derived> +QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB, + UsingTypeLoc TL) { + const UsingType *T = TL.getTypePtr(); + + auto *Found = cast_or_null<UsingShadowDecl>(getDerived().TransformDecl( + TL.getLocalSourceRange().getBegin(), T->getFoundDecl())); + if (!Found) + return QualType(); + + QualType Underlying = getDerived().TransformType(T->desugar()); + if (Underlying.isNull()) + return QualType(); + + QualType Result = TL.getType(); + if (getDerived().AlwaysRebuild() || Found != T->getFoundDecl() || + Underlying != T->getUnderlyingType()) { + Result = getDerived().RebuildUsingType(Found, Underlying); + if (Result.isNull()) + return QualType(); + } + + TLB.pushTypeSpec(Result).setNameLoc(TL.getNameLoc()); + return Result; +} + template<typename Derived> QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) { @@ -6111,13 +6406,13 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, return QualType(); QualType Result = TL.getType(); - if (getDerived().AlwaysRebuild() || - E.get() != TL.getUnderlyingExpr()) { - Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); + TypeOfKind Kind = Result->getAs<TypeOfExprType>()->getKind(); + if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) { + Result = + getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind); if (Result.isNull()) return QualType(); } - else E.get(); TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); NewTL.setTypeofLoc(TL.getTypeofLoc()); @@ -6130,14 +6425,15 @@ QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, template<typename Derived> QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, TypeOfTypeLoc TL) { - TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); + TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo(); TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); if (!New_Under_TI) return QualType(); QualType Result = TL.getType(); + TypeOfKind Kind = Result->getAs<TypeOfType>()->getKind(); if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { - Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); + Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind); if (Result.isNull()) return QualType(); } @@ -6146,7 +6442,7 @@ QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, NewTL.setTypeofLoc(TL.getTypeofLoc()); NewTL.setLParenLoc(TL.getLParenLoc()); NewTL.setRParenLoc(TL.getRParenLoc()); - NewTL.setUnderlyingTInfo(New_Under_TI); + NewTL.setUnmodifiedTInfo(New_Under_TI); return Result; } @@ -6172,15 +6468,15 @@ QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || E.get() != T->getUnderlyingExpr()) { - Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); + Result = getDerived().RebuildDecltypeType(E.get(), TL.getDecltypeLoc()); if (Result.isNull()) return QualType(); } else E.get(); DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); - NewTL.setNameLoc(TL.getNameLoc()); - + NewTL.setDecltypeLoc(TL.getDecltypeLoc()); + NewTL.setRParenLoc(TL.getRParenLoc()); return Result; } @@ -6303,6 +6599,14 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformTemplateTypeParmType( TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL) { + return getDerived().TransformTemplateTypeParmType( + TLB, TL, + /*SuppressObjCLifetime=*/false); +} + +template <typename Derived> +QualType TreeTransform<Derived>::TransformTemplateTypeParmType( + TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) { return TransformTypeSpecType(TLB, TL); } @@ -6312,6 +6616,9 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( SubstTemplateTypeParmTypeLoc TL) { const SubstTemplateTypeParmType *T = TL.getTypePtr(); + Decl *NewReplaced = + getDerived().TransformDecl(TL.getNameLoc(), T->getAssociatedDecl()); + // Substitute into the replacement type, which itself might involve something // that needs to be transformed. This only tends to occur with default // template arguments of template template parameters. @@ -6320,11 +6627,8 @@ QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( if (Replacement.isNull()) return QualType(); - // Always canonicalize the replacement type. - Replacement = SemaRef.Context.getCanonicalType(Replacement); - QualType Result - = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), - Replacement); + QualType Result = SemaRef.Context.getSubstTemplateTypeParmType( + Replacement, NewReplaced, T->getIndex(), T->getPackIndex()); // Propagate type-source information. SubstTemplateTypeParmTypeLoc NewTL @@ -6338,6 +6642,13 @@ template<typename Derived> QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL) { + return getDerived().TransformSubstTemplateTypeParmPackType( + TLB, TL, /*SuppressObjCLifetime=*/false); +} + +template <typename Derived> +QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( + TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) { return TransformTypeSpecType(TLB, TL); } @@ -6405,27 +6716,27 @@ QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB, } template <typename Derived> -QualType TreeTransform<Derived>::TransformExtIntType(TypeLocBuilder &TLB, - ExtIntTypeLoc TL) { - const ExtIntType *EIT = TL.getTypePtr(); +QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB, + BitIntTypeLoc TL) { + const BitIntType *EIT = TL.getTypePtr(); QualType Result = TL.getType(); if (getDerived().AlwaysRebuild()) { - Result = getDerived().RebuildExtIntType(EIT->isUnsigned(), + Result = getDerived().RebuildBitIntType(EIT->isUnsigned(), EIT->getNumBits(), TL.getNameLoc()); if (Result.isNull()) return QualType(); } - ExtIntTypeLoc NewTL = TLB.push<ExtIntTypeLoc>(Result); + BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result); NewTL.setNameLoc(TL.getNameLoc()); return Result; } template <typename Derived> -QualType TreeTransform<Derived>::TransformDependentExtIntType( - TypeLocBuilder &TLB, DependentExtIntTypeLoc TL) { - const DependentExtIntType *EIT = TL.getTypePtr(); +QualType TreeTransform<Derived>::TransformDependentBitIntType( + TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) { + const DependentBitIntType *EIT = TL.getTypePtr(); EnterExpressionEvaluationContext Unevaluated( SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); @@ -6438,18 +6749,18 @@ QualType TreeTransform<Derived>::TransformDependentExtIntType( QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) { - Result = getDerived().RebuildDependentExtIntType( + Result = getDerived().RebuildDependentBitIntType( EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc()); if (Result.isNull()) return QualType(); } - if (isa<DependentExtIntType>(Result)) { - DependentExtIntTypeLoc NewTL = TLB.push<DependentExtIntTypeLoc>(Result); + if (isa<DependentBitIntType>(Result)) { + DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(Result); NewTL.setNameLoc(TL.getNameLoc()); } else { - ExtIntTypeLoc NewTL = TLB.push<ExtIntTypeLoc>(Result); + BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(Result); NewTL.setNameLoc(TL.getNameLoc()); } return Result; @@ -6535,16 +6846,16 @@ QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, TemplateArgumentListInfo NewTemplateArgs; NestedNameSpecifierLoc NewNestedNameSpec; if (T->isConstrained()) { + assert(TL.getConceptReference()); NewCD = cast_or_null<ConceptDecl>(getDerived().TransformDecl( TL.getConceptNameLoc(), T->getTypeConstraintConcept())); NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator; - if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), - ArgIterator(TL, - TL.getNumArgs()), - NewTemplateArgs)) + if (getDerived().TransformTemplateArguments( + ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()), + NewTemplateArgs)) return QualType(); if (TL.getNestedNameSpecifierLoc()) { @@ -6561,7 +6872,7 @@ QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, T->isDependentType() || T->isConstrained()) { // FIXME: Maybe don't rebuild if all template arguments are the same. llvm::SmallVector<TemplateArgument, 4> NewArgList; - NewArgList.reserve(NewArgList.size()); + NewArgList.reserve(NewTemplateArgs.size()); for (const auto &ArgLoc : NewTemplateArgs.arguments()) NewArgList.push_back(ArgLoc.getArgument()); Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD, @@ -6572,14 +6883,20 @@ QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); NewTL.setNameLoc(TL.getNameLoc()); - NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec); - NewTL.setTemplateKWLoc(TL.getTemplateKWLoc()); - NewTL.setConceptNameLoc(TL.getConceptNameLoc()); - NewTL.setFoundDecl(TL.getFoundDecl()); - NewTL.setLAngleLoc(TL.getLAngleLoc()); - NewTL.setRAngleLoc(TL.getRAngleLoc()); - for (unsigned I = 0; I < NewTL.getNumArgs(); ++I) - NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo()); + NewTL.setRParenLoc(TL.getRParenLoc()); + NewTL.setConceptReference(nullptr); + + if (T->isConstrained()) { + DeclarationNameInfo DNI = DeclarationNameInfo( + TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(), + TL.getConceptNameLoc(), + TL.getTypePtr()->getTypeConstraintConcept()->getDeclName()); + auto *CR = ConceptReference::Create( + SemaRef.Context, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI, + TL.getFoundDecl(), TL.getTypePtr()->getTypeConstraintConcept(), + ASTTemplateArgumentListInfo::Create(SemaRef.Context, NewTemplateArgs)); + NewTL.setConceptReference(CR); + } return Result; } @@ -6657,12 +6974,9 @@ QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( // FIXME: maybe don't rebuild if all the template arguments are the same. if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { - QualType Result - = getSema().Context.getDependentTemplateSpecializationType( - TL.getTypePtr()->getKeyword(), - DTN->getQualifier(), - DTN->getIdentifier(), - NewTemplateArgs); + QualType Result = getSema().Context.getDependentTemplateSpecializationType( + TL.getTypePtr()->getKeyword(), DTN->getQualifier(), + DTN->getIdentifier(), NewTemplateArgs.arguments()); DependentTemplateSpecializationTypeLoc NewTL = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); @@ -6720,7 +7034,8 @@ TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, // If the identifier resolves to a typedef-name or the simple-template-id // resolves to an alias template specialization, the // elaborated-type-specifier is ill-formed. - if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) { + if (T->getKeyword() != ElaboratedTypeKeyword::None && + T->getKeyword() != ElaboratedTypeKeyword::Typename) { if (const TemplateSpecializationType *TST = NamedT->getAs<TemplateSpecializationType>()) { TemplateName Template = TST->getTemplateName(); @@ -6729,7 +7044,8 @@ TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(), diag::err_tag_reference_non_tag) << TAT << Sema::NTK_TypeAliasTemplate - << ElaboratedType::getTagTypeKindForKeyword(T->getKeyword()); + << llvm::to_underlying( + ElaboratedType::getTagTypeKindForKeyword(T->getKeyword())); SemaRef.Diag(TAT->getLocation(), diag::note_declared_at); } } @@ -6752,12 +7068,12 @@ TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, return Result; } -template<typename Derived> +template <typename Derived> +template <typename Fn> QualType TreeTransform<Derived>::TransformAttributedType( - TypeLocBuilder &TLB, - AttributedTypeLoc TL) { + TypeLocBuilder &TLB, AttributedTypeLoc TL, Fn TransformModifiedTypeFn) { const AttributedType *oldType = TL.getTypePtr(); - QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); + QualType modifiedType = TransformModifiedTypeFn(TLB, TL.getModifiedLoc()); if (modifiedType.isNull()) return QualType(); @@ -6783,7 +7099,8 @@ QualType TreeTransform<Derived>::TransformAttributedType( // type sugar, and therefore cannot be diagnosed in any other way. if (auto nullability = oldType->getImmediateNullability()) { if (!modifiedType->canHaveNullability()) { - SemaRef.Diag(TL.getAttr()->getLocation(), + SemaRef.Diag((TL.getAttr() ? TL.getAttr()->getLocation() + : TL.getModifiedLoc().getBeginLoc()), diag::err_nullability_nonpointer) << DiagNullabilityKind(*nullability, false) << modifiedType; return QualType(); @@ -6800,6 +7117,22 @@ QualType TreeTransform<Derived>::TransformAttributedType( return result; } +template <typename Derived> +QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB, + AttributedTypeLoc TL) { + return getDerived().TransformAttributedType( + TLB, TL, [&](TypeLocBuilder &TLB, TypeLoc ModifiedLoc) -> QualType { + return getDerived().TransformType(TLB, ModifiedLoc); + }); +} + +template <typename Derived> +QualType TreeTransform<Derived>::TransformBTFTagAttributedType( + TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) { + // The BTFTagAttributedType is available for C only. + llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType"); +} + template<typename Derived> QualType TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, @@ -7013,12 +7346,10 @@ TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB, QualType Result = TL.getType(); if (getDerived().AlwaysRebuild() || OTP != T->getDecl()) { - Result = getDerived().RebuildObjCTypeParamType(OTP, - TL.getProtocolLAngleLoc(), - llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), - TL.getNumProtocols()), - TL.getProtocolLocs(), - TL.getProtocolRAngleLoc()); + Result = getDerived().RebuildObjCTypeParamType( + OTP, TL.getProtocolLAngleLoc(), + llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), + TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); if (Result.isNull()) return QualType(); } @@ -7066,7 +7397,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc(); bool Expand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); + std::optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); if (getDerived().TryExpandParameterPacks( PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(), Unexpanded, Expand, RetainExpansion, NumExpansions)) @@ -7116,7 +7447,8 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, TypeLocBuilder TypeArgBuilder; TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize()); - QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc); + QualType NewTypeArg = + getDerived().TransformType(TypeArgBuilder, TypeArgLoc); if (NewTypeArg.isNull()) return QualType(); @@ -7137,7 +7469,7 @@ TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, Result = getDerived().RebuildObjCObjectType( BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos, TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(), - llvm::makeArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), + llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()), TL.getProtocolLocs(), TL.getProtocolRAngleLoc()); if (Result.isNull()) @@ -7199,6 +7531,10 @@ StmtResult TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr) { Sema::CompoundScopeRAII CompoundScope(getSema()); + Sema::FPFeaturesStateRAII FPSave(getSema()); + if (S->hasStoredFPFeatures()) + getSema().resetFPOptions( + S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts())); const Stmt *ExprResult = S->getStmtExprResult(); bool SubStmtInvalid = false; @@ -7321,36 +7657,52 @@ const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) { return R; switch (R->getKind()) { -// Transform attributes with a pragma spelling by calling TransformXXXAttr. -#define ATTR(X) -#define PRAGMA_SPELLING_ATTR(X) \ +// Transform attributes by calling TransformXXXAttr. +#define ATTR(X) \ case attr::X: \ return getDerived().Transform##X##Attr(cast<X##Attr>(R)); #include "clang/Basic/AttrList.inc" - default: + } + return R; +} + +template <typename Derived> +const Attr *TreeTransform<Derived>::TransformStmtAttr(const Stmt *OrigS, + const Stmt *InstS, + const Attr *R) { + if (!R) return R; + + switch (R->getKind()) { +// Transform attributes by calling TransformStmtXXXAttr. +#define ATTR(X) \ + case attr::X: \ + return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R)); +#include "clang/Basic/AttrList.inc" } + return TransformAttr(R); } template <typename Derived> StmtResult TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S, StmtDiscardKind SDK) { + StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK); + if (SubStmt.isInvalid()) + return StmtError(); + bool AttrsChanged = false; SmallVector<const Attr *, 1> Attrs; // Visit attributes and keep track if any are transformed. for (const auto *I : S->getAttrs()) { - const Attr *R = getDerived().TransformAttr(I); + const Attr *R = + getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I); AttrsChanged |= (I != R); if (R) Attrs.push_back(R); } - StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK); - if (SubStmt.isInvalid()) - return StmtError(); - if (SubStmt.get() == S->getSubStmt() && !AttrsChanged) return S; @@ -7371,16 +7723,19 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { if (Init.isInvalid()) return StmtError(); - // Transform the condition - Sema::ConditionResult Cond = getDerived().TransformCondition( - S->getIfLoc(), S->getConditionVariable(), S->getCond(), - S->isConstexpr() ? Sema::ConditionKind::ConstexprIf - : Sema::ConditionKind::Boolean); - if (Cond.isInvalid()) - return StmtError(); + Sema::ConditionResult Cond; + if (!S->isConsteval()) { + // Transform the condition + Cond = getDerived().TransformCondition( + S->getIfLoc(), S->getConditionVariable(), S->getCond(), + S->isConstexpr() ? Sema::ConditionKind::ConstexprIf + : Sema::ConditionKind::Boolean); + if (Cond.isInvalid()) + return StmtError(); + } // If this is a constexpr if, determine which arm we should instantiate. - llvm::Optional<bool> ConstexprConditionValue; + std::optional<bool> ConstexprConditionValue; if (S->isConstexpr()) ConstexprConditionValue = Cond.getKnownValue(); @@ -7391,7 +7746,11 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { if (Then.isInvalid()) return StmtError(); } else { - Then = new (getSema().Context) NullStmt(S->getThen()->getBeginLoc()); + // Discarded branch is replaced with empty CompoundStmt so we can keep + // proper source location for start and end of original branch, so + // subsequent transformations like CoverageMapping work properly + Then = new (getSema().Context) + CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc()); } // Transform the "else" branch. @@ -7400,6 +7759,13 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { Else = getDerived().TransformStmt(S->getElse()); if (Else.isInvalid()) return StmtError(); + } else if (S->getElse() && ConstexprConditionValue && + *ConstexprConditionValue) { + // Same thing here as with <then> branch, we are discarding it, we can't + // replace it with NULL nor NullStmt as we need to keep for source location + // range, for CoverageMapping + Else = new (getSema().Context) + CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc()); } if (!getDerived().AlwaysRebuild() && @@ -7410,7 +7776,7 @@ TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { return S; return getDerived().RebuildIfStmt( - S->getIfLoc(), S->isConstexpr(), S->getLParenLoc(), Cond, + S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond, S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get()); } @@ -7697,8 +8063,7 @@ TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { template<typename Derived> StmtResult TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { - ArrayRef<Token> AsmToks = - llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); + ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks()); bool HadError = false, HadChange = false; @@ -7726,8 +8091,7 @@ TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { TransformedExprs, S->getEndLoc()); } -// C++ Coroutines TS - +// C++ Coroutines template<typename Derived> StmtResult TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) { @@ -7835,11 +8199,12 @@ TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) { return StmtError(); Builder.Deallocate = DeallocRes.get(); - assert(S->getResultDecl() && "ResultDecl must already be built"); - StmtResult ResultDecl = getDerived().TransformStmt(S->getResultDecl()); - if (ResultDecl.isInvalid()) - return StmtError(); - Builder.ResultDecl = ResultDecl.get(); + if (auto *ResultDecl = S->getResultDecl()) { + StmtResult Res = getDerived().TransformStmt(ResultDecl); + if (Res.isInvalid()) + return StmtError(); + Builder.ResultDecl = Res.get(); + } if (auto *ReturnStmt = S->getReturnStmt()) { StmtResult Res = getDerived().TransformStmt(ReturnStmt); @@ -7866,18 +8231,27 @@ TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) { S->isImplicit()); } -template<typename Derived> -ExprResult -TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) { - ExprResult Result = getDerived().TransformInitializer(E->getOperand(), - /*NotCopyInit*/false); - if (Result.isInvalid()) +template <typename Derived> +ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) { + ExprResult Operand = getDerived().TransformInitializer(E->getOperand(), + /*NotCopyInit*/ false); + if (Operand.isInvalid()) return ExprError(); + // Rebuild the common-expr from the operand rather than transforming it + // separately. + + // FIXME: getCurScope() should not be used during template instantiation. + // We should pick up the set of unqualified lookup results for operator + // co_await during the initial parse. + ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr( + getSema().getCurScope(), E->getKeywordLoc()); + // Always rebuild; we don't know if this needs to be injected into a new // context or if the promise type has changed. - return getDerived().RebuildCoawaitExpr(E->getKeywordLoc(), Result.get(), - E->isImplicit()); + return getDerived().RebuildCoawaitExpr( + E->getKeywordLoc(), Operand.get(), + cast<UnresolvedLookupExpr>(Lookup.get()), E->isImplicit()); } template <typename Derived> @@ -8501,7 +8875,17 @@ StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( return getDerived().RebuildOMPExecutableDirective( D->getDirectiveKind(), DirName, CancelRegion, TClauses, - AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc()); + AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc(), + D->getMappedDirective()); +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) { + // TODO: Fix This + SemaRef.Diag(D->getBeginLoc(), diag::err_omp_instantiation_not_supported) + << getOpenMPDirectiveName(D->getDirectiveKind()); + return StmtError(); } template <typename Derived> @@ -8594,6 +8978,17 @@ TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) { template <typename Derived> StmtResult +TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_scope, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) { DeclarationNameInfo DirName; getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr, @@ -8658,6 +9053,17 @@ StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective( } template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective( + OMPParallelMaskedDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_masked, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective( OMPParallelSectionsDirective *D) { DeclarationNameInfo DirName; @@ -8713,6 +9119,17 @@ TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { } template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_error, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective( OMPTaskgroupDirective *D) { DeclarationNameInfo DirName; @@ -8922,6 +9339,17 @@ StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective( } template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective( + OMPMaskedTaskLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective( OMPMasterTaskLoopSimdDirective *D) { DeclarationNameInfo DirName; @@ -8933,6 +9361,17 @@ StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective( } template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective( + OMPMaskedTaskLoopSimdDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop_simd, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective( OMPParallelMasterTaskLoopDirective *D) { DeclarationNameInfo DirName; @@ -8944,6 +9383,17 @@ StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective( } template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective( + OMPParallelMaskedTaskLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock( + OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective( OMPParallelMasterTaskLoopSimdDirective *D) { @@ -8956,6 +9406,18 @@ TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective( } template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective( + OMPParallelMaskedTaskLoopSimdDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock( + OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective( OMPDistributeDirective *D) { DeclarationNameInfo DirName; @@ -9160,6 +9622,62 @@ TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) { return Res; } +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective( + OMPGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_loop, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_loop, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective( + OMPTargetTeamsGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_target_teams_loop, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective( + OMPParallelGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_loop, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + +template <typename Derived> +StmtResult +TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective( + OMPTargetParallelGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_target_parallel_loop, DirName, + nullptr, D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + //===----------------------------------------------------------------------===// // OpenMP clause transformation //===----------------------------------------------------------------------===// @@ -9383,6 +9901,19 @@ TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) { template <typename Derived> OMPClause * +TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *C) { + // No need to rebuild this clause, no template-dependent parameters. + return C; +} + +template <typename Derived> +OMPClause * TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) { // No need to rebuild this clause, no template-dependent parameters. return C; @@ -9442,17 +9973,17 @@ OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) { if (IVR.isInvalid()) return nullptr; - llvm::SmallVector<Expr *, 8> PrefExprs; - PrefExprs.reserve(C->varlist_size() - 1); + OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync()); + InteropInfo.PreferTypes.reserve(C->varlist_size() - 1); for (Expr *E : llvm::drop_begin(C->varlists())) { ExprResult ER = getDerived().TransformExpr(cast<Expr>(E)); if (ER.isInvalid()) return nullptr; - PrefExprs.push_back(ER.get()); + InteropInfo.PreferTypes.push_back(ER.get()); } - return getDerived().RebuildOMPInitClause( - IVR.get(), PrefExprs, C->getIsTarget(), C->getIsTargetSync(), - C->getBeginLoc(), C->getLParenLoc(), C->getVarLoc(), C->getEndLoc()); + return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo, + C->getBeginLoc(), C->getLParenLoc(), + C->getVarLoc(), C->getEndLoc()); } template <typename Derived> @@ -9510,6 +10041,15 @@ TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) { } template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) { + ExprResult E = getDerived().TransformExpr(C->getAlignment()); + if (E.isInvalid()) + return nullptr; + return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(), + C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause( OMPUnifiedAddressClause *C) { llvm_unreachable("unified_address clause cannot appear in dependent context"); @@ -9543,6 +10083,32 @@ OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause( } template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *C) { + return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(), + C->getBeginLoc(), C->getLParenLoc(), + C->getEndLoc()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *C) { + return getDerived().RebuildOMPSeverityClause( + C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(), + C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) { + ExprResult E = getDerived().TransformExpr(C->getMessageString()); + if (E.isInvalid()) + return nullptr; + return getDerived().RebuildOMPMessageClause( + C->getMessageString(), C->getBeginLoc(), C->getLParenLoc(), + C->getEndLoc()); +} + +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { llvm::SmallVector<Expr *, 16> Vars; @@ -9757,7 +10323,8 @@ TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) { return nullptr; return getDerived().RebuildOMPLinearClause( Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(), - C->getModifierLoc(), C->getColonLoc(), C->getEndLoc()); + C->getModifierLoc(), C->getColonLoc(), C->getStepModifierLoc(), + C->getEndLoc()); } template <typename Derived> @@ -9852,9 +10419,9 @@ TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) { Vars.push_back(EVar.get()); } return getDerived().RebuildOMPDependClause( - DepModifier, C->getDependencyKind(), C->getDependencyLoc(), - C->getColonLoc(), Vars, C->getBeginLoc(), C->getLParenLoc(), - C->getEndLoc()); + {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(), + C->getOmpAllMemoryLoc()}, + DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); } template <typename Derived> @@ -9925,6 +10492,13 @@ template <typename Derived> OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) { OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); llvm::SmallVector<Expr *, 16> Vars; + Expr *IteratorModifier = C->getIteratorModifier(); + if (IteratorModifier) { + ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier); + if (MapModRes.isInvalid()) + return nullptr; + IteratorModifier = MapModRes.get(); + } CXXScopeSpec MapperIdScopeSpec; DeclarationNameInfo MapperIdInfo; llvm::SmallVector<Expr *, 16> UnresolvedMappers; @@ -9932,9 +10506,9 @@ OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) { *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers)) return nullptr; return getDerived().RebuildOMPMapClause( - C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), MapperIdScopeSpec, - MapperIdInfo, C->getMapType(), C->isImplicitMapType(), C->getMapLoc(), - C->getColonLoc(), Vars, Locs, UnresolvedMappers); + IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(), + MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(), + C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers); } template <typename Derived> @@ -9997,7 +10571,8 @@ TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) { if (E.isInvalid()) return nullptr; return getDerived().RebuildOMPGrainsizeClause( - E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); + C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), + C->getModifierLoc(), C->getEndLoc()); } template <typename Derived> @@ -10007,7 +10582,8 @@ TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) { if (E.isInvalid()) return nullptr; return getDerived().RebuildOMPNumTasksClause( - E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); + C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(), + C->getModifierLoc(), C->getEndLoc()); } template <typename Derived> @@ -10120,6 +10696,21 @@ TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) { } template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause( + OMPHasDeviceAddrClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); + return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs); +} + +template <typename Derived> OMPClause * TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) { llvm::SmallVector<Expr *, 16> Vars; @@ -10214,9 +10805,57 @@ TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) { template <typename Derived> OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) { - return getDerived().RebuildOMPOrderClause(C->getKind(), C->getKindKwLoc(), - C->getBeginLoc(), C->getLParenLoc(), - C->getEndLoc()); + return getDerived().RebuildOMPOrderClause( + C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(), + C->getEndLoc(), C->getModifier(), C->getModifierKwLoc()); +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) { + return getDerived().RebuildOMPBindClause( + C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(), + C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause( + OMPXDynCGroupMemClause *C) { + ExprResult Size = getDerived().TransformExpr(C->getSize()); + if (Size.isInvalid()) + return nullptr; + return getDerived().RebuildOMPXDynCGroupMemClause( + Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPDoacrossClause(OMPDoacrossClause *C) { + llvm::SmallVector<Expr *, 16> Vars; + Vars.reserve(C->varlist_size()); + for (auto *VE : C->varlists()) { + ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); + if (EVar.isInvalid()) + return nullptr; + Vars.push_back(EVar.get()); + } + return getDerived().RebuildOMPDoacrossClause( + C->getDependenceType(), C->getDependenceLoc(), C->getColonLoc(), Vars, + C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> +OMPClause * +TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *C) { + SmallVector<const Attr *> NewAttrs; + for (auto *A : C->getAttrs()) + NewAttrs.push_back(getDerived().TransformAttr(A)); + return getDerived().RebuildOMPXAttributeClause( + NewAttrs, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc()); +} + +template <typename Derived> +OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *C) { + return getDerived().RebuildOMPXBareClause(C->getBeginLoc(), C->getEndLoc()); } //===----------------------------------------------------------------------===// @@ -10356,17 +10995,20 @@ TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { template<typename Derived> ExprResult TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { - if (FunctionDecl *FD = E->getDirectCallee()) - SemaRef.MarkFunctionReferenced(E->getBeginLoc(), FD); - return SemaRef.MaybeBindToTemporary(E); + return getDerived().TransformCallExpr(E); } template<typename Derived> ExprResult TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { - ExprResult ControllingExpr = - getDerived().TransformExpr(E->getControllingExpr()); - if (ControllingExpr.isInvalid()) + ExprResult ControllingExpr; + TypeSourceInfo *ControllingType = nullptr; + if (E->isExprPredicate()) + ControllingExpr = getDerived().TransformExpr(E->getControllingExpr()); + else + ControllingType = getDerived().TransformType(E->getControllingType()); + + if (ControllingExpr.isInvalid() && !ControllingType) return ExprError(); SmallVector<Expr *, 4> AssocExprs; @@ -10389,12 +11031,16 @@ TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { AssocExprs.push_back(AssocExpr.get()); } + if (!ControllingType) return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(), ControllingExpr.get(), AssocTypes, AssocExprs); + return getDerived().RebuildGenericSelectionExpr( + E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(), + ControllingType, AssocTypes, AssocExprs); } template<typename Derived> @@ -10857,11 +11503,15 @@ TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { FoundDecl == E->getFoundDecl() && !E->hasExplicitTemplateArgs()) { - // Mark it referenced in the new context regardless. - // FIXME: this is a bit instantiation-specific. - SemaRef.MarkMemberReferenced(E); - - return E; + // Skip for member expression of (this->f), rebuilt thisi->f is needed + // for Openmp where the field need to be privatizized in the case. + if (!(isa<CXXThisExpr>(E->getBase()) && + getSema().isOpenMPRebuildMemberExpr(cast<ValueDecl>(Member)))) { + // Mark it referenced in the new context regardless. + // FIXME: this is a bit instantiation-specific. + SemaRef.MarkMemberReferenced(E); + return E; + } } TemplateArgumentListInfo TransArgs; @@ -10909,7 +11559,8 @@ TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { if (LHS.isInvalid()) return ExprError(); - ExprResult RHS = getDerived().TransformExpr(E->getRHS()); + ExprResult RHS = + getDerived().TransformInitializer(E->getRHS(), /*NotCopyInit=*/false); if (RHS.isInvalid()) return ExprError(); @@ -10923,7 +11574,7 @@ TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { return getDerived().RebuildBinaryOperator( E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get()); Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); - FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts())); + FPOptionsOverride NewOverrides(E->getFPFeatures()); getSema().CurFPFeatures = NewOverrides.applyOverrides(getSema().getLangOpts()); getSema().FpPragmaStack.CurrentValue = NewOverrides; @@ -10944,14 +11595,10 @@ ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator( if (RHS.isInvalid()) return ExprError(); - if (!getDerived().AlwaysRebuild() && - LHS.get() == Decomp.LHS && - RHS.get() == Decomp.RHS) - return E; - // Extract the already-resolved callee declarations so that we can restrict // ourselves to using them as the unqualified lookup results when rebuilding. UnresolvedSet<2> UnqualLookups; + bool ChangedAnyLookups = false; Expr *PossibleBinOps[] = {E->getSemanticForm(), const_cast<Expr *>(Decomp.InnerBinOp)}; for (Expr *PossibleBinOp : PossibleBinOps) { @@ -10968,9 +11615,23 @@ ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator( E->getOperatorLoc(), Callee->getFoundDecl())); if (!Found) return ExprError(); + if (Found != Callee->getFoundDecl()) + ChangedAnyLookups = true; UnqualLookups.addDecl(Found); } + if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups && + LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) { + // Mark all functions used in the rewrite as referenced. Note that when + // a < b is rewritten to (a <=> b) < 0, both the <=> and the < might be + // function calls, and/or there might be a user-defined conversion sequence + // applied to the operands of the <. + // FIXME: this is a bit instantiation-specific. + const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS}; + SemaRef.MarkDeclarationsReferencedInExpr(E, false, StopAt); + return E; + } + return getDerived().RebuildCXXRewrittenBinaryOperator( E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get()); } @@ -10980,7 +11641,7 @@ ExprResult TreeTransform<Derived>::TransformCompoundAssignOperator( CompoundAssignOperator *E) { Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); - FPOptionsOverride NewOverrides(E->getFPFeatures(getSema().getLangOpts())); + FPOptionsOverride NewOverrides(E->getFPFeatures()); getSema().CurFPFeatures = NewOverrides.applyOverrides(getSema().getLangOpts()); getSema().FpPragmaStack.CurrentValue = NewOverrides; @@ -11112,9 +11773,9 @@ TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { // FIXME: Bad source location SourceLocation FakeOperatorLoc = SemaRef.getLocForEndOfToken(E->getBase()->getEndLoc()); - return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, - E->getAccessorLoc(), - E->getAccessor()); + return getDerived().RebuildExtVectorElementExpr( + Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(), + E->getAccessor()); } template<typename Derived> @@ -11159,22 +11820,23 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { bool ExprChanged = false; for (const DesignatedInitExpr::Designator &D : E->designators()) { if (D.isFieldDesignator()) { - Desig.AddDesignator(Designator::getField(D.getFieldName(), - D.getDotLoc(), - D.getFieldLoc())); - if (D.getField()) { + if (D.getFieldDecl()) { FieldDecl *Field = cast_or_null<FieldDecl>( - getDerived().TransformDecl(D.getFieldLoc(), D.getField())); - if (Field != D.getField()) + getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl())); + if (Field != D.getFieldDecl()) // Rebuild the expression when the transformed FieldDecl is // different to the already assigned FieldDecl. ExprChanged = true; + if (Field->isAnonymousStructOrUnion()) + continue; } else { // Ensure that the designator expression is rebuilt when there isn't // a resolved FieldDecl in the designator as we don't want to assign // a FieldDecl to a pattern designator that will be instantiated again. ExprChanged = true; } + Desig.AddDesignator(Designator::CreateFieldDesignator( + D.getFieldName(), D.getDotLoc(), D.getFieldLoc())); continue; } @@ -11184,7 +11846,7 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { return ExprError(); Desig.AddDesignator( - Designator::getArray(Index.get(), D.getLBracketLoc())); + Designator::CreateArrayDesignator(Index.get(), D.getLBracketLoc())); ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D); ArrayExprs.push_back(Index.get()); @@ -11201,10 +11863,8 @@ TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { if (End.isInvalid()) return ExprError(); - Desig.AddDesignator(Designator::getArrayRange(Start.get(), - End.get(), - D.getLBracketLoc(), - D.getEllipsisLoc())); + Desig.AddDesignator(Designator::CreateArrayRangeDesignator( + Start.get(), End.get(), D.getLBracketLoc(), D.getEllipsisLoc())); ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) || End.get() != E->getArrayRangeEnd(D); @@ -11393,6 +12053,7 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { case OO_Array_Delete: llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); + case OO_Subscript: case OO_Call: { // This is a call to an object's operator(). assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); @@ -11412,17 +12073,20 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { Args)) return ExprError(); + if (E->getOperator() == OO_Subscript) + return getDerived().RebuildCxxSubscriptExpr(Object.get(), FakeLParenLoc, + Args, E->getEndLoc()); + return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args, E->getEndLoc()); } -#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ - case OO_##Name: +#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ + case OO_##Name: \ + break; + #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) #include "clang/Basic/OperatorKinds.def" - case OO_Subscript: - // Handled below. - break; case OO_Conditional: llvm_unreachable("conditional operator is not actually overloadable"); @@ -11432,10 +12096,6 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { llvm_unreachable("not an overloaded operator?"); } - ExprResult Callee = getDerived().TransformExpr(E->getCallee()); - if (Callee.isInvalid()) - return ExprError(); - ExprResult First; if (E->getOperator() == OO_Amp) First = getDerived().TransformAddressOfOperand(E->getArg(0)); @@ -11446,28 +12106,45 @@ TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { ExprResult Second; if (E->getNumArgs() == 2) { - Second = getDerived().TransformExpr(E->getArg(1)); + Second = + getDerived().TransformInitializer(E->getArg(1), /*NotCopyInit=*/false); if (Second.isInvalid()) return ExprError(); } - if (!getDerived().AlwaysRebuild() && - Callee.get() == E->getCallee() && - First.get() == E->getArg(0) && - (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) - return SemaRef.MaybeBindToTemporary(E); - Sema::FPFeaturesStateRAII FPFeaturesState(getSema()); FPOptionsOverride NewOverrides(E->getFPFeatures()); getSema().CurFPFeatures = NewOverrides.applyOverrides(getSema().getLangOpts()); getSema().FpPragmaStack.CurrentValue = NewOverrides; - return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), - E->getOperatorLoc(), - Callee.get(), - First.get(), - Second.get()); + Expr *Callee = E->getCallee(); + if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { + LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(), + Sema::LookupOrdinaryName); + if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R)) + return ExprError(); + + return getDerived().RebuildCXXOperatorCallExpr( + E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(), + ULE->requiresADL(), R.asUnresolvedSet(), First.get(), Second.get()); + } + + UnresolvedSet<1> Functions; + if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) + Callee = ICE->getSubExprAsWritten(); + NamedDecl *DR = cast<DeclRefExpr>(Callee)->getDecl(); + ValueDecl *VD = cast_or_null<ValueDecl>( + getDerived().TransformDecl(DR->getLocation(), DR)); + if (!VD) + return ExprError(); + + if (!isa<CXXMethodDecl>(VD)) + Functions.addDecl(VD); + + return getDerived().RebuildCXXOperatorCallExpr( + E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(), + /*RequiresADL=*/false, Functions, First.get(), Second.get()); } template<typename Derived> @@ -11478,14 +12155,14 @@ TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { template <typename Derived> ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) { - bool NeedRebuildFunc = E->getIdentKind() == SourceLocExpr::Function && + bool NeedRebuildFunc = SourceLocExpr::MayBeDependent(E->getIdentKind()) && getSema().CurContext != E->getParentContext(); if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc) return E; - return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getBeginLoc(), - E->getEndLoc(), + return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(), + E->getBeginLoc(), E->getEndLoc(), getSema().CurContext); } @@ -11708,7 +12385,16 @@ TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { - QualType T = getSema().getCurrentThisType(); + + // In lambdas, the qualifiers of the type depends of where in + // the call operator `this` appear, and we do not have a good way to + // rebuild this information, so we transform the type. + // + // In other contexts, the type of `this` may be overrided + // for type deduction, so we need to recompute it. + QualType T = getSema().getCurLambda() ? + getDerived().TransformType(E->getType()) + : getSema().getCurrentThisType(); if (!getDerived().AlwaysRebuild() && T == E->getType()) { // Mark it referenced in the new context regardless. @@ -11743,11 +12429,20 @@ TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { if (!Param) return ExprError(); + ExprResult InitRes; + if (E->hasRewrittenInit()) { + InitRes = getDerived().TransformExpr(E->getRewrittenExpr()); + if (InitRes.isInvalid()) + return ExprError(); + } + if (!getDerived().AlwaysRebuild() && Param == E->getParam() && - E->getUsedContext() == SemaRef.CurContext) + E->getUsedContext() == SemaRef.CurContext && + InitRes.get() == E->getRewrittenExpr()) return E; - return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); + return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param, + InitRes.get()); } template<typename Derived> @@ -11792,10 +12487,10 @@ TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { return ExprError(); // Transform the size of the array we're allocating (if any). - Optional<Expr *> ArraySize; - if (Optional<Expr *> OldArraySize = E->getArraySize()) { + std::optional<Expr *> ArraySize; + if (E->isArray()) { ExprResult NewArraySize; - if (*OldArraySize) { + if (std::optional<Expr *> OldArraySize = E->getArraySize()) { NewArraySize = getDerived().TransformExpr(*OldArraySize); if (NewArraySize.isInvalid()) return ExprError(); @@ -11981,12 +12676,9 @@ TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( E->getDestroyedTypeLoc()); } else { // Look for a destructor known with the given name. - ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), - *E->getDestroyedTypeIdentifier(), - E->getDestroyedTypeLoc(), - /*Scope=*/nullptr, - SS, ObjectTypePtr, - false); + ParsedType T = SemaRef.getDestructorName( + *E->getDestroyedTypeIdentifier(), E->getDestroyedTypeLoc(), + /*Scope=*/nullptr, SS, ObjectTypePtr, false); if (!T) return ExprError(); @@ -12174,9 +12866,9 @@ TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = + std::optional<unsigned> OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(), Unexpanded, @@ -12297,7 +12989,8 @@ TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { // C++2a [expr.prim.req]p2 // Expressions appearing within a requirement-body are unevaluated operands. EnterExpressionEvaluationContext Ctx( - SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); + SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, + Sema::ReuseLambdaContextDecl); RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create( getSema().Context, getSema().CurContext, @@ -12305,16 +12998,20 @@ TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false); - if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(), - E->getLocalParameters(), - /*ParamTypes=*/nullptr, - /*ParamInfos=*/nullptr, - TransParamTypes, &TransParams, - ExtParamInfos)) - return ExprError(); + ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams( + E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body, + E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos); for (ParmVarDecl *Param : TransParams) - Param->setDeclContext(Body); + if (Param) + Param->setDeclContext(Body); + + // On failure to transform, TransformRequiresTypeParams returns an expression + // in the event that the transformation of the type params failed in some way. + // It is expected that this will result in a 'not satisfied' Requires clause + // when instantiating. + if (!TypeParamResult.isUnset()) + return TypeParamResult; SmallVector<concepts::Requirement *, 4> TransReqs; if (getDerived().TransformRequiresExprRequirements(E->getRequirements(), @@ -12331,9 +13028,9 @@ TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) { } } - return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body, - TransParams, TransReqs, - E->getRBraceLoc()); + return getDerived().RebuildRequiresExpr( + E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams, + E->getRParenLoc(), TransReqs, E->getRBraceLoc()); } template<typename Derived> @@ -12380,12 +13077,14 @@ TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) TransExpr = Req->getExprSubstitutionDiagnostic(); else { ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr()); + if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType()) + TransExprRes = SemaRef.CheckPlaceholderExpr(TransExprRes.get()); if (TransExprRes.isInvalid()) return nullptr; TransExpr = TransExprRes.get(); } - llvm::Optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq; + std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq; const auto &RetReq = Req->getReturnTypeRequirement(); if (RetReq.isEmpty()) TransRetReq.emplace(); @@ -12400,8 +13099,7 @@ TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) return nullptr; TransRetReq.emplace(TPL); } - assert(TransRetReq.hasValue() && - "All code paths leading here must set TransRetReq"); + assert(TransRetReq && "All code paths leading here must set TransRetReq"); if (Expr *E = TransExpr.dyn_cast<Expr *>()) return getDerived().RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(), @@ -12415,10 +13113,10 @@ template<typename Derived> concepts::NestedRequirement * TreeTransform<Derived>::TransformNestedRequirement( concepts::NestedRequirement *Req) { - if (Req->isSubstitutionFailure()) { + if (Req->hasInvalidConstraint()) { if (getDerived().AlwaysRebuild()) return getDerived().RebuildNestedRequirement( - Req->getSubstitutionDiagnostic()); + Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction()); return Req; } ExprResult TransConstraint = @@ -12627,6 +13325,9 @@ ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr( template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { + if (auto *Dtor = E->getTemporary()->getDestructor()) + SemaRef.MarkFunctionReferenced(E->getBeginLoc(), + const_cast<CXXDestructorDecl *>(Dtor)); return getDerived().TransformExpr(E->getSubExpr()); } @@ -12705,10 +13406,10 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { continue; TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()]; - VarDecl *OldVD = C->getCapturedVar(); + auto *OldVD = cast<VarDecl>(C->getCapturedVar()); auto SubstInitCapture = [&](SourceLocation EllipsisLoc, - Optional<unsigned> NumExpansions) { + std::optional<unsigned> NumExpansions) { ExprResult NewExprInitResult = getDerived().TransformInitializer( OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit); @@ -12720,9 +13421,10 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { QualType NewInitCaptureType = getSema().buildLambdaInitCaptureInitialization( - C->getLocation(), OldVD->getType()->isReferenceType(), + C->getLocation(), C->getCaptureKind() == LCK_ByRef, EllipsisLoc, NumExpansions, OldVD->getIdentifier(), - C->getCapturedVar()->getInitStyle() != VarDecl::CInit, + cast<VarDecl>(C->getCapturedVar())->getInitStyle() != + VarDecl::CInit, NewExprInit); Result.Expansions.push_back( InitCaptureInfoTy(NewExprInit, NewInitCaptureType)); @@ -12740,9 +13442,9 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = + std::optional<unsigned> OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions(); - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks( ExpansionTL.getEllipsisLoc(), OldVD->getInit()->getSourceRange(), Unexpanded, Expand, @@ -12751,7 +13453,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { if (Expand) { for (unsigned I = 0; I != *NumExpansions; ++I) { Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); - SubstInitCapture(SourceLocation(), None); + SubstInitCapture(SourceLocation(), std::nullopt); } } if (!Expand || RetainExpansion) { @@ -12760,98 +13462,47 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { Result.EllipsisLoc = ExpansionTL.getEllipsisLoc(); } } else { - SubstInitCapture(SourceLocation(), None); + SubstInitCapture(SourceLocation(), std::nullopt); } } LambdaScopeInfo *LSI = getSema().PushLambdaScope(); Sema::FunctionScopeRAII FuncScopeCleanup(getSema()); - // Transform the template parameters, and add them to the current - // instantiation scope. The null case is handled correctly. - auto TPL = getDerived().TransformTemplateParameterList( - E->getTemplateParameterList()); - LSI->GLTemplateParameterList = TPL; - - // Transform the type of the original lambda's call operator. - // The transformation MUST be done in the CurrentInstantiationScope since - // it introduces a mapping of the original to the newly created - // transformed parameters. - TypeSourceInfo *NewCallOpTSI = nullptr; - { - TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo(); - FunctionProtoTypeLoc OldCallOpFPTL = - OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); - - TypeLocBuilder NewCallOpTLBuilder; - SmallVector<QualType, 4> ExceptionStorage; - TreeTransform *This = this; // Work around gcc.gnu.org/PR56135. - QualType NewCallOpType = TransformFunctionProtoType( - NewCallOpTLBuilder, OldCallOpFPTL, nullptr, Qualifiers(), - [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { - return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI, - ExceptionStorage, Changed); - }); - if (NewCallOpType.isNull()) - return ExprError(); - NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, - NewCallOpType); - } + // Create the local class that will describe the lambda. - // Transform the trailing requires clause - ExprResult NewTrailingRequiresClause; - if (Expr *TRC = E->getCallOperator()->getTrailingRequiresClause()) - // FIXME: Concepts: Substitution into requires clause should only happen - // when checking satisfaction. - NewTrailingRequiresClause = getDerived().TransformExpr(TRC); + // FIXME: DependencyKind below is wrong when substituting inside a templated + // context that isn't a DeclContext (such as a variable template), or when + // substituting an unevaluated lambda inside of a function's parameter's type + // - as parameter types are not instantiated from within a function's DC. We + // use evaluation contexts to distinguish the function parameter case. + CXXRecordDecl::LambdaDependencyKind DependencyKind = + CXXRecordDecl::LDK_Unknown; + if ((getSema().isUnevaluatedContext() || + getSema().isConstantEvaluatedContext()) && + (getSema().CurContext->isFileContext() || + !getSema().CurContext->getParent()->isDependentContext())) + DependencyKind = CXXRecordDecl::LDK_NeverDependent; - // Create the local class that will describe the lambda. - // FIXME: KnownDependent below is wrong when substituting inside a templated - // context that isn't a DeclContext (such as a variable template). CXXRecordDecl *OldClass = E->getLambdaClass(); - CXXRecordDecl *Class - = getSema().createLambdaClosureType(E->getIntroducerRange(), - NewCallOpTSI, - /*KnownDependent=*/false, - E->getCaptureDefault()); + CXXRecordDecl *Class = getSema().createLambdaClosureType( + E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind, + E->getCaptureDefault()); getDerived().transformedLocalDecl(OldClass, {Class}); - Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling; - if (getDerived().ReplacingOriginal()) - Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(), - OldClass->getLambdaManglingNumber(), - OldClass->getDeviceLambdaManglingNumber(), - OldClass->getLambdaContextDecl()); - - // Build the call operator. - CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition( - Class, E->getIntroducerRange(), NewCallOpTSI, - E->getCallOperator()->getEndLoc(), - NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(), - E->getCallOperator()->getConstexprKind(), - NewTrailingRequiresClause.get()); - - LSI->CallOperator = NewCallOperator; - - getDerived().transformAttrs(E->getCallOperator(), NewCallOperator); - getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator}); + CXXMethodDecl *NewCallOperator = + getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class); + NewCallOperator->setLexicalDeclContext(getSema().CurContext); - // Number the lambda for linkage purposes if necessary. - getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling); + // Enter the scope of the lambda. + getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(), + E->getCaptureDefault(), E->getCaptureDefaultLoc(), + E->hasExplicitParameters(), E->isMutable()); // Introduce the context of the call operator. Sema::ContextRAII SavedContext(getSema(), NewCallOperator, /*NewThisContext*/false); - // Enter the scope of the lambda. - getSema().buildLambdaScope(LSI, NewCallOperator, - E->getIntroducerRange(), - E->getCaptureDefault(), - E->getCaptureDefaultLoc(), - E->hasExplicitParameters(), - E->hasExplicitResultType(), - E->isMutable()); - bool Invalid = false; // Transform captures. @@ -12865,6 +13516,16 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { // Capturing 'this' is trivial. if (C->capturesThis()) { + // If this is a lambda that is part of a default member initialiser + // and which we're instantiating outside the class that 'this' is + // supposed to refer to, adjust the type of 'this' accordingly. + // + // Otherwise, leave the type of 'this' as-is. + Sema::CXXThisScopeRAII ThisScope( + getSema(), + dyn_cast_if_present<CXXRecordDecl>( + getSema().getFunctionLevelDeclContext()), + Qualifiers()); getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(), /*BuildAndDiagnose*/ true, nullptr, C->getCaptureKind() == LCK_StarThis); @@ -12879,7 +13540,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { if (E->isInitCapture(C)) { TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()]; - VarDecl *OldVD = C->getCapturedVar(); + auto *OldVD = cast<VarDecl>(C->getCapturedVar()); llvm::SmallVector<Decl*, 4> NewVDs; for (InitCaptureInfoTy &Info : NewC.Expansions) { @@ -12891,13 +13552,14 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { } VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl( OldVD->getLocation(), InitQualType, NewC.EllipsisLoc, - OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get()); + OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(), + getSema().CurContext); if (!NewVD) { Invalid = true; break; } NewVDs.push_back(NewVD); - getSema().addInitCapture(LSI, NewVD); + getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef); } if (Invalid) @@ -12920,7 +13582,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), C->getLocation(), Unexpanded, @@ -12934,7 +13596,7 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { // The transform has determined that we should perform an expansion; // transform and capture each of the arguments. // expansion of the pattern. Do so. - VarDecl *Pack = C->getCapturedVar(); + auto *Pack = cast<VarDecl>(C->getCapturedVar()); for (unsigned I = 0; I != *NumExpansions; ++I) { Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); VarDecl *CapturedVar @@ -12958,9 +13620,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { } // Transform the captured variable. - VarDecl *CapturedVar - = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), - C->getCapturedVar())); + auto *CapturedVar = cast_or_null<ValueDecl>( + getDerived().TransformDecl(C->getLocation(), C->getCapturedVar())); if (!CapturedVar || CapturedVar->isInvalidDecl()) { Invalid = true; continue; @@ -12972,15 +13633,103 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { } getSema().finishLambdaExplicitCaptures(LSI); + // Transform the template parameters, and add them to the current + // instantiation scope. The null case is handled correctly. + auto TPL = getDerived().TransformTemplateParameterList( + E->getTemplateParameterList()); + LSI->GLTemplateParameterList = TPL; + if (TPL) + getSema().AddTemplateParametersToLambdaCallOperator(NewCallOperator, Class, + TPL); + + // Transform the type of the original lambda's call operator. + // The transformation MUST be done in the CurrentInstantiationScope since + // it introduces a mapping of the original to the newly created + // transformed parameters. + TypeSourceInfo *NewCallOpTSI = nullptr; + { + auto OldCallOpTypeLoc = + E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); + + auto TransformFunctionProtoTypeLoc = + [this](TypeLocBuilder &TLB, FunctionProtoTypeLoc FPTL) -> QualType { + SmallVector<QualType, 4> ExceptionStorage; + return this->TransformFunctionProtoType( + TLB, FPTL, nullptr, Qualifiers(), + [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { + return TransformExceptionSpec(FPTL.getBeginLoc(), ESI, + ExceptionStorage, Changed); + }); + }; + + QualType NewCallOpType; + TypeLocBuilder NewCallOpTLBuilder; + + if (auto ATL = OldCallOpTypeLoc.getAs<AttributedTypeLoc>()) { + NewCallOpType = this->TransformAttributedType( + NewCallOpTLBuilder, ATL, + [&](TypeLocBuilder &TLB, TypeLoc TL) -> QualType { + return TransformFunctionProtoTypeLoc( + TLB, TL.castAs<FunctionProtoTypeLoc>()); + }); + } else { + auto FPTL = OldCallOpTypeLoc.castAs<FunctionProtoTypeLoc>(); + NewCallOpType = TransformFunctionProtoTypeLoc(NewCallOpTLBuilder, FPTL); + } + + if (NewCallOpType.isNull()) + return ExprError(); + NewCallOpTSI = + NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, NewCallOpType); + } + + ArrayRef<ParmVarDecl *> Params; + if (auto ATL = NewCallOpTSI->getTypeLoc().getAs<AttributedTypeLoc>()) { + Params = ATL.getModifiedLoc().castAs<FunctionProtoTypeLoc>().getParams(); + } else { + auto FPTL = NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>(); + Params = FPTL.getParams(); + } + + getSema().CompleteLambdaCallOperator( + NewCallOperator, E->getCallOperator()->getLocation(), + E->getCallOperator()->getInnerLocStart(), + E->getCallOperator()->getTrailingRequiresClause(), NewCallOpTSI, + E->getCallOperator()->getConstexprKind(), + E->getCallOperator()->getStorageClass(), Params, + E->hasExplicitResultType()); + + getDerived().transformAttrs(E->getCallOperator(), NewCallOperator); + getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator}); + + { + // Number the lambda for linkage purposes if necessary. + Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext()); + + std::optional<CXXRecordDecl::LambdaNumbering> Numbering; + if (getDerived().ReplacingOriginal()) { + Numbering = OldClass->getLambdaNumbering(); + } + + getSema().handleLambdaNumbering(Class, NewCallOperator, Numbering); + } + // FIXME: Sema's lambda-building mechanism expects us to push an expression // evaluation context even if we're not transforming the function body. getSema().PushExpressionEvaluationContext( Sema::ExpressionEvaluationContext::PotentiallyEvaluated); + Sema::CodeSynthesisContext C; + C.Kind = clang::Sema::CodeSynthesisContext::LambdaExpressionSubstitution; + C.PointOfInstantiation = E->getBody()->getBeginLoc(); + getSema().pushCodeSynthesisContext(C); + // Instantiate the body of the lambda expression. StmtResult Body = Invalid ? StmtError() : getDerived().TransformLambdaBody(E, E->getBody()); + getSema().popCodeSynthesisContext(); + // ActOnLambda* will pop the function scope for us. FuncScopeCleanup.disable(); @@ -13297,7 +14046,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); bool ShouldExpand = false; bool RetainExpansion = false; - Optional<unsigned> NumExpansions; + std::optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), Unexpanded, ShouldExpand, RetainExpansion, @@ -13310,9 +14059,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { auto *Pack = E->getPack(); if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Pack)) { ArgStorage = getSema().Context.getPackExpansionType( - getSema().Context.getTypeDeclType(TTPD), None); + getSema().Context.getTypeDeclType(TTPD), std::nullopt); } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Pack)) { - ArgStorage = TemplateArgument(TemplateName(TTPD), None); + ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt); } else { auto *VD = cast<ValueDecl>(Pack); ExprResult DRE = getSema().BuildDeclRefExpr( @@ -13321,8 +14070,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { E->getPackLoc()); if (DRE.isInvalid()) return ExprError(); - ArgStorage = new (getSema().Context) PackExpansionExpr( - getSema().Context.DependentTy, DRE.get(), E->getPackLoc(), None); + ArgStorage = new (getSema().Context) + PackExpansionExpr(getSema().Context.DependentTy, DRE.get(), + E->getPackLoc(), std::nullopt); } PackArgs = ArgStorage; } @@ -13334,13 +14084,13 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { getDerived().TransformDecl(E->getPackLoc(), E->getPack())); if (!Pack) return ExprError(); - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, - E->getPackLoc(), - E->getRParenLoc(), None, None); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(), + std::nullopt, std::nullopt); } // Try to compute the result without performing a partial substitution. - Optional<unsigned> Result = 0; + std::optional<unsigned> Result = 0; for (const TemplateArgument &Arg : PackArgs) { if (!Arg.isPackExpansion()) { Result = *Result + 1; @@ -13352,7 +14102,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { // Find the pattern of the pack expansion. SourceLocation Ellipsis; - Optional<unsigned> OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions; TemplateArgumentLoc Pattern = getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis, OrigNumExpansions); @@ -13365,12 +14115,12 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { return true; // See if we can determine the number of arguments from the result. - Optional<unsigned> NumExpansions = + std::optional<unsigned> NumExpansions = getSema().getFullyPackExpandedSize(OutPattern.getArgument()); if (!NumExpansions) { // No: we must be in an alias template expansion, and we're going to need // to actually expand the packs. - Result = None; + Result = std::nullopt; break; } @@ -13380,9 +14130,9 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { // Common case: we could determine the number of expansions without // substituting. if (Result) - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), - E->getPackLoc(), - E->getRParenLoc(), *Result, None); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), + *Result, std::nullopt); TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(), E->getPackLoc()); @@ -13407,13 +14157,13 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { } if (PartialSubstitution) - return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), - E->getPackLoc(), - E->getRParenLoc(), None, Args); + return getDerived().RebuildSizeOfPackExpr( + E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), + std::nullopt, Args); return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(), - Args.size(), None); + Args.size(), std::nullopt); } template<typename Derived> @@ -13467,8 +14217,8 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = E->getNumExpansions(), - NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = E->getNumExpansions(), + NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -13553,13 +14303,17 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { // We've got down to a single element; build a binary operator. Expr *LHS = LeftFold ? Result.get() : Out.get(); Expr *RHS = LeftFold ? Out.get() : Result.get(); - if (Callee) + if (Callee) { + UnresolvedSet<16> Functions; + Functions.append(Callee->decls_begin(), Callee->decls_end()); Result = getDerived().RebuildCXXOperatorCallExpr( BinaryOperator::getOverloadedOperator(E->getOperator()), - E->getEllipsisLoc(), Callee, LHS, RHS); - else + E->getEllipsisLoc(), Callee->getBeginLoc(), Callee->requiresADL(), + Functions, LHS, RHS); + } else { Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(), E->getOperator(), LHS, RHS); + } } else Result = Out; @@ -13592,6 +14346,19 @@ TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { return Result; } +template <typename Derived> +ExprResult +TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) { + SmallVector<Expr *, 4> TransformedInits; + ArrayRef<Expr *> InitExprs = E->getInitExprs(); + if (TransformExprs(InitExprs.data(), InitExprs.size(), true, + TransformedInits)) + return ExprError(); + + return getDerived().RebuildParenListExpr(E->getBeginLoc(), TransformedInits, + E->getEndLoc()); +} + template<typename Derived> ExprResult TreeTransform<Derived>::TransformCXXStdInitializerListExpr( @@ -13664,8 +14431,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( // and should be expanded. bool Expand = true; bool RetainExpansion = false; - Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; - Optional<unsigned> NumExpansions = OrigNumExpansions; + std::optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; + std::optional<unsigned> NumExpansions = OrigNumExpansions; SourceRange PatternRange(OrigElement.Key->getBeginLoc(), OrigElement.Value->getEndLoc()); if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, @@ -13752,9 +14519,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( if (Value.get() != OrigElement.Value) ArgChanged = true; - ObjCDictionaryElement Element = { - Key.get(), Value.get(), SourceLocation(), None - }; + ObjCDictionaryElement Element = {Key.get(), Value.get(), SourceLocation(), + std::nullopt}; Elements.push_back(Element); } @@ -14112,7 +14878,12 @@ TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { oldCapture)); assert(blockScope->CaptureMap.count(newCapture)); } - assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()); + + // The this pointer may not be captured by the instantiated block, even when + // it's captured by the original block, if the expression causing the + // capture is in the discarded branch of a constexpr if statement. + assert((!blockScope->isCXXThisCaptured() || oldBlock->capturesCXXThis()) && + "this pointer isn't captured in the old block"); } #endif @@ -14211,11 +14982,11 @@ QualType TreeTransform<Derived>::RebuildObjCObjectType( ArrayRef<ObjCProtocolDecl *> Protocols, ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc) { - return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, - TypeArgs, TypeArgsRAngleLoc, - ProtocolLAngleLoc, Protocols, ProtocolLocs, - ProtocolRAngleLoc, - /*FailOnError=*/true); + return SemaRef.BuildObjCObjectType(BaseType, Loc, TypeArgsLAngleLoc, TypeArgs, + TypeArgsRAngleLoc, ProtocolLAngleLoc, + Protocols, ProtocolLocs, ProtocolRAngleLoc, + /*FailOnError=*/true, + /*Rebuilding=*/true); } template<typename Derived> @@ -14225,14 +14996,10 @@ QualType TreeTransform<Derived>::RebuildObjCObjectPointerType( return SemaRef.Context.getObjCObjectPointerType(PointeeType); } -template<typename Derived> -QualType -TreeTransform<Derived>::RebuildArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - const llvm::APInt *Size, - Expr *SizeExpr, - unsigned IndexTypeQuals, - SourceRange BracketsRange) { +template <typename Derived> +QualType TreeTransform<Derived>::RebuildArrayType( + QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt *Size, + Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { if (SizeExpr || !Size) return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, IndexTypeQuals, BracketsRange, @@ -14243,11 +15010,10 @@ TreeTransform<Derived>::RebuildArrayType(QualType ElementType, SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty }; - const unsigned NumTypes = llvm::array_lengthof(Types); QualType SizeType; - for (unsigned I = 0; I != NumTypes; ++I) - if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { - SizeType = Types[I]; + for (const auto &T : Types) + if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) { + SizeType = T; break; } @@ -14261,47 +15027,35 @@ TreeTransform<Derived>::RebuildArrayType(QualType ElementType, getDerived().getBaseEntity()); } -template<typename Derived> -QualType -TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - const llvm::APInt &Size, - Expr *SizeExpr, - unsigned IndexTypeQuals, - SourceRange BracketsRange) { +template <typename Derived> +QualType TreeTransform<Derived>::RebuildConstantArrayType( + QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt &Size, + Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) { return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr, IndexTypeQuals, BracketsRange); } -template<typename Derived> -QualType -TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - unsigned IndexTypeQuals, - SourceRange BracketsRange) { +template <typename Derived> +QualType TreeTransform<Derived>::RebuildIncompleteArrayType( + QualType ElementType, ArraySizeModifier SizeMod, unsigned IndexTypeQuals, + SourceRange BracketsRange) { return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr, IndexTypeQuals, BracketsRange); } -template<typename Derived> -QualType -TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - Expr *SizeExpr, - unsigned IndexTypeQuals, - SourceRange BracketsRange) { +template <typename Derived> +QualType TreeTransform<Derived>::RebuildVariableArrayType( + QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr, + unsigned IndexTypeQuals, SourceRange BracketsRange) { return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, SizeExpr, IndexTypeQuals, BracketsRange); } -template<typename Derived> -QualType -TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, - ArrayType::ArraySizeModifier SizeMod, - Expr *SizeExpr, - unsigned IndexTypeQuals, - SourceRange BracketsRange) { +template <typename Derived> +QualType TreeTransform<Derived>::RebuildDependentSizedArrayType( + QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr, + unsigned IndexTypeQuals, SourceRange BracketsRange) { return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, SizeExpr, IndexTypeQuals, BracketsRange); @@ -14315,10 +15069,9 @@ QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType( } template <typename Derived> -QualType -TreeTransform<Derived>::RebuildVectorType(QualType ElementType, - unsigned NumElements, - VectorType::VectorKind VecKind) { +QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, + unsigned NumElements, + VectorKind VecKind) { // FIXME: semantic checking! return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); } @@ -14326,7 +15079,7 @@ TreeTransform<Derived>::RebuildVectorType(QualType ElementType, template <typename Derived> QualType TreeTransform<Derived>::RebuildDependentVectorType( QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc, - VectorType::VectorKind VecKind) { + VectorKind VecKind) { return SemaRef.BuildVectorType(ElementType, SizeExpr, AttributeLoc); } @@ -14388,7 +15141,6 @@ QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc, if (D->isInvalidDecl()) return QualType(); // FIXME: Doesn't account for ObjCInterfaceDecl! - TypeDecl *Ty; if (auto *UPD = dyn_cast<UsingPackDecl>(D)) { // A valid resolved using typename pack expansion decl can have multiple // UsingDecls, but they must each have exactly one type, and it must be @@ -14424,34 +15176,35 @@ QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(SourceLocation Loc, // A valid resolved using typename decl points to exactly one type decl. assert(++Using->shadow_begin() == Using->shadow_end()); - NamedDecl *Target = Using->shadow_begin()->getTargetDecl(); - if (SemaRef.DiagnoseUseOfDecl(Target, Loc)) + UsingShadowDecl *Shadow = *Using->shadow_begin(); + if (SemaRef.DiagnoseUseOfDecl(Shadow->getTargetDecl(), Loc)) return QualType(); - Ty = cast<TypeDecl>(Target); + return SemaRef.Context.getUsingType( + Shadow, SemaRef.Context.getTypeDeclType( + cast<TypeDecl>(Shadow->getTargetDecl()))); } else { assert(isa<UnresolvedUsingTypenameDecl>(D) && "UnresolvedUsingTypenameDecl transformed to non-using decl"); - Ty = cast<UnresolvedUsingTypenameDecl>(D); + return SemaRef.Context.getTypeDeclType( + cast<UnresolvedUsingTypenameDecl>(D)); } - - return SemaRef.Context.getTypeDeclType(Ty); } -template<typename Derived> -QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, - SourceLocation Loc) { - return SemaRef.BuildTypeofExprType(E, Loc); +template <typename Derived> +QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation, + TypeOfKind Kind) { + return SemaRef.BuildTypeofExprType(E, Kind); } template<typename Derived> -QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { - return SemaRef.Context.getTypeOfType(Underlying); +QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying, + TypeOfKind Kind) { + return SemaRef.Context.getTypeOfType(Underlying, Kind); } -template<typename Derived> -QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, - SourceLocation Loc) { - return SemaRef.BuildDecltypeType(E, Loc); +template <typename Derived> +QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) { + return SemaRef.BuildDecltypeType(E); } template<typename Derived> @@ -14484,20 +15237,20 @@ QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType, } template <typename Derived> -QualType TreeTransform<Derived>::RebuildExtIntType(bool IsUnsigned, +QualType TreeTransform<Derived>::RebuildBitIntType(bool IsUnsigned, unsigned NumBits, SourceLocation Loc) { llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), NumBits, true); IntegerLiteral *Bits = IntegerLiteral::Create(SemaRef.Context, NumBitsAP, SemaRef.Context.IntTy, Loc); - return SemaRef.BuildExtIntType(IsUnsigned, Bits, Loc); + return SemaRef.BuildBitIntType(IsUnsigned, Bits, Loc); } template <typename Derived> -QualType TreeTransform<Derived>::RebuildDependentExtIntType( +QualType TreeTransform<Derived>::RebuildDependentBitIntType( bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) { - return SemaRef.BuildExtIntType(IsUnsigned, NumBitsExpr, Loc); + return SemaRef.BuildBitIntType(IsUnsigned, NumBitsExpr, Loc); } template<typename Derived> @@ -14506,7 +15259,7 @@ TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, bool TemplateKW, TemplateDecl *Template) { return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, - Template); + TemplateName(Template)); } template<typename Derived> @@ -14547,14 +15300,11 @@ TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, return Template.get(); } -template<typename Derived> -ExprResult -TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, - SourceLocation OpLoc, - Expr *OrigCallee, - Expr *First, - Expr *Second) { - Expr *Callee = OrigCallee->IgnoreParenCasts(); +template <typename Derived> +ExprResult TreeTransform<Derived>::RebuildCXXOperatorCallExpr( + OverloadedOperatorKind Op, SourceLocation OpLoc, SourceLocation CalleeLoc, + bool RequiresADL, const UnresolvedSetImpl &Functions, Expr *First, + Expr *Second) { bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); if (First->getObjectKind() == OK_ObjCProperty) { @@ -14579,9 +15329,13 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, if (Op == OO_Subscript) { if (!First->getType()->isOverloadableType() && !Second->getType()->isOverloadableType()) - return getSema().CreateBuiltinArraySubscriptExpr( - First, Callee->getBeginLoc(), Second, OpLoc); + return getSema().CreateBuiltinArraySubscriptExpr(First, CalleeLoc, Second, + OpLoc); } else if (Op == OO_Arrow) { + // It is possible that the type refers to a RecoveryExpr created earlier + // in the tree transformation. + if (First->getType()->isDependentType()) + return ExprError(); // -> is never a builtin operation. return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc); } else if (Second == nullptr || isPostIncDec) { @@ -14610,27 +15364,6 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, } } - // Compute the transformed set of functions (and function templates) to be - // used during overload resolution. - UnresolvedSet<16> Functions; - bool RequiresADL; - - if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { - Functions.append(ULE->decls_begin(), ULE->decls_end()); - // If the overload could not be resolved in the template definition - // (because we had a dependent argument), ADL is performed as part of - // template instantiation. - RequiresADL = ULE->requiresADL(); - } else { - // If we've resolved this to a particular non-member function, just call - // that function. If we resolved it to a member function, - // CreateOverloaded* will find that function for us. - NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl(); - if (!isa<CXXMethodDecl>(ND)) - Functions.addDecl(ND); - RequiresADL = false; - } - // Add any functions found via argument-dependent lookup. Expr *Args[2] = { First, Second }; unsigned NumArgs = 1 + (Second != nullptr); @@ -14643,23 +15376,6 @@ TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, RequiresADL); } - if (Op == OO_Subscript) { - SourceLocation LBrace; - SourceLocation RBrace; - - if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { - DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo(); - LBrace = NameLoc.getCXXOperatorNameBeginLoc(); - RBrace = NameLoc.getCXXOperatorNameEndLoc(); - } else { - LBrace = Callee->getBeginLoc(); - RBrace = OpLoc; - } - - return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, - First, Second); - } - // Create the overloaded operator invocation for binary operators. BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); ExprResult Result = SemaRef.CreateOverloadedBinOp( |