TreeTransform.h revision 6bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89
1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7//===----------------------------------------------------------------------===// 8// 9// This file implements a semantic tree transformation that takes a given 10// AST and rebuilds it, possibly transforming some nodes in the process. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_SEMA_TREETRANSFORM_H 15#define LLVM_CLANG_SEMA_TREETRANSFORM_H 16 17#include "TypeLocBuilder.h" 18#include "clang/AST/Decl.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/DeclTemplate.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/ExprCXX.h" 23#include "clang/AST/ExprObjC.h" 24#include "clang/AST/Stmt.h" 25#include "clang/AST/StmtCXX.h" 26#include "clang/AST/StmtObjC.h" 27#include "clang/AST/StmtOpenMP.h" 28#include "clang/Sema/Designator.h" 29#include "clang/Sema/Lookup.h" 30#include "clang/Sema/Ownership.h" 31#include "clang/Sema/ParsedTemplate.h" 32#include "clang/Sema/ScopeInfo.h" 33#include "clang/Sema/SemaDiagnostic.h" 34#include "clang/Sema/SemaInternal.h" 35#include "llvm/ADT/ArrayRef.h" 36#include "llvm/Support/ErrorHandling.h" 37#include <algorithm> 38 39namespace clang { 40using namespace sema; 41 42/// \brief A semantic tree transformation that allows one to transform one 43/// abstract syntax tree into another. 44/// 45/// A new tree transformation is defined by creating a new subclass \c X of 46/// \c TreeTransform<X> and then overriding certain operations to provide 47/// behavior specific to that transformation. For example, template 48/// instantiation is implemented as a tree transformation where the 49/// transformation of TemplateTypeParmType nodes involves substituting the 50/// template arguments for their corresponding template parameters; a similar 51/// transformation is performed for non-type template parameters and 52/// template template parameters. 53/// 54/// This tree-transformation template uses static polymorphism to allow 55/// subclasses to customize any of its operations. Thus, a subclass can 56/// override any of the transformation or rebuild operators by providing an 57/// operation with the same signature as the default implementation. The 58/// overridding function should not be virtual. 59/// 60/// Semantic tree transformations are split into two stages, either of which 61/// can be replaced by a subclass. The "transform" step transforms an AST node 62/// or the parts of an AST node using the various transformation functions, 63/// then passes the pieces on to the "rebuild" step, which constructs a new AST 64/// node of the appropriate kind from the pieces. The default transformation 65/// routines recursively transform the operands to composite AST nodes (e.g., 66/// the pointee type of a PointerType node) and, if any of those operand nodes 67/// were changed by the transformation, invokes the rebuild operation to create 68/// a new AST node. 69/// 70/// Subclasses can customize the transformation at various levels. The 71/// most coarse-grained transformations involve replacing TransformType(), 72/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(), 73/// TransformTemplateName(), or TransformTemplateArgument() with entirely 74/// new implementations. 75/// 76/// For more fine-grained transformations, subclasses can replace any of the 77/// \c TransformXXX functions (where XXX is the name of an AST node, e.g., 78/// PointerType, StmtExpr) to alter the transformation. As mentioned previously, 79/// replacing TransformTemplateTypeParmType() allows template instantiation 80/// to substitute template arguments for their corresponding template 81/// parameters. Additionally, subclasses can override the \c RebuildXXX 82/// functions to control how AST nodes are rebuilt when their operands change. 83/// By default, \c TreeTransform will invoke semantic analysis to rebuild 84/// AST nodes. However, certain other tree transformations (e.g, cloning) may 85/// be able to use more efficient rebuild steps. 86/// 87/// There are a handful of other functions that can be overridden, allowing one 88/// to avoid traversing nodes that don't need any transformation 89/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their 90/// operands have not changed (\c AlwaysRebuild()), and customize the 91/// default locations and entity names used for type-checking 92/// (\c getBaseLocation(), \c getBaseEntity()). 93template<typename Derived> 94class TreeTransform { 95 /// \brief Private RAII object that helps us forget and then re-remember 96 /// the template argument corresponding to a partially-substituted parameter 97 /// pack. 98 class ForgetPartiallySubstitutedPackRAII { 99 Derived &Self; 100 TemplateArgument Old; 101 102 public: 103 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) { 104 Old = Self.ForgetPartiallySubstitutedPack(); 105 } 106 107 ~ForgetPartiallySubstitutedPackRAII() { 108 Self.RememberPartiallySubstitutedPack(Old); 109 } 110 }; 111 112protected: 113 Sema &SemaRef; 114 115 /// \brief The set of local declarations that have been transformed, for 116 /// cases where we are forced to build new declarations within the transformer 117 /// rather than in the subclass (e.g., lambda closure types). 118 llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls; 119 120public: 121 /// \brief Initializes a new tree transformer. 122 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } 123 124 /// \brief Retrieves a reference to the derived class. 125 Derived &getDerived() { return static_cast<Derived&>(*this); } 126 127 /// \brief Retrieves a reference to the derived class. 128 const Derived &getDerived() const { 129 return static_cast<const Derived&>(*this); 130 } 131 132 static inline ExprResult Owned(Expr *E) { return E; } 133 static inline StmtResult Owned(Stmt *S) { return S; } 134 135 /// \brief Retrieves a reference to the semantic analysis object used for 136 /// this tree transform. 137 Sema &getSema() const { return SemaRef; } 138 139 /// \brief Whether the transformation should always rebuild AST nodes, even 140 /// if none of the children have changed. 141 /// 142 /// Subclasses may override this function to specify when the transformation 143 /// should rebuild all AST nodes. 144 /// 145 /// We must always rebuild all AST nodes when performing variadic template 146 /// pack expansion, in order to avoid violating the AST invariant that each 147 /// statement node appears at most once in its containing declaration. 148 bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; } 149 150 /// \brief Returns the location of the entity being transformed, if that 151 /// information was not available elsewhere in the AST. 152 /// 153 /// By default, returns no source-location information. Subclasses can 154 /// provide an alternative implementation that provides better location 155 /// information. 156 SourceLocation getBaseLocation() { return SourceLocation(); } 157 158 /// \brief Returns the name of the entity being transformed, if that 159 /// information was not available elsewhere in the AST. 160 /// 161 /// By default, returns an empty name. Subclasses can provide an alternative 162 /// implementation with a more precise name. 163 DeclarationName getBaseEntity() { return DeclarationName(); } 164 165 /// \brief Sets the "base" location and entity when that 166 /// information is known based on another transformation. 167 /// 168 /// By default, the source location and entity are ignored. Subclasses can 169 /// override this function to provide a customized implementation. 170 void setBase(SourceLocation Loc, DeclarationName Entity) { } 171 172 /// \brief RAII object that temporarily sets the base location and entity 173 /// used for reporting diagnostics in types. 174 class TemporaryBase { 175 TreeTransform &Self; 176 SourceLocation OldLocation; 177 DeclarationName OldEntity; 178 179 public: 180 TemporaryBase(TreeTransform &Self, SourceLocation Location, 181 DeclarationName Entity) : Self(Self) { 182 OldLocation = Self.getDerived().getBaseLocation(); 183 OldEntity = Self.getDerived().getBaseEntity(); 184 185 if (Location.isValid()) 186 Self.getDerived().setBase(Location, Entity); 187 } 188 189 ~TemporaryBase() { 190 Self.getDerived().setBase(OldLocation, OldEntity); 191 } 192 }; 193 194 /// \brief Determine whether the given type \p T has already been 195 /// transformed. 196 /// 197 /// Subclasses can provide an alternative implementation of this routine 198 /// to short-circuit evaluation when it is known that a given type will 199 /// not change. For example, template instantiation need not traverse 200 /// non-dependent types. 201 bool AlreadyTransformed(QualType T) { 202 return T.isNull(); 203 } 204 205 /// \brief Determine whether the given call argument should be dropped, e.g., 206 /// because it is a default argument. 207 /// 208 /// Subclasses can provide an alternative implementation of this routine to 209 /// determine which kinds of call arguments get dropped. By default, 210 /// CXXDefaultArgument nodes are dropped (prior to transformation). 211 bool DropCallArgument(Expr *E) { 212 return E->isDefaultArgument(); 213 } 214 215 /// \brief Determine whether we should expand a pack expansion with the 216 /// given set of parameter packs into separate arguments by repeatedly 217 /// transforming the pattern. 218 /// 219 /// By default, the transformer never tries to expand pack expansions. 220 /// Subclasses can override this routine to provide different behavior. 221 /// 222 /// \param EllipsisLoc The location of the ellipsis that identifies the 223 /// pack expansion. 224 /// 225 /// \param PatternRange The source range that covers the entire pattern of 226 /// the pack expansion. 227 /// 228 /// \param Unexpanded The set of unexpanded parameter packs within the 229 /// pattern. 230 /// 231 /// \param ShouldExpand Will be set to \c true if the transformer should 232 /// expand the corresponding pack expansions into separate arguments. When 233 /// set, \c NumExpansions must also be set. 234 /// 235 /// \param RetainExpansion Whether the caller should add an unexpanded 236 /// pack expansion after all of the expanded arguments. This is used 237 /// when extending explicitly-specified template argument packs per 238 /// C++0x [temp.arg.explicit]p9. 239 /// 240 /// \param NumExpansions The number of separate arguments that will be in 241 /// the expanded form of the corresponding pack expansion. This is both an 242 /// input and an output parameter, which can be set by the caller if the 243 /// number of expansions is known a priori (e.g., due to a prior substitution) 244 /// and will be set by the callee when the number of expansions is known. 245 /// The callee must set this value when \c ShouldExpand is \c true; it may 246 /// set this value in other cases. 247 /// 248 /// \returns true if an error occurred (e.g., because the parameter packs 249 /// are to be instantiated with arguments of different lengths), false 250 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions) 251 /// must be set. 252 bool TryExpandParameterPacks(SourceLocation EllipsisLoc, 253 SourceRange PatternRange, 254 ArrayRef<UnexpandedParameterPack> Unexpanded, 255 bool &ShouldExpand, 256 bool &RetainExpansion, 257 Optional<unsigned> &NumExpansions) { 258 ShouldExpand = false; 259 return false; 260 } 261 262 /// \brief "Forget" about the partially-substituted pack template argument, 263 /// when performing an instantiation that must preserve the parameter pack 264 /// use. 265 /// 266 /// This routine is meant to be overridden by the template instantiator. 267 TemplateArgument ForgetPartiallySubstitutedPack() { 268 return TemplateArgument(); 269 } 270 271 /// \brief "Remember" the partially-substituted pack template argument 272 /// after performing an instantiation that must preserve the parameter pack 273 /// use. 274 /// 275 /// This routine is meant to be overridden by the template instantiator. 276 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { } 277 278 /// \brief Note to the derived class when a function parameter pack is 279 /// being expanded. 280 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { } 281 282 /// \brief Transforms the given type into another type. 283 /// 284 /// By default, this routine transforms a type by creating a 285 /// TypeSourceInfo for it and delegating to the appropriate 286 /// function. This is expensive, but we don't mind, because 287 /// this method is deprecated anyway; all users should be 288 /// switched to storing TypeSourceInfos. 289 /// 290 /// \returns the transformed type. 291 QualType TransformType(QualType T); 292 293 /// \brief Transforms the given type-with-location into a new 294 /// type-with-location. 295 /// 296 /// By default, this routine transforms a type by delegating to the 297 /// appropriate TransformXXXType to build a new type. Subclasses 298 /// may override this function (to take over all type 299 /// transformations) or some set of the TransformXXXType functions 300 /// to alter the transformation. 301 TypeSourceInfo *TransformType(TypeSourceInfo *DI); 302 303 /// \brief Transform the given type-with-location into a new 304 /// type, collecting location information in the given builder 305 /// as necessary. 306 /// 307 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL); 308 309 /// \brief Transform the given statement. 310 /// 311 /// By default, this routine transforms a statement by delegating to the 312 /// appropriate TransformXXXStmt function to transform a specific kind of 313 /// statement or the TransformExpr() function to transform an expression. 314 /// Subclasses may override this function to transform statements using some 315 /// other mechanism. 316 /// 317 /// \returns the transformed statement. 318 StmtResult TransformStmt(Stmt *S); 319 320 /// \brief Transform the given statement. 321 /// 322 /// By default, this routine transforms a statement by delegating to the 323 /// appropriate TransformOMPXXXClause function to transform a specific kind 324 /// of clause. Subclasses may override this function to transform statements 325 /// using some other mechanism. 326 /// 327 /// \returns the transformed OpenMP clause. 328 OMPClause *TransformOMPClause(OMPClause *S); 329 330 /// \brief Transform the given expression. 331 /// 332 /// By default, this routine transforms an expression by delegating to the 333 /// appropriate TransformXXXExpr function to build a new expression. 334 /// Subclasses may override this function to transform expressions using some 335 /// other mechanism. 336 /// 337 /// \returns the transformed expression. 338 ExprResult TransformExpr(Expr *E); 339 340 /// \brief Transform the given initializer. 341 /// 342 /// By default, this routine transforms an initializer by stripping off the 343 /// semantic nodes added by initialization, then passing the result to 344 /// TransformExpr or TransformExprs. 345 /// 346 /// \returns the transformed initializer. 347 ExprResult TransformInitializer(Expr *Init, bool CXXDirectInit); 348 349 /// \brief Transform the given list of expressions. 350 /// 351 /// This routine transforms a list of expressions by invoking 352 /// \c TransformExpr() for each subexpression. However, it also provides 353 /// support for variadic templates by expanding any pack expansions (if the 354 /// derived class permits such expansion) along the way. When pack expansions 355 /// are present, the number of outputs may not equal the number of inputs. 356 /// 357 /// \param Inputs The set of expressions to be transformed. 358 /// 359 /// \param NumInputs The number of expressions in \c Inputs. 360 /// 361 /// \param IsCall If \c true, then this transform is being performed on 362 /// function-call arguments, and any arguments that should be dropped, will 363 /// be. 364 /// 365 /// \param Outputs The transformed input expressions will be added to this 366 /// vector. 367 /// 368 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed 369 /// due to transformation. 370 /// 371 /// \returns true if an error occurred, false otherwise. 372 bool TransformExprs(Expr **Inputs, unsigned NumInputs, bool IsCall, 373 SmallVectorImpl<Expr *> &Outputs, 374 bool *ArgChanged = nullptr); 375 376 /// \brief Transform the given declaration, which is referenced from a type 377 /// or expression. 378 /// 379 /// By default, acts as the identity function on declarations, unless the 380 /// transformer has had to transform the declaration itself. Subclasses 381 /// may override this function to provide alternate behavior. 382 Decl *TransformDecl(SourceLocation Loc, Decl *D) { 383 llvm::DenseMap<Decl *, Decl *>::iterator Known 384 = TransformedLocalDecls.find(D); 385 if (Known != TransformedLocalDecls.end()) 386 return Known->second; 387 388 return D; 389 } 390 391 /// \brief Transform the attributes associated with the given declaration and 392 /// place them on the new declaration. 393 /// 394 /// By default, this operation does nothing. Subclasses may override this 395 /// behavior to transform attributes. 396 void transformAttrs(Decl *Old, Decl *New) { } 397 398 /// \brief Note that a local declaration has been transformed by this 399 /// transformer. 400 /// 401 /// Local declarations are typically transformed via a call to 402 /// TransformDefinition. However, in some cases (e.g., lambda expressions), 403 /// the transformer itself has to transform the declarations. This routine 404 /// can be overridden by a subclass that keeps track of such mappings. 405 void transformedLocalDecl(Decl *Old, Decl *New) { 406 TransformedLocalDecls[Old] = New; 407 } 408 409 /// \brief Transform the definition of the given declaration. 410 /// 411 /// By default, invokes TransformDecl() to transform the declaration. 412 /// Subclasses may override this function to provide alternate behavior. 413 Decl *TransformDefinition(SourceLocation Loc, Decl *D) { 414 return getDerived().TransformDecl(Loc, D); 415 } 416 417 /// \brief Transform the given declaration, which was the first part of a 418 /// nested-name-specifier in a member access expression. 419 /// 420 /// This specific declaration transformation only applies to the first 421 /// identifier in a nested-name-specifier of a member access expression, e.g., 422 /// the \c T in \c x->T::member 423 /// 424 /// By default, invokes TransformDecl() to transform the declaration. 425 /// Subclasses may override this function to provide alternate behavior. 426 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) { 427 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D)); 428 } 429 430 /// \brief Transform the given nested-name-specifier with source-location 431 /// information. 432 /// 433 /// By default, transforms all of the types and declarations within the 434 /// nested-name-specifier. Subclasses may override this function to provide 435 /// alternate behavior. 436 NestedNameSpecifierLoc 437 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, 438 QualType ObjectType = QualType(), 439 NamedDecl *FirstQualifierInScope = nullptr); 440 441 /// \brief Transform the given declaration name. 442 /// 443 /// By default, transforms the types of conversion function, constructor, 444 /// and destructor names and then (if needed) rebuilds the declaration name. 445 /// Identifiers and selectors are returned unmodified. Sublcasses may 446 /// override this function to provide alternate behavior. 447 DeclarationNameInfo 448 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); 449 450 /// \brief Transform the given template name. 451 /// 452 /// \param SS The nested-name-specifier that qualifies the template 453 /// name. This nested-name-specifier must already have been transformed. 454 /// 455 /// \param Name The template name to transform. 456 /// 457 /// \param NameLoc The source location of the template name. 458 /// 459 /// \param ObjectType If we're translating a template name within a member 460 /// access expression, this is the type of the object whose member template 461 /// is being referenced. 462 /// 463 /// \param FirstQualifierInScope If the first part of a nested-name-specifier 464 /// also refers to a name within the current (lexical) scope, this is the 465 /// declaration it refers to. 466 /// 467 /// By default, transforms the template name by transforming the declarations 468 /// and nested-name-specifiers that occur within the template name. 469 /// Subclasses may override this function to provide alternate behavior. 470 TemplateName 471 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name, 472 SourceLocation NameLoc, 473 QualType ObjectType = QualType(), 474 NamedDecl *FirstQualifierInScope = nullptr); 475 476 /// \brief Transform the given template argument. 477 /// 478 /// By default, this operation transforms the type, expression, or 479 /// declaration stored within the template argument and constructs a 480 /// new template argument from the transformed result. Subclasses may 481 /// override this function to provide alternate behavior. 482 /// 483 /// Returns true if there was an error. 484 bool TransformTemplateArgument(const TemplateArgumentLoc &Input, 485 TemplateArgumentLoc &Output); 486 487 /// \brief Transform the given set of template arguments. 488 /// 489 /// By default, this operation transforms all of the template arguments 490 /// in the input set using \c TransformTemplateArgument(), and appends 491 /// the transformed arguments to the output list. 492 /// 493 /// Note that this overload of \c TransformTemplateArguments() is merely 494 /// a convenience function. Subclasses that wish to override this behavior 495 /// should override the iterator-based member template version. 496 /// 497 /// \param Inputs The set of template arguments to be transformed. 498 /// 499 /// \param NumInputs The number of template arguments in \p Inputs. 500 /// 501 /// \param Outputs The set of transformed template arguments output by this 502 /// routine. 503 /// 504 /// Returns true if an error occurred. 505 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs, 506 unsigned NumInputs, 507 TemplateArgumentListInfo &Outputs) { 508 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs); 509 } 510 511 /// \brief Transform the given set of template arguments. 512 /// 513 /// By default, this operation transforms all of the template arguments 514 /// in the input set using \c TransformTemplateArgument(), and appends 515 /// the transformed arguments to the output list. 516 /// 517 /// \param First An iterator to the first template argument. 518 /// 519 /// \param Last An iterator one step past the last template argument. 520 /// 521 /// \param Outputs The set of transformed template arguments output by this 522 /// routine. 523 /// 524 /// Returns true if an error occurred. 525 template<typename InputIterator> 526 bool TransformTemplateArguments(InputIterator First, 527 InputIterator Last, 528 TemplateArgumentListInfo &Outputs); 529 530 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument. 531 void InventTemplateArgumentLoc(const TemplateArgument &Arg, 532 TemplateArgumentLoc &ArgLoc); 533 534 /// \brief Fakes up a TypeSourceInfo for a type. 535 TypeSourceInfo *InventTypeSourceInfo(QualType T) { 536 return SemaRef.Context.getTrivialTypeSourceInfo(T, 537 getDerived().getBaseLocation()); 538 } 539 540#define ABSTRACT_TYPELOC(CLASS, PARENT) 541#define TYPELOC(CLASS, PARENT) \ 542 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T); 543#include "clang/AST/TypeLocNodes.def" 544 545 QualType TransformFunctionProtoType(TypeLocBuilder &TLB, 546 FunctionProtoTypeLoc TL, 547 CXXRecordDecl *ThisContext, 548 unsigned ThisTypeQuals); 549 550 StmtResult TransformSEHHandler(Stmt *Handler); 551 552 QualType 553 TransformTemplateSpecializationType(TypeLocBuilder &TLB, 554 TemplateSpecializationTypeLoc TL, 555 TemplateName Template); 556 557 QualType 558 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 559 DependentTemplateSpecializationTypeLoc TL, 560 TemplateName Template, 561 CXXScopeSpec &SS); 562 563 QualType 564 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 565 DependentTemplateSpecializationTypeLoc TL, 566 NestedNameSpecifierLoc QualifierLoc); 567 568 /// \brief Transforms the parameters of a function type into the 569 /// given vectors. 570 /// 571 /// The result vectors should be kept in sync; null entries in the 572 /// variables vector are acceptable. 573 /// 574 /// Return true on error. 575 bool TransformFunctionTypeParams(SourceLocation Loc, 576 ParmVarDecl **Params, unsigned NumParams, 577 const QualType *ParamTypes, 578 SmallVectorImpl<QualType> &PTypes, 579 SmallVectorImpl<ParmVarDecl*> *PVars); 580 581 /// \brief Transforms a single function-type parameter. Return null 582 /// on error. 583 /// 584 /// \param indexAdjustment - A number to add to the parameter's 585 /// scope index; can be negative 586 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, 587 int indexAdjustment, 588 Optional<unsigned> NumExpansions, 589 bool ExpectParameterPack); 590 591 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL); 592 593 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr); 594 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E); 595 596 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy; 597 /// \brief Transform the captures and body of a lambda expression. 598 ExprResult TransformLambdaScope(LambdaExpr *E, CXXMethodDecl *CallOperator, 599 ArrayRef<InitCaptureInfoTy> InitCaptureExprsAndTypes); 600 601 TemplateParameterList *TransformTemplateParameterList( 602 TemplateParameterList *TPL) { 603 return TPL; 604 } 605 606 ExprResult TransformAddressOfOperand(Expr *E); 607 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E, 608 bool IsAddressOfOperand); 609 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S); 610 611// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous 612// amount of stack usage with clang. 613#define STMT(Node, Parent) \ 614 LLVM_ATTRIBUTE_NOINLINE \ 615 StmtResult Transform##Node(Node *S); 616#define EXPR(Node, Parent) \ 617 LLVM_ATTRIBUTE_NOINLINE \ 618 ExprResult Transform##Node(Node *E); 619#define ABSTRACT_STMT(Stmt) 620#include "clang/AST/StmtNodes.inc" 621 622#define OPENMP_CLAUSE(Name, Class) \ 623 LLVM_ATTRIBUTE_NOINLINE \ 624 OMPClause *Transform ## Class(Class *S); 625#include "clang/Basic/OpenMPKinds.def" 626 627 /// \brief Build a new pointer type given its pointee type. 628 /// 629 /// By default, performs semantic analysis when building the pointer type. 630 /// Subclasses may override this routine to provide different behavior. 631 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil); 632 633 /// \brief Build a new block pointer type given its pointee type. 634 /// 635 /// By default, performs semantic analysis when building the block pointer 636 /// type. Subclasses may override this routine to provide different behavior. 637 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil); 638 639 /// \brief Build a new reference type given the type it references. 640 /// 641 /// By default, performs semantic analysis when building the 642 /// reference type. Subclasses may override this routine to provide 643 /// different behavior. 644 /// 645 /// \param LValue whether the type was written with an lvalue sigil 646 /// or an rvalue sigil. 647 QualType RebuildReferenceType(QualType ReferentType, 648 bool LValue, 649 SourceLocation Sigil); 650 651 /// \brief Build a new member pointer type given the pointee type and the 652 /// class type it refers into. 653 /// 654 /// By default, performs semantic analysis when building the member pointer 655 /// type. Subclasses may override this routine to provide different behavior. 656 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType, 657 SourceLocation Sigil); 658 659 /// \brief Build a new array type given the element type, size 660 /// modifier, size of the array (if known), size expression, and index type 661 /// qualifiers. 662 /// 663 /// By default, performs semantic analysis when building the array type. 664 /// Subclasses may override this routine to provide different behavior. 665 /// Also by default, all of the other Rebuild*Array 666 QualType RebuildArrayType(QualType ElementType, 667 ArrayType::ArraySizeModifier SizeMod, 668 const llvm::APInt *Size, 669 Expr *SizeExpr, 670 unsigned IndexTypeQuals, 671 SourceRange BracketsRange); 672 673 /// \brief Build a new constant array type given the element type, size 674 /// modifier, (known) size of the array, and index type qualifiers. 675 /// 676 /// By default, performs semantic analysis when building the array type. 677 /// Subclasses may override this routine to provide different behavior. 678 QualType RebuildConstantArrayType(QualType ElementType, 679 ArrayType::ArraySizeModifier SizeMod, 680 const llvm::APInt &Size, 681 unsigned IndexTypeQuals, 682 SourceRange BracketsRange); 683 684 /// \brief Build a new incomplete array type given the element type, size 685 /// modifier, and index type qualifiers. 686 /// 687 /// By default, performs semantic analysis when building the array type. 688 /// Subclasses may override this routine to provide different behavior. 689 QualType RebuildIncompleteArrayType(QualType ElementType, 690 ArrayType::ArraySizeModifier SizeMod, 691 unsigned IndexTypeQuals, 692 SourceRange BracketsRange); 693 694 /// \brief Build a new variable-length array type given the element type, 695 /// size modifier, size expression, and index type qualifiers. 696 /// 697 /// By default, performs semantic analysis when building the array type. 698 /// Subclasses may override this routine to provide different behavior. 699 QualType RebuildVariableArrayType(QualType ElementType, 700 ArrayType::ArraySizeModifier SizeMod, 701 Expr *SizeExpr, 702 unsigned IndexTypeQuals, 703 SourceRange BracketsRange); 704 705 /// \brief Build a new dependent-sized array type given the element type, 706 /// size modifier, size expression, and index type qualifiers. 707 /// 708 /// By default, performs semantic analysis when building the array type. 709 /// Subclasses may override this routine to provide different behavior. 710 QualType RebuildDependentSizedArrayType(QualType ElementType, 711 ArrayType::ArraySizeModifier SizeMod, 712 Expr *SizeExpr, 713 unsigned IndexTypeQuals, 714 SourceRange BracketsRange); 715 716 /// \brief Build a new vector type given the element type and 717 /// number of elements. 718 /// 719 /// By default, performs semantic analysis when building the vector type. 720 /// Subclasses may override this routine to provide different behavior. 721 QualType RebuildVectorType(QualType ElementType, unsigned NumElements, 722 VectorType::VectorKind VecKind); 723 724 /// \brief Build a new extended vector type given the element type and 725 /// number of elements. 726 /// 727 /// By default, performs semantic analysis when building the vector type. 728 /// Subclasses may override this routine to provide different behavior. 729 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements, 730 SourceLocation AttributeLoc); 731 732 /// \brief Build a new potentially dependently-sized extended vector type 733 /// given the element type and number of elements. 734 /// 735 /// By default, performs semantic analysis when building the vector type. 736 /// Subclasses may override this routine to provide different behavior. 737 QualType RebuildDependentSizedExtVectorType(QualType ElementType, 738 Expr *SizeExpr, 739 SourceLocation AttributeLoc); 740 741 /// \brief Build a new function type. 742 /// 743 /// By default, performs semantic analysis when building the function type. 744 /// Subclasses may override this routine to provide different behavior. 745 QualType RebuildFunctionProtoType(QualType T, 746 llvm::MutableArrayRef<QualType> ParamTypes, 747 const FunctionProtoType::ExtProtoInfo &EPI); 748 749 /// \brief Build a new unprototyped function type. 750 QualType RebuildFunctionNoProtoType(QualType ResultType); 751 752 /// \brief Rebuild an unresolved typename type, given the decl that 753 /// the UnresolvedUsingTypenameDecl was transformed to. 754 QualType RebuildUnresolvedUsingType(Decl *D); 755 756 /// \brief Build a new typedef type. 757 QualType RebuildTypedefType(TypedefNameDecl *Typedef) { 758 return SemaRef.Context.getTypeDeclType(Typedef); 759 } 760 761 /// \brief Build a new class/struct/union type. 762 QualType RebuildRecordType(RecordDecl *Record) { 763 return SemaRef.Context.getTypeDeclType(Record); 764 } 765 766 /// \brief Build a new Enum type. 767 QualType RebuildEnumType(EnumDecl *Enum) { 768 return SemaRef.Context.getTypeDeclType(Enum); 769 } 770 771 /// \brief Build a new typeof(expr) type. 772 /// 773 /// By default, performs semantic analysis when building the typeof type. 774 /// Subclasses may override this routine to provide different behavior. 775 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc); 776 777 /// \brief Build a new typeof(type) type. 778 /// 779 /// By default, builds a new TypeOfType with the given underlying type. 780 QualType RebuildTypeOfType(QualType Underlying); 781 782 /// \brief Build a new unary transform type. 783 QualType RebuildUnaryTransformType(QualType BaseType, 784 UnaryTransformType::UTTKind UKind, 785 SourceLocation Loc); 786 787 /// \brief Build a new C++11 decltype type. 788 /// 789 /// By default, performs semantic analysis when building the decltype type. 790 /// Subclasses may override this routine to provide different behavior. 791 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc); 792 793 /// \brief Build a new C++11 auto type. 794 /// 795 /// By default, builds a new AutoType with the given deduced type. 796 QualType RebuildAutoType(QualType Deduced, bool IsDecltypeAuto) { 797 // Note, IsDependent is always false here: we implicitly convert an 'auto' 798 // which has been deduced to a dependent type into an undeduced 'auto', so 799 // that we'll retry deduction after the transformation. 800 return SemaRef.Context.getAutoType(Deduced, IsDecltypeAuto, 801 /*IsDependent*/ false); 802 } 803 804 /// \brief Build a new template specialization type. 805 /// 806 /// By default, performs semantic analysis when building the template 807 /// specialization type. Subclasses may override this routine to provide 808 /// different behavior. 809 QualType RebuildTemplateSpecializationType(TemplateName Template, 810 SourceLocation TemplateLoc, 811 TemplateArgumentListInfo &Args); 812 813 /// \brief Build a new parenthesized type. 814 /// 815 /// By default, builds a new ParenType type from the inner type. 816 /// Subclasses may override this routine to provide different behavior. 817 QualType RebuildParenType(QualType InnerType) { 818 return SemaRef.Context.getParenType(InnerType); 819 } 820 821 /// \brief Build a new qualified name type. 822 /// 823 /// By default, builds a new ElaboratedType type from the keyword, 824 /// the nested-name-specifier and the named type. 825 /// Subclasses may override this routine to provide different behavior. 826 QualType RebuildElaboratedType(SourceLocation KeywordLoc, 827 ElaboratedTypeKeyword Keyword, 828 NestedNameSpecifierLoc QualifierLoc, 829 QualType Named) { 830 return SemaRef.Context.getElaboratedType(Keyword, 831 QualifierLoc.getNestedNameSpecifier(), 832 Named); 833 } 834 835 /// \brief Build a new typename type that refers to a template-id. 836 /// 837 /// By default, builds a new DependentNameType type from the 838 /// nested-name-specifier and the given type. Subclasses may override 839 /// this routine to provide different behavior. 840 QualType RebuildDependentTemplateSpecializationType( 841 ElaboratedTypeKeyword Keyword, 842 NestedNameSpecifierLoc QualifierLoc, 843 const IdentifierInfo *Name, 844 SourceLocation NameLoc, 845 TemplateArgumentListInfo &Args) { 846 // Rebuild the template name. 847 // TODO: avoid TemplateName abstraction 848 CXXScopeSpec SS; 849 SS.Adopt(QualifierLoc); 850 TemplateName InstName 851 = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(), 852 nullptr); 853 854 if (InstName.isNull()) 855 return QualType(); 856 857 // If it's still dependent, make a dependent specialization. 858 if (InstName.getAsDependentTemplateName()) 859 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword, 860 QualifierLoc.getNestedNameSpecifier(), 861 Name, 862 Args); 863 864 // Otherwise, make an elaborated type wrapping a non-dependent 865 // specialization. 866 QualType T = 867 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args); 868 if (T.isNull()) return QualType(); 869 870 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr) 871 return T; 872 873 return SemaRef.Context.getElaboratedType(Keyword, 874 QualifierLoc.getNestedNameSpecifier(), 875 T); 876 } 877 878 /// \brief Build a new typename type that refers to an identifier. 879 /// 880 /// By default, performs semantic analysis when building the typename type 881 /// (or elaborated type). Subclasses may override this routine to provide 882 /// different behavior. 883 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword, 884 SourceLocation KeywordLoc, 885 NestedNameSpecifierLoc QualifierLoc, 886 const IdentifierInfo *Id, 887 SourceLocation IdLoc) { 888 CXXScopeSpec SS; 889 SS.Adopt(QualifierLoc); 890 891 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) { 892 // If the name is still dependent, just build a new dependent name type. 893 if (!SemaRef.computeDeclContext(SS)) 894 return SemaRef.Context.getDependentNameType(Keyword, 895 QualifierLoc.getNestedNameSpecifier(), 896 Id); 897 } 898 899 if (Keyword == ETK_None || Keyword == ETK_Typename) 900 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc, 901 *Id, IdLoc); 902 903 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword); 904 905 // We had a dependent elaborated-type-specifier that has been transformed 906 // into a non-dependent elaborated-type-specifier. Find the tag we're 907 // referring to. 908 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName); 909 DeclContext *DC = SemaRef.computeDeclContext(SS, false); 910 if (!DC) 911 return QualType(); 912 913 if (SemaRef.RequireCompleteDeclContext(SS, DC)) 914 return QualType(); 915 916 TagDecl *Tag = nullptr; 917 SemaRef.LookupQualifiedName(Result, DC); 918 switch (Result.getResultKind()) { 919 case LookupResult::NotFound: 920 case LookupResult::NotFoundInCurrentInstantiation: 921 break; 922 923 case LookupResult::Found: 924 Tag = Result.getAsSingle<TagDecl>(); 925 break; 926 927 case LookupResult::FoundOverloaded: 928 case LookupResult::FoundUnresolvedValue: 929 llvm_unreachable("Tag lookup cannot find non-tags"); 930 931 case LookupResult::Ambiguous: 932 // Let the LookupResult structure handle ambiguities. 933 return QualType(); 934 } 935 936 if (!Tag) { 937 // Check where the name exists but isn't a tag type and use that to emit 938 // better diagnostics. 939 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName); 940 SemaRef.LookupQualifiedName(Result, DC); 941 switch (Result.getResultKind()) { 942 case LookupResult::Found: 943 case LookupResult::FoundOverloaded: 944 case LookupResult::FoundUnresolvedValue: { 945 NamedDecl *SomeDecl = Result.getRepresentativeDecl(); 946 unsigned Kind = 0; 947 if (isa<TypedefDecl>(SomeDecl)) Kind = 1; 948 else if (isa<TypeAliasDecl>(SomeDecl)) Kind = 2; 949 else if (isa<ClassTemplateDecl>(SomeDecl)) Kind = 3; 950 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << Kind; 951 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at); 952 break; 953 } 954 default: 955 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope) 956 << Kind << Id << DC << QualifierLoc.getSourceRange(); 957 break; 958 } 959 return QualType(); 960 } 961 962 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false, 963 IdLoc, *Id)) { 964 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id; 965 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use); 966 return QualType(); 967 } 968 969 // Build the elaborated-type-specifier type. 970 QualType T = SemaRef.Context.getTypeDeclType(Tag); 971 return SemaRef.Context.getElaboratedType(Keyword, 972 QualifierLoc.getNestedNameSpecifier(), 973 T); 974 } 975 976 /// \brief Build a new pack expansion type. 977 /// 978 /// By default, builds a new PackExpansionType type from the given pattern. 979 /// Subclasses may override this routine to provide different behavior. 980 QualType RebuildPackExpansionType(QualType Pattern, 981 SourceRange PatternRange, 982 SourceLocation EllipsisLoc, 983 Optional<unsigned> NumExpansions) { 984 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, 985 NumExpansions); 986 } 987 988 /// \brief Build a new atomic type given its value type. 989 /// 990 /// By default, performs semantic analysis when building the atomic type. 991 /// Subclasses may override this routine to provide different behavior. 992 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc); 993 994 /// \brief Build a new template name given a nested name specifier, a flag 995 /// indicating whether the "template" keyword was provided, and the template 996 /// that the template name refers to. 997 /// 998 /// By default, builds the new template name directly. Subclasses may override 999 /// this routine to provide different behavior. 1000 TemplateName RebuildTemplateName(CXXScopeSpec &SS, 1001 bool TemplateKW, 1002 TemplateDecl *Template); 1003 1004 /// \brief Build a new template name given a nested name specifier and the 1005 /// name that is referred to as a template. 1006 /// 1007 /// By default, performs semantic analysis to determine whether the name can 1008 /// be resolved to a specific template, then builds the appropriate kind of 1009 /// template name. Subclasses may override this routine to provide different 1010 /// behavior. 1011 TemplateName RebuildTemplateName(CXXScopeSpec &SS, 1012 const IdentifierInfo &Name, 1013 SourceLocation NameLoc, 1014 QualType ObjectType, 1015 NamedDecl *FirstQualifierInScope); 1016 1017 /// \brief Build a new template name given a nested name specifier and the 1018 /// overloaded operator name that is referred to as a template. 1019 /// 1020 /// By default, performs semantic analysis to determine whether the name can 1021 /// be resolved to a specific template, then builds the appropriate kind of 1022 /// template name. Subclasses may override this routine to provide different 1023 /// behavior. 1024 TemplateName RebuildTemplateName(CXXScopeSpec &SS, 1025 OverloadedOperatorKind Operator, 1026 SourceLocation NameLoc, 1027 QualType ObjectType); 1028 1029 /// \brief Build a new template name given a template template parameter pack 1030 /// and the 1031 /// 1032 /// By default, performs semantic analysis to determine whether the name can 1033 /// be resolved to a specific template, then builds the appropriate kind of 1034 /// template name. Subclasses may override this routine to provide different 1035 /// behavior. 1036 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param, 1037 const TemplateArgument &ArgPack) { 1038 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 1039 } 1040 1041 /// \brief Build a new compound statement. 1042 /// 1043 /// By default, performs semantic analysis to build the new statement. 1044 /// Subclasses may override this routine to provide different behavior. 1045 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc, 1046 MultiStmtArg Statements, 1047 SourceLocation RBraceLoc, 1048 bool IsStmtExpr) { 1049 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements, 1050 IsStmtExpr); 1051 } 1052 1053 /// \brief Build a new case statement. 1054 /// 1055 /// By default, performs semantic analysis to build the new statement. 1056 /// Subclasses may override this routine to provide different behavior. 1057 StmtResult RebuildCaseStmt(SourceLocation CaseLoc, 1058 Expr *LHS, 1059 SourceLocation EllipsisLoc, 1060 Expr *RHS, 1061 SourceLocation ColonLoc) { 1062 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS, 1063 ColonLoc); 1064 } 1065 1066 /// \brief Attach the body to a new case statement. 1067 /// 1068 /// By default, performs semantic analysis to build the new statement. 1069 /// Subclasses may override this routine to provide different behavior. 1070 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) { 1071 getSema().ActOnCaseStmtBody(S, Body); 1072 return S; 1073 } 1074 1075 /// \brief Build a new default statement. 1076 /// 1077 /// By default, performs semantic analysis to build the new statement. 1078 /// Subclasses may override this routine to provide different behavior. 1079 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, 1080 SourceLocation ColonLoc, 1081 Stmt *SubStmt) { 1082 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt, 1083 /*CurScope=*/nullptr); 1084 } 1085 1086 /// \brief Build a new label statement. 1087 /// 1088 /// By default, performs semantic analysis to build the new statement. 1089 /// Subclasses may override this routine to provide different behavior. 1090 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L, 1091 SourceLocation ColonLoc, Stmt *SubStmt) { 1092 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt); 1093 } 1094 1095 /// \brief Build a new label statement. 1096 /// 1097 /// By default, performs semantic analysis to build the new statement. 1098 /// Subclasses may override this routine to provide different behavior. 1099 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc, 1100 ArrayRef<const Attr*> Attrs, 1101 Stmt *SubStmt) { 1102 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt); 1103 } 1104 1105 /// \brief Build a new "if" statement. 1106 /// 1107 /// By default, performs semantic analysis to build the new statement. 1108 /// Subclasses may override this routine to provide different behavior. 1109 StmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond, 1110 VarDecl *CondVar, Stmt *Then, 1111 SourceLocation ElseLoc, Stmt *Else) { 1112 return getSema().ActOnIfStmt(IfLoc, Cond, CondVar, Then, ElseLoc, Else); 1113 } 1114 1115 /// \brief Start building a new switch statement. 1116 /// 1117 /// By default, performs semantic analysis to build the new statement. 1118 /// Subclasses may override this routine to provide different behavior. 1119 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, 1120 Expr *Cond, VarDecl *CondVar) { 1121 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Cond, 1122 CondVar); 1123 } 1124 1125 /// \brief Attach the body to the switch statement. 1126 /// 1127 /// By default, performs semantic analysis to build the new statement. 1128 /// Subclasses may override this routine to provide different behavior. 1129 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, 1130 Stmt *Switch, Stmt *Body) { 1131 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body); 1132 } 1133 1134 /// \brief Build a new while statement. 1135 /// 1136 /// By default, performs semantic analysis to build the new statement. 1137 /// Subclasses may override this routine to provide different behavior. 1138 StmtResult RebuildWhileStmt(SourceLocation WhileLoc, Sema::FullExprArg Cond, 1139 VarDecl *CondVar, Stmt *Body) { 1140 return getSema().ActOnWhileStmt(WhileLoc, Cond, CondVar, Body); 1141 } 1142 1143 /// \brief Build a new do-while statement. 1144 /// 1145 /// By default, performs semantic analysis to build the new statement. 1146 /// Subclasses may override this routine to provide different behavior. 1147 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body, 1148 SourceLocation WhileLoc, SourceLocation LParenLoc, 1149 Expr *Cond, SourceLocation RParenLoc) { 1150 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc, 1151 Cond, RParenLoc); 1152 } 1153 1154 /// \brief Build a new for statement. 1155 /// 1156 /// By default, performs semantic analysis to build the new statement. 1157 /// Subclasses may override this routine to provide different behavior. 1158 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, 1159 Stmt *Init, Sema::FullExprArg Cond, 1160 VarDecl *CondVar, Sema::FullExprArg Inc, 1161 SourceLocation RParenLoc, Stmt *Body) { 1162 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond, 1163 CondVar, Inc, RParenLoc, Body); 1164 } 1165 1166 /// \brief Build a new goto statement. 1167 /// 1168 /// By default, performs semantic analysis to build the new statement. 1169 /// Subclasses may override this routine to provide different behavior. 1170 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, 1171 LabelDecl *Label) { 1172 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label); 1173 } 1174 1175 /// \brief Build a new indirect goto statement. 1176 /// 1177 /// By default, performs semantic analysis to build the new statement. 1178 /// Subclasses may override this routine to provide different behavior. 1179 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc, 1180 SourceLocation StarLoc, 1181 Expr *Target) { 1182 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target); 1183 } 1184 1185 /// \brief Build a new return statement. 1186 /// 1187 /// By default, performs semantic analysis to build the new statement. 1188 /// Subclasses may override this routine to provide different behavior. 1189 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) { 1190 return getSema().BuildReturnStmt(ReturnLoc, Result); 1191 } 1192 1193 /// \brief Build a new declaration statement. 1194 /// 1195 /// By default, performs semantic analysis to build the new statement. 1196 /// Subclasses may override this routine to provide different behavior. 1197 StmtResult RebuildDeclStmt(llvm::MutableArrayRef<Decl *> Decls, 1198 SourceLocation StartLoc, SourceLocation EndLoc) { 1199 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls); 1200 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc); 1201 } 1202 1203 /// \brief Build a new inline asm statement. 1204 /// 1205 /// By default, performs semantic analysis to build the new statement. 1206 /// Subclasses may override this routine to provide different behavior. 1207 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, 1208 bool IsVolatile, unsigned NumOutputs, 1209 unsigned NumInputs, IdentifierInfo **Names, 1210 MultiExprArg Constraints, MultiExprArg Exprs, 1211 Expr *AsmString, MultiExprArg Clobbers, 1212 SourceLocation RParenLoc) { 1213 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs, 1214 NumInputs, Names, Constraints, Exprs, 1215 AsmString, Clobbers, RParenLoc); 1216 } 1217 1218 /// \brief Build a new MS style inline asm statement. 1219 /// 1220 /// By default, performs semantic analysis to build the new statement. 1221 /// Subclasses may override this routine to provide different behavior. 1222 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, 1223 ArrayRef<Token> AsmToks, 1224 StringRef AsmString, 1225 unsigned NumOutputs, unsigned NumInputs, 1226 ArrayRef<StringRef> Constraints, 1227 ArrayRef<StringRef> Clobbers, 1228 ArrayRef<Expr*> Exprs, 1229 SourceLocation EndLoc) { 1230 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString, 1231 NumOutputs, NumInputs, 1232 Constraints, Clobbers, Exprs, EndLoc); 1233 } 1234 1235 /// \brief Build a new Objective-C \@try statement. 1236 /// 1237 /// By default, performs semantic analysis to build the new statement. 1238 /// Subclasses may override this routine to provide different behavior. 1239 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc, 1240 Stmt *TryBody, 1241 MultiStmtArg CatchStmts, 1242 Stmt *Finally) { 1243 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts, 1244 Finally); 1245 } 1246 1247 /// \brief Rebuild an Objective-C exception declaration. 1248 /// 1249 /// By default, performs semantic analysis to build the new declaration. 1250 /// Subclasses may override this routine to provide different behavior. 1251 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, 1252 TypeSourceInfo *TInfo, QualType T) { 1253 return getSema().BuildObjCExceptionDecl(TInfo, T, 1254 ExceptionDecl->getInnerLocStart(), 1255 ExceptionDecl->getLocation(), 1256 ExceptionDecl->getIdentifier()); 1257 } 1258 1259 /// \brief Build a new Objective-C \@catch statement. 1260 /// 1261 /// By default, performs semantic analysis to build the new statement. 1262 /// Subclasses may override this routine to provide different behavior. 1263 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc, 1264 SourceLocation RParenLoc, 1265 VarDecl *Var, 1266 Stmt *Body) { 1267 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc, 1268 Var, Body); 1269 } 1270 1271 /// \brief Build a new Objective-C \@finally statement. 1272 /// 1273 /// By default, performs semantic analysis to build the new statement. 1274 /// Subclasses may override this routine to provide different behavior. 1275 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc, 1276 Stmt *Body) { 1277 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body); 1278 } 1279 1280 /// \brief Build a new Objective-C \@throw statement. 1281 /// 1282 /// By default, performs semantic analysis to build the new statement. 1283 /// Subclasses may override this routine to provide different behavior. 1284 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc, 1285 Expr *Operand) { 1286 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand); 1287 } 1288 1289 /// \brief Build a new OpenMP executable directive. 1290 /// 1291 /// By default, performs semantic analysis to build the new statement. 1292 /// Subclasses may override this routine to provide different behavior. 1293 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind, 1294 ArrayRef<OMPClause *> Clauses, 1295 Stmt *AStmt, 1296 SourceLocation StartLoc, 1297 SourceLocation EndLoc) { 1298 return getSema().ActOnOpenMPExecutableDirective(Kind, Clauses, AStmt, 1299 StartLoc, EndLoc); 1300 } 1301 1302 /// \brief Build a new OpenMP 'if' clause. 1303 /// 1304 /// By default, performs semantic analysis to build the new statement. 1305 /// Subclasses may override this routine to provide different behavior. 1306 OMPClause *RebuildOMPIfClause(Expr *Condition, 1307 SourceLocation StartLoc, 1308 SourceLocation LParenLoc, 1309 SourceLocation EndLoc) { 1310 return getSema().ActOnOpenMPIfClause(Condition, StartLoc, 1311 LParenLoc, EndLoc); 1312 } 1313 1314 /// \brief Build a new OpenMP 'num_threads' clause. 1315 /// 1316 /// By default, performs semantic analysis to build the new statement. 1317 /// Subclasses may override this routine to provide different behavior. 1318 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads, 1319 SourceLocation StartLoc, 1320 SourceLocation LParenLoc, 1321 SourceLocation EndLoc) { 1322 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc, 1323 LParenLoc, EndLoc); 1324 } 1325 1326 /// \brief Build a new OpenMP 'safelen' clause. 1327 /// 1328 /// By default, performs semantic analysis to build the new statement. 1329 /// Subclasses may override this routine to provide different behavior. 1330 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc, 1331 SourceLocation LParenLoc, 1332 SourceLocation EndLoc) { 1333 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc); 1334 } 1335 1336 /// \brief Build a new OpenMP 'collapse' clause. 1337 /// 1338 /// By default, performs semantic analysis to build the new statement. 1339 /// Subclasses may override this routine to provide different behavior. 1340 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc, 1341 SourceLocation LParenLoc, 1342 SourceLocation EndLoc) { 1343 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc, 1344 EndLoc); 1345 } 1346 1347 /// \brief Build a new OpenMP 'default' clause. 1348 /// 1349 /// By default, performs semantic analysis to build the new statement. 1350 /// Subclasses may override this routine to provide different behavior. 1351 OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind, 1352 SourceLocation KindKwLoc, 1353 SourceLocation StartLoc, 1354 SourceLocation LParenLoc, 1355 SourceLocation EndLoc) { 1356 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc, 1357 StartLoc, LParenLoc, EndLoc); 1358 } 1359 1360 /// \brief Build a new OpenMP 'proc_bind' clause. 1361 /// 1362 /// By default, performs semantic analysis to build the new statement. 1363 /// Subclasses may override this routine to provide different behavior. 1364 OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind, 1365 SourceLocation KindKwLoc, 1366 SourceLocation StartLoc, 1367 SourceLocation LParenLoc, 1368 SourceLocation EndLoc) { 1369 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc, 1370 StartLoc, LParenLoc, EndLoc); 1371 } 1372 1373 /// \brief Build a new OpenMP 'private' clause. 1374 /// 1375 /// By default, performs semantic analysis to build the new statement. 1376 /// Subclasses may override this routine to provide different behavior. 1377 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList, 1378 SourceLocation StartLoc, 1379 SourceLocation LParenLoc, 1380 SourceLocation EndLoc) { 1381 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, 1382 EndLoc); 1383 } 1384 1385 /// \brief Build a new OpenMP 'firstprivate' clause. 1386 /// 1387 /// By default, performs semantic analysis to build the new statement. 1388 /// Subclasses may override this routine to provide different behavior. 1389 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList, 1390 SourceLocation StartLoc, 1391 SourceLocation LParenLoc, 1392 SourceLocation EndLoc) { 1393 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, 1394 EndLoc); 1395 } 1396 1397 /// \brief Build a new OpenMP 'shared' clause. 1398 /// 1399 /// By default, performs semantic analysis to build the new statement. 1400 /// Subclasses may override this routine to provide different behavior. 1401 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList, 1402 SourceLocation StartLoc, 1403 SourceLocation LParenLoc, 1404 SourceLocation EndLoc) { 1405 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, 1406 EndLoc); 1407 } 1408 1409 /// \brief Build a new OpenMP 'linear' clause. 1410 /// 1411 /// By default, performs semantic analysis to build the new statement. 1412 /// Subclasses may override this routine to provide different behavior. 1413 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step, 1414 SourceLocation StartLoc, 1415 SourceLocation LParenLoc, 1416 SourceLocation ColonLoc, 1417 SourceLocation EndLoc) { 1418 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc, 1419 ColonLoc, EndLoc); 1420 } 1421 1422 /// \brief Build a new OpenMP 'copyin' clause. 1423 /// 1424 /// By default, performs semantic analysis to build the new statement. 1425 /// Subclasses may override this routine to provide different behavior. 1426 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList, 1427 SourceLocation StartLoc, 1428 SourceLocation LParenLoc, 1429 SourceLocation EndLoc) { 1430 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, 1431 EndLoc); 1432 } 1433 1434 /// \brief Rebuild the operand to an Objective-C \@synchronized statement. 1435 /// 1436 /// By default, performs semantic analysis to build the new statement. 1437 /// Subclasses may override this routine to provide different behavior. 1438 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc, 1439 Expr *object) { 1440 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object); 1441 } 1442 1443 /// \brief Build a new Objective-C \@synchronized statement. 1444 /// 1445 /// By default, performs semantic analysis to build the new statement. 1446 /// Subclasses may override this routine to provide different behavior. 1447 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc, 1448 Expr *Object, Stmt *Body) { 1449 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body); 1450 } 1451 1452 /// \brief Build a new Objective-C \@autoreleasepool statement. 1453 /// 1454 /// By default, performs semantic analysis to build the new statement. 1455 /// Subclasses may override this routine to provide different behavior. 1456 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc, 1457 Stmt *Body) { 1458 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body); 1459 } 1460 1461 /// \brief Build a new Objective-C fast enumeration statement. 1462 /// 1463 /// By default, performs semantic analysis to build the new statement. 1464 /// Subclasses may override this routine to provide different behavior. 1465 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc, 1466 Stmt *Element, 1467 Expr *Collection, 1468 SourceLocation RParenLoc, 1469 Stmt *Body) { 1470 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc, 1471 Element, 1472 Collection, 1473 RParenLoc); 1474 if (ForEachStmt.isInvalid()) 1475 return StmtError(); 1476 1477 return getSema().FinishObjCForCollectionStmt(ForEachStmt.take(), Body); 1478 } 1479 1480 /// \brief Build a new C++ exception declaration. 1481 /// 1482 /// By default, performs semantic analysis to build the new decaration. 1483 /// Subclasses may override this routine to provide different behavior. 1484 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, 1485 TypeSourceInfo *Declarator, 1486 SourceLocation StartLoc, 1487 SourceLocation IdLoc, 1488 IdentifierInfo *Id) { 1489 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator, 1490 StartLoc, IdLoc, Id); 1491 if (Var) 1492 getSema().CurContext->addDecl(Var); 1493 return Var; 1494 } 1495 1496 /// \brief Build a new C++ catch statement. 1497 /// 1498 /// By default, performs semantic analysis to build the new statement. 1499 /// Subclasses may override this routine to provide different behavior. 1500 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc, 1501 VarDecl *ExceptionDecl, 1502 Stmt *Handler) { 1503 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, 1504 Handler)); 1505 } 1506 1507 /// \brief Build a new C++ try statement. 1508 /// 1509 /// By default, performs semantic analysis to build the new statement. 1510 /// Subclasses may override this routine to provide different behavior. 1511 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock, 1512 ArrayRef<Stmt *> Handlers) { 1513 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers); 1514 } 1515 1516 /// \brief Build a new C++0x range-based for statement. 1517 /// 1518 /// By default, performs semantic analysis to build the new statement. 1519 /// Subclasses may override this routine to provide different behavior. 1520 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc, 1521 SourceLocation ColonLoc, 1522 Stmt *Range, Stmt *BeginEnd, 1523 Expr *Cond, Expr *Inc, 1524 Stmt *LoopVar, 1525 SourceLocation RParenLoc) { 1526 // If we've just learned that the range is actually an Objective-C 1527 // collection, treat this as an Objective-C fast enumeration loop. 1528 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) { 1529 if (RangeStmt->isSingleDecl()) { 1530 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) { 1531 if (RangeVar->isInvalidDecl()) 1532 return StmtError(); 1533 1534 Expr *RangeExpr = RangeVar->getInit(); 1535 if (!RangeExpr->isTypeDependent() && 1536 RangeExpr->getType()->isObjCObjectPointerType()) 1537 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr, 1538 RParenLoc); 1539 } 1540 } 1541 } 1542 1543 return getSema().BuildCXXForRangeStmt(ForLoc, ColonLoc, Range, BeginEnd, 1544 Cond, Inc, LoopVar, RParenLoc, 1545 Sema::BFRK_Rebuild); 1546 } 1547 1548 /// \brief Build a new C++0x range-based for statement. 1549 /// 1550 /// By default, performs semantic analysis to build the new statement. 1551 /// Subclasses may override this routine to provide different behavior. 1552 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc, 1553 bool IsIfExists, 1554 NestedNameSpecifierLoc QualifierLoc, 1555 DeclarationNameInfo NameInfo, 1556 Stmt *Nested) { 1557 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists, 1558 QualifierLoc, NameInfo, Nested); 1559 } 1560 1561 /// \brief Attach body to a C++0x range-based for statement. 1562 /// 1563 /// By default, performs semantic analysis to finish the new statement. 1564 /// Subclasses may override this routine to provide different behavior. 1565 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) { 1566 return getSema().FinishCXXForRangeStmt(ForRange, Body); 1567 } 1568 1569 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, 1570 Stmt *TryBlock, Stmt *Handler) { 1571 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler); 1572 } 1573 1574 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, 1575 Stmt *Block) { 1576 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block); 1577 } 1578 1579 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) { 1580 return getSema().ActOnSEHFinallyBlock(Loc, Block); 1581 } 1582 1583 /// \brief Build a new expression that references a declaration. 1584 /// 1585 /// By default, performs semantic analysis to build the new expression. 1586 /// Subclasses may override this routine to provide different behavior. 1587 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS, 1588 LookupResult &R, 1589 bool RequiresADL) { 1590 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL); 1591 } 1592 1593 1594 /// \brief Build a new expression that references a declaration. 1595 /// 1596 /// By default, performs semantic analysis to build the new expression. 1597 /// Subclasses may override this routine to provide different behavior. 1598 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc, 1599 ValueDecl *VD, 1600 const DeclarationNameInfo &NameInfo, 1601 TemplateArgumentListInfo *TemplateArgs) { 1602 CXXScopeSpec SS; 1603 SS.Adopt(QualifierLoc); 1604 1605 // FIXME: loses template args. 1606 1607 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD); 1608 } 1609 1610 /// \brief Build a new expression in parentheses. 1611 /// 1612 /// By default, performs semantic analysis to build the new expression. 1613 /// Subclasses may override this routine to provide different behavior. 1614 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen, 1615 SourceLocation RParen) { 1616 return getSema().ActOnParenExpr(LParen, RParen, SubExpr); 1617 } 1618 1619 /// \brief Build a new pseudo-destructor expression. 1620 /// 1621 /// By default, performs semantic analysis to build the new expression. 1622 /// Subclasses may override this routine to provide different behavior. 1623 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base, 1624 SourceLocation OperatorLoc, 1625 bool isArrow, 1626 CXXScopeSpec &SS, 1627 TypeSourceInfo *ScopeType, 1628 SourceLocation CCLoc, 1629 SourceLocation TildeLoc, 1630 PseudoDestructorTypeStorage Destroyed); 1631 1632 /// \brief Build a new unary operator expression. 1633 /// 1634 /// By default, performs semantic analysis to build the new expression. 1635 /// Subclasses may override this routine to provide different behavior. 1636 ExprResult RebuildUnaryOperator(SourceLocation OpLoc, 1637 UnaryOperatorKind Opc, 1638 Expr *SubExpr) { 1639 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr); 1640 } 1641 1642 /// \brief Build a new builtin offsetof expression. 1643 /// 1644 /// By default, performs semantic analysis to build the new expression. 1645 /// Subclasses may override this routine to provide different behavior. 1646 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc, 1647 TypeSourceInfo *Type, 1648 Sema::OffsetOfComponent *Components, 1649 unsigned NumComponents, 1650 SourceLocation RParenLoc) { 1651 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components, 1652 NumComponents, RParenLoc); 1653 } 1654 1655 /// \brief Build a new sizeof, alignof or vec_step expression with a 1656 /// type argument. 1657 /// 1658 /// By default, performs semantic analysis to build the new expression. 1659 /// Subclasses may override this routine to provide different behavior. 1660 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo, 1661 SourceLocation OpLoc, 1662 UnaryExprOrTypeTrait ExprKind, 1663 SourceRange R) { 1664 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R); 1665 } 1666 1667 /// \brief Build a new sizeof, alignof or vec step expression with an 1668 /// expression argument. 1669 /// 1670 /// By default, performs semantic analysis to build the new expression. 1671 /// Subclasses may override this routine to provide different behavior. 1672 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc, 1673 UnaryExprOrTypeTrait ExprKind, 1674 SourceRange R) { 1675 ExprResult Result 1676 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind); 1677 if (Result.isInvalid()) 1678 return ExprError(); 1679 1680 return Result; 1681 } 1682 1683 /// \brief Build a new array subscript expression. 1684 /// 1685 /// By default, performs semantic analysis to build the new expression. 1686 /// Subclasses may override this routine to provide different behavior. 1687 ExprResult RebuildArraySubscriptExpr(Expr *LHS, 1688 SourceLocation LBracketLoc, 1689 Expr *RHS, 1690 SourceLocation RBracketLoc) { 1691 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS, 1692 LBracketLoc, RHS, 1693 RBracketLoc); 1694 } 1695 1696 /// \brief Build a new call expression. 1697 /// 1698 /// By default, performs semantic analysis to build the new expression. 1699 /// Subclasses may override this routine to provide different behavior. 1700 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc, 1701 MultiExprArg Args, 1702 SourceLocation RParenLoc, 1703 Expr *ExecConfig = nullptr) { 1704 return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc, 1705 Args, RParenLoc, ExecConfig); 1706 } 1707 1708 /// \brief Build a new member access expression. 1709 /// 1710 /// By default, performs semantic analysis to build the new expression. 1711 /// Subclasses may override this routine to provide different behavior. 1712 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc, 1713 bool isArrow, 1714 NestedNameSpecifierLoc QualifierLoc, 1715 SourceLocation TemplateKWLoc, 1716 const DeclarationNameInfo &MemberNameInfo, 1717 ValueDecl *Member, 1718 NamedDecl *FoundDecl, 1719 const TemplateArgumentListInfo *ExplicitTemplateArgs, 1720 NamedDecl *FirstQualifierInScope) { 1721 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base, 1722 isArrow); 1723 if (!Member->getDeclName()) { 1724 // We have a reference to an unnamed field. This is always the 1725 // base of an anonymous struct/union member access, i.e. the 1726 // field is always of record type. 1727 assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!"); 1728 assert(Member->getType()->isRecordType() && 1729 "unnamed member not of record type?"); 1730 1731 BaseResult = 1732 getSema().PerformObjectMemberConversion(BaseResult.take(), 1733 QualifierLoc.getNestedNameSpecifier(), 1734 FoundDecl, Member); 1735 if (BaseResult.isInvalid()) 1736 return ExprError(); 1737 Base = BaseResult.take(); 1738 ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind(); 1739 MemberExpr *ME = 1740 new (getSema().Context) MemberExpr(Base, isArrow, 1741 Member, MemberNameInfo, 1742 cast<FieldDecl>(Member)->getType(), 1743 VK, OK_Ordinary); 1744 return getSema().Owned(ME); 1745 } 1746 1747 CXXScopeSpec SS; 1748 SS.Adopt(QualifierLoc); 1749 1750 Base = BaseResult.take(); 1751 QualType BaseType = Base->getType(); 1752 1753 // FIXME: this involves duplicating earlier analysis in a lot of 1754 // cases; we should avoid this when possible. 1755 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName); 1756 R.addDecl(FoundDecl); 1757 R.resolveKind(); 1758 1759 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow, 1760 SS, TemplateKWLoc, 1761 FirstQualifierInScope, 1762 R, ExplicitTemplateArgs); 1763 } 1764 1765 /// \brief Build a new binary operator expression. 1766 /// 1767 /// By default, performs semantic analysis to build the new expression. 1768 /// Subclasses may override this routine to provide different behavior. 1769 ExprResult RebuildBinaryOperator(SourceLocation OpLoc, 1770 BinaryOperatorKind Opc, 1771 Expr *LHS, Expr *RHS) { 1772 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS); 1773 } 1774 1775 /// \brief Build a new conditional operator expression. 1776 /// 1777 /// By default, performs semantic analysis to build the new expression. 1778 /// Subclasses may override this routine to provide different behavior. 1779 ExprResult RebuildConditionalOperator(Expr *Cond, 1780 SourceLocation QuestionLoc, 1781 Expr *LHS, 1782 SourceLocation ColonLoc, 1783 Expr *RHS) { 1784 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond, 1785 LHS, RHS); 1786 } 1787 1788 /// \brief Build a new C-style cast expression. 1789 /// 1790 /// By default, performs semantic analysis to build the new expression. 1791 /// Subclasses may override this routine to provide different behavior. 1792 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc, 1793 TypeSourceInfo *TInfo, 1794 SourceLocation RParenLoc, 1795 Expr *SubExpr) { 1796 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, 1797 SubExpr); 1798 } 1799 1800 /// \brief Build a new compound literal expression. 1801 /// 1802 /// By default, performs semantic analysis to build the new expression. 1803 /// Subclasses may override this routine to provide different behavior. 1804 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, 1805 TypeSourceInfo *TInfo, 1806 SourceLocation RParenLoc, 1807 Expr *Init) { 1808 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, 1809 Init); 1810 } 1811 1812 /// \brief Build a new extended vector element access expression. 1813 /// 1814 /// By default, performs semantic analysis to build the new expression. 1815 /// Subclasses may override this routine to provide different behavior. 1816 ExprResult RebuildExtVectorElementExpr(Expr *Base, 1817 SourceLocation OpLoc, 1818 SourceLocation AccessorLoc, 1819 IdentifierInfo &Accessor) { 1820 1821 CXXScopeSpec SS; 1822 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc); 1823 return getSema().BuildMemberReferenceExpr(Base, Base->getType(), 1824 OpLoc, /*IsArrow*/ false, 1825 SS, SourceLocation(), 1826 /*FirstQualifierInScope*/ nullptr, 1827 NameInfo, 1828 /* TemplateArgs */ nullptr); 1829 } 1830 1831 /// \brief Build a new initializer list expression. 1832 /// 1833 /// By default, performs semantic analysis to build the new expression. 1834 /// Subclasses may override this routine to provide different behavior. 1835 ExprResult RebuildInitList(SourceLocation LBraceLoc, 1836 MultiExprArg Inits, 1837 SourceLocation RBraceLoc, 1838 QualType ResultTy) { 1839 ExprResult Result 1840 = SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc); 1841 if (Result.isInvalid() || ResultTy->isDependentType()) 1842 return Result; 1843 1844 // Patch in the result type we were given, which may have been computed 1845 // when the initial InitListExpr was built. 1846 InitListExpr *ILE = cast<InitListExpr>((Expr *)Result.get()); 1847 ILE->setType(ResultTy); 1848 return Result; 1849 } 1850 1851 /// \brief Build a new designated initializer expression. 1852 /// 1853 /// By default, performs semantic analysis to build the new expression. 1854 /// Subclasses may override this routine to provide different behavior. 1855 ExprResult RebuildDesignatedInitExpr(Designation &Desig, 1856 MultiExprArg ArrayExprs, 1857 SourceLocation EqualOrColonLoc, 1858 bool GNUSyntax, 1859 Expr *Init) { 1860 ExprResult Result 1861 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax, 1862 Init); 1863 if (Result.isInvalid()) 1864 return ExprError(); 1865 1866 return Result; 1867 } 1868 1869 /// \brief Build a new value-initialized expression. 1870 /// 1871 /// By default, builds the implicit value initialization without performing 1872 /// any semantic analysis. Subclasses may override this routine to provide 1873 /// different behavior. 1874 ExprResult RebuildImplicitValueInitExpr(QualType T) { 1875 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); 1876 } 1877 1878 /// \brief Build a new \c va_arg expression. 1879 /// 1880 /// By default, performs semantic analysis to build the new expression. 1881 /// Subclasses may override this routine to provide different behavior. 1882 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, 1883 Expr *SubExpr, TypeSourceInfo *TInfo, 1884 SourceLocation RParenLoc) { 1885 return getSema().BuildVAArgExpr(BuiltinLoc, 1886 SubExpr, TInfo, 1887 RParenLoc); 1888 } 1889 1890 /// \brief Build a new expression list in parentheses. 1891 /// 1892 /// By default, performs semantic analysis to build the new expression. 1893 /// Subclasses may override this routine to provide different behavior. 1894 ExprResult RebuildParenListExpr(SourceLocation LParenLoc, 1895 MultiExprArg SubExprs, 1896 SourceLocation RParenLoc) { 1897 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs); 1898 } 1899 1900 /// \brief Build a new address-of-label expression. 1901 /// 1902 /// By default, performs semantic analysis, using the name of the label 1903 /// rather than attempting to map the label statement itself. 1904 /// Subclasses may override this routine to provide different behavior. 1905 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, 1906 SourceLocation LabelLoc, LabelDecl *Label) { 1907 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label); 1908 } 1909 1910 /// \brief Build a new GNU statement expression. 1911 /// 1912 /// By default, performs semantic analysis to build the new expression. 1913 /// Subclasses may override this routine to provide different behavior. 1914 ExprResult RebuildStmtExpr(SourceLocation LParenLoc, 1915 Stmt *SubStmt, 1916 SourceLocation RParenLoc) { 1917 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc); 1918 } 1919 1920 /// \brief Build a new __builtin_choose_expr expression. 1921 /// 1922 /// By default, performs semantic analysis to build the new expression. 1923 /// Subclasses may override this routine to provide different behavior. 1924 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc, 1925 Expr *Cond, Expr *LHS, Expr *RHS, 1926 SourceLocation RParenLoc) { 1927 return SemaRef.ActOnChooseExpr(BuiltinLoc, 1928 Cond, LHS, RHS, 1929 RParenLoc); 1930 } 1931 1932 /// \brief Build a new generic selection expression. 1933 /// 1934 /// By default, performs semantic analysis to build the new expression. 1935 /// Subclasses may override this routine to provide different behavior. 1936 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc, 1937 SourceLocation DefaultLoc, 1938 SourceLocation RParenLoc, 1939 Expr *ControllingExpr, 1940 ArrayRef<TypeSourceInfo *> Types, 1941 ArrayRef<Expr *> Exprs) { 1942 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1943 ControllingExpr, Types, Exprs); 1944 } 1945 1946 /// \brief Build a new overloaded operator call expression. 1947 /// 1948 /// By default, performs semantic analysis to build the new expression. 1949 /// The semantic analysis provides the behavior of template instantiation, 1950 /// copying with transformations that turn what looks like an overloaded 1951 /// operator call into a use of a builtin operator, performing 1952 /// argument-dependent lookup, etc. Subclasses may override this routine to 1953 /// provide different behavior. 1954 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 1955 SourceLocation OpLoc, 1956 Expr *Callee, 1957 Expr *First, 1958 Expr *Second); 1959 1960 /// \brief Build a new C++ "named" cast expression, such as static_cast or 1961 /// reinterpret_cast. 1962 /// 1963 /// By default, this routine dispatches to one of the more-specific routines 1964 /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). 1965 /// Subclasses may override this routine to provide different behavior. 1966 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, 1967 Stmt::StmtClass Class, 1968 SourceLocation LAngleLoc, 1969 TypeSourceInfo *TInfo, 1970 SourceLocation RAngleLoc, 1971 SourceLocation LParenLoc, 1972 Expr *SubExpr, 1973 SourceLocation RParenLoc) { 1974 switch (Class) { 1975 case Stmt::CXXStaticCastExprClass: 1976 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo, 1977 RAngleLoc, LParenLoc, 1978 SubExpr, RParenLoc); 1979 1980 case Stmt::CXXDynamicCastExprClass: 1981 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo, 1982 RAngleLoc, LParenLoc, 1983 SubExpr, RParenLoc); 1984 1985 case Stmt::CXXReinterpretCastExprClass: 1986 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo, 1987 RAngleLoc, LParenLoc, 1988 SubExpr, 1989 RParenLoc); 1990 1991 case Stmt::CXXConstCastExprClass: 1992 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo, 1993 RAngleLoc, LParenLoc, 1994 SubExpr, RParenLoc); 1995 1996 default: 1997 llvm_unreachable("Invalid C++ named cast"); 1998 } 1999 } 2000 2001 /// \brief Build a new C++ static_cast expression. 2002 /// 2003 /// By default, performs semantic analysis to build the new expression. 2004 /// Subclasses may override this routine to provide different behavior. 2005 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, 2006 SourceLocation LAngleLoc, 2007 TypeSourceInfo *TInfo, 2008 SourceLocation RAngleLoc, 2009 SourceLocation LParenLoc, 2010 Expr *SubExpr, 2011 SourceLocation RParenLoc) { 2012 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast, 2013 TInfo, SubExpr, 2014 SourceRange(LAngleLoc, RAngleLoc), 2015 SourceRange(LParenLoc, RParenLoc)); 2016 } 2017 2018 /// \brief Build a new C++ dynamic_cast expression. 2019 /// 2020 /// By default, performs semantic analysis to build the new expression. 2021 /// Subclasses may override this routine to provide different behavior. 2022 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, 2023 SourceLocation LAngleLoc, 2024 TypeSourceInfo *TInfo, 2025 SourceLocation RAngleLoc, 2026 SourceLocation LParenLoc, 2027 Expr *SubExpr, 2028 SourceLocation RParenLoc) { 2029 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast, 2030 TInfo, SubExpr, 2031 SourceRange(LAngleLoc, RAngleLoc), 2032 SourceRange(LParenLoc, RParenLoc)); 2033 } 2034 2035 /// \brief Build a new C++ reinterpret_cast expression. 2036 /// 2037 /// By default, performs semantic analysis to build the new expression. 2038 /// Subclasses may override this routine to provide different behavior. 2039 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, 2040 SourceLocation LAngleLoc, 2041 TypeSourceInfo *TInfo, 2042 SourceLocation RAngleLoc, 2043 SourceLocation LParenLoc, 2044 Expr *SubExpr, 2045 SourceLocation RParenLoc) { 2046 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, 2047 TInfo, SubExpr, 2048 SourceRange(LAngleLoc, RAngleLoc), 2049 SourceRange(LParenLoc, RParenLoc)); 2050 } 2051 2052 /// \brief Build a new C++ const_cast expression. 2053 /// 2054 /// By default, performs semantic analysis to build the new expression. 2055 /// Subclasses may override this routine to provide different behavior. 2056 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, 2057 SourceLocation LAngleLoc, 2058 TypeSourceInfo *TInfo, 2059 SourceLocation RAngleLoc, 2060 SourceLocation LParenLoc, 2061 Expr *SubExpr, 2062 SourceLocation RParenLoc) { 2063 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast, 2064 TInfo, SubExpr, 2065 SourceRange(LAngleLoc, RAngleLoc), 2066 SourceRange(LParenLoc, RParenLoc)); 2067 } 2068 2069 /// \brief Build a new C++ functional-style cast expression. 2070 /// 2071 /// By default, performs semantic analysis to build the new expression. 2072 /// Subclasses may override this routine to provide different behavior. 2073 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, 2074 SourceLocation LParenLoc, 2075 Expr *Sub, 2076 SourceLocation RParenLoc) { 2077 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc, 2078 MultiExprArg(&Sub, 1), 2079 RParenLoc); 2080 } 2081 2082 /// \brief Build a new C++ typeid(type) expression. 2083 /// 2084 /// By default, performs semantic analysis to build the new expression. 2085 /// Subclasses may override this routine to provide different behavior. 2086 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, 2087 SourceLocation TypeidLoc, 2088 TypeSourceInfo *Operand, 2089 SourceLocation RParenLoc) { 2090 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, 2091 RParenLoc); 2092 } 2093 2094 2095 /// \brief Build a new C++ typeid(expr) expression. 2096 /// 2097 /// By default, performs semantic analysis to build the new expression. 2098 /// Subclasses may override this routine to provide different behavior. 2099 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, 2100 SourceLocation TypeidLoc, 2101 Expr *Operand, 2102 SourceLocation RParenLoc) { 2103 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, 2104 RParenLoc); 2105 } 2106 2107 /// \brief Build a new C++ __uuidof(type) expression. 2108 /// 2109 /// By default, performs semantic analysis to build the new expression. 2110 /// Subclasses may override this routine to provide different behavior. 2111 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType, 2112 SourceLocation TypeidLoc, 2113 TypeSourceInfo *Operand, 2114 SourceLocation RParenLoc) { 2115 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand, 2116 RParenLoc); 2117 } 2118 2119 /// \brief Build a new C++ __uuidof(expr) expression. 2120 /// 2121 /// By default, performs semantic analysis to build the new expression. 2122 /// Subclasses may override this routine to provide different behavior. 2123 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType, 2124 SourceLocation TypeidLoc, 2125 Expr *Operand, 2126 SourceLocation RParenLoc) { 2127 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand, 2128 RParenLoc); 2129 } 2130 2131 /// \brief Build a new C++ "this" expression. 2132 /// 2133 /// By default, builds a new "this" expression without performing any 2134 /// semantic analysis. Subclasses may override this routine to provide 2135 /// different behavior. 2136 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, 2137 QualType ThisType, 2138 bool isImplicit) { 2139 getSema().CheckCXXThisCapture(ThisLoc); 2140 return getSema().Owned( 2141 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, 2142 isImplicit)); 2143 } 2144 2145 /// \brief Build a new C++ throw expression. 2146 /// 2147 /// By default, performs semantic analysis to build the new expression. 2148 /// Subclasses may override this routine to provide different behavior. 2149 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub, 2150 bool IsThrownVariableInScope) { 2151 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope); 2152 } 2153 2154 /// \brief Build a new C++ default-argument expression. 2155 /// 2156 /// By default, builds a new default-argument expression, which does not 2157 /// require any semantic analysis. Subclasses may override this routine to 2158 /// provide different behavior. 2159 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, 2160 ParmVarDecl *Param) { 2161 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc, 2162 Param)); 2163 } 2164 2165 /// \brief Build a new C++11 default-initialization expression. 2166 /// 2167 /// By default, builds a new default field initialization expression, which 2168 /// does not require any semantic analysis. Subclasses may override this 2169 /// routine to provide different behavior. 2170 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, 2171 FieldDecl *Field) { 2172 return getSema().Owned(CXXDefaultInitExpr::Create(getSema().Context, Loc, 2173 Field)); 2174 } 2175 2176 /// \brief Build a new C++ zero-initialization expression. 2177 /// 2178 /// By default, performs semantic analysis to build the new expression. 2179 /// Subclasses may override this routine to provide different behavior. 2180 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo, 2181 SourceLocation LParenLoc, 2182 SourceLocation RParenLoc) { 2183 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, 2184 None, RParenLoc); 2185 } 2186 2187 /// \brief Build a new C++ "new" expression. 2188 /// 2189 /// By default, performs semantic analysis to build the new expression. 2190 /// Subclasses may override this routine to provide different behavior. 2191 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, 2192 bool UseGlobal, 2193 SourceLocation PlacementLParen, 2194 MultiExprArg PlacementArgs, 2195 SourceLocation PlacementRParen, 2196 SourceRange TypeIdParens, 2197 QualType AllocatedType, 2198 TypeSourceInfo *AllocatedTypeInfo, 2199 Expr *ArraySize, 2200 SourceRange DirectInitRange, 2201 Expr *Initializer) { 2202 return getSema().BuildCXXNew(StartLoc, UseGlobal, 2203 PlacementLParen, 2204 PlacementArgs, 2205 PlacementRParen, 2206 TypeIdParens, 2207 AllocatedType, 2208 AllocatedTypeInfo, 2209 ArraySize, 2210 DirectInitRange, 2211 Initializer); 2212 } 2213 2214 /// \brief Build a new C++ "delete" expression. 2215 /// 2216 /// By default, performs semantic analysis to build the new expression. 2217 /// Subclasses may override this routine to provide different behavior. 2218 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, 2219 bool IsGlobalDelete, 2220 bool IsArrayForm, 2221 Expr *Operand) { 2222 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, 2223 Operand); 2224 } 2225 2226 /// \brief Build a new type trait expression. 2227 /// 2228 /// By default, performs semantic analysis to build the new expression. 2229 /// Subclasses may override this routine to provide different behavior. 2230 ExprResult RebuildTypeTrait(TypeTrait Trait, 2231 SourceLocation StartLoc, 2232 ArrayRef<TypeSourceInfo *> Args, 2233 SourceLocation RParenLoc) { 2234 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc); 2235 } 2236 2237 /// \brief Build a new array type trait expression. 2238 /// 2239 /// By default, performs semantic analysis to build the new expression. 2240 /// Subclasses may override this routine to provide different behavior. 2241 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait, 2242 SourceLocation StartLoc, 2243 TypeSourceInfo *TSInfo, 2244 Expr *DimExpr, 2245 SourceLocation RParenLoc) { 2246 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc); 2247 } 2248 2249 /// \brief Build a new expression trait expression. 2250 /// 2251 /// By default, performs semantic analysis to build the new expression. 2252 /// Subclasses may override this routine to provide different behavior. 2253 ExprResult RebuildExpressionTrait(ExpressionTrait Trait, 2254 SourceLocation StartLoc, 2255 Expr *Queried, 2256 SourceLocation RParenLoc) { 2257 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc); 2258 } 2259 2260 /// \brief Build a new (previously unresolved) declaration reference 2261 /// expression. 2262 /// 2263 /// By default, performs semantic analysis to build the new expression. 2264 /// Subclasses may override this routine to provide different behavior. 2265 ExprResult RebuildDependentScopeDeclRefExpr( 2266 NestedNameSpecifierLoc QualifierLoc, 2267 SourceLocation TemplateKWLoc, 2268 const DeclarationNameInfo &NameInfo, 2269 const TemplateArgumentListInfo *TemplateArgs, 2270 bool IsAddressOfOperand) { 2271 CXXScopeSpec SS; 2272 SS.Adopt(QualifierLoc); 2273 2274 if (TemplateArgs || TemplateKWLoc.isValid()) 2275 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, 2276 NameInfo, TemplateArgs); 2277 2278 return getSema().BuildQualifiedDeclarationNameExpr(SS, NameInfo, 2279 IsAddressOfOperand); 2280 } 2281 2282 /// \brief Build a new template-id expression. 2283 /// 2284 /// By default, performs semantic analysis to build the new expression. 2285 /// Subclasses may override this routine to provide different behavior. 2286 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS, 2287 SourceLocation TemplateKWLoc, 2288 LookupResult &R, 2289 bool RequiresADL, 2290 const TemplateArgumentListInfo *TemplateArgs) { 2291 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL, 2292 TemplateArgs); 2293 } 2294 2295 /// \brief Build a new object-construction expression. 2296 /// 2297 /// By default, performs semantic analysis to build the new expression. 2298 /// Subclasses may override this routine to provide different behavior. 2299 ExprResult RebuildCXXConstructExpr(QualType T, 2300 SourceLocation Loc, 2301 CXXConstructorDecl *Constructor, 2302 bool IsElidable, 2303 MultiExprArg Args, 2304 bool HadMultipleCandidates, 2305 bool ListInitialization, 2306 bool RequiresZeroInit, 2307 CXXConstructExpr::ConstructionKind ConstructKind, 2308 SourceRange ParenRange) { 2309 SmallVector<Expr*, 8> ConvertedArgs; 2310 if (getSema().CompleteConstructorCall(Constructor, Args, Loc, 2311 ConvertedArgs)) 2312 return ExprError(); 2313 2314 return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable, 2315 ConvertedArgs, 2316 HadMultipleCandidates, 2317 ListInitialization, 2318 RequiresZeroInit, ConstructKind, 2319 ParenRange); 2320 } 2321 2322 /// \brief Build a new object-construction expression. 2323 /// 2324 /// By default, performs semantic analysis to build the new expression. 2325 /// Subclasses may override this routine to provide different behavior. 2326 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo, 2327 SourceLocation LParenLoc, 2328 MultiExprArg Args, 2329 SourceLocation RParenLoc) { 2330 return getSema().BuildCXXTypeConstructExpr(TSInfo, 2331 LParenLoc, 2332 Args, 2333 RParenLoc); 2334 } 2335 2336 /// \brief Build a new object-construction expression. 2337 /// 2338 /// By default, performs semantic analysis to build the new expression. 2339 /// Subclasses may override this routine to provide different behavior. 2340 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo, 2341 SourceLocation LParenLoc, 2342 MultiExprArg Args, 2343 SourceLocation RParenLoc) { 2344 return getSema().BuildCXXTypeConstructExpr(TSInfo, 2345 LParenLoc, 2346 Args, 2347 RParenLoc); 2348 } 2349 2350 /// \brief Build a new member reference expression. 2351 /// 2352 /// By default, performs semantic analysis to build the new expression. 2353 /// Subclasses may override this routine to provide different behavior. 2354 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE, 2355 QualType BaseType, 2356 bool IsArrow, 2357 SourceLocation OperatorLoc, 2358 NestedNameSpecifierLoc QualifierLoc, 2359 SourceLocation TemplateKWLoc, 2360 NamedDecl *FirstQualifierInScope, 2361 const DeclarationNameInfo &MemberNameInfo, 2362 const TemplateArgumentListInfo *TemplateArgs) { 2363 CXXScopeSpec SS; 2364 SS.Adopt(QualifierLoc); 2365 2366 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, 2367 OperatorLoc, IsArrow, 2368 SS, TemplateKWLoc, 2369 FirstQualifierInScope, 2370 MemberNameInfo, 2371 TemplateArgs); 2372 } 2373 2374 /// \brief Build a new member reference expression. 2375 /// 2376 /// By default, performs semantic analysis to build the new expression. 2377 /// Subclasses may override this routine to provide different behavior. 2378 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType, 2379 SourceLocation OperatorLoc, 2380 bool IsArrow, 2381 NestedNameSpecifierLoc QualifierLoc, 2382 SourceLocation TemplateKWLoc, 2383 NamedDecl *FirstQualifierInScope, 2384 LookupResult &R, 2385 const TemplateArgumentListInfo *TemplateArgs) { 2386 CXXScopeSpec SS; 2387 SS.Adopt(QualifierLoc); 2388 2389 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, 2390 OperatorLoc, IsArrow, 2391 SS, TemplateKWLoc, 2392 FirstQualifierInScope, 2393 R, TemplateArgs); 2394 } 2395 2396 /// \brief Build a new noexcept expression. 2397 /// 2398 /// By default, performs semantic analysis to build the new expression. 2399 /// Subclasses may override this routine to provide different behavior. 2400 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) { 2401 return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd()); 2402 } 2403 2404 /// \brief Build a new expression to compute the length of a parameter pack. 2405 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, 2406 SourceLocation PackLoc, 2407 SourceLocation RParenLoc, 2408 Optional<unsigned> Length) { 2409 if (Length) 2410 return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(), 2411 OperatorLoc, Pack, PackLoc, 2412 RParenLoc, *Length); 2413 2414 return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(), 2415 OperatorLoc, Pack, PackLoc, 2416 RParenLoc); 2417 } 2418 2419 /// \brief Build a new Objective-C boxed expression. 2420 /// 2421 /// By default, performs semantic analysis to build the new expression. 2422 /// Subclasses may override this routine to provide different behavior. 2423 ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) { 2424 return getSema().BuildObjCBoxedExpr(SR, ValueExpr); 2425 } 2426 2427 /// \brief Build a new Objective-C array literal. 2428 /// 2429 /// By default, performs semantic analysis to build the new expression. 2430 /// Subclasses may override this routine to provide different behavior. 2431 ExprResult RebuildObjCArrayLiteral(SourceRange Range, 2432 Expr **Elements, unsigned NumElements) { 2433 return getSema().BuildObjCArrayLiteral(Range, 2434 MultiExprArg(Elements, NumElements)); 2435 } 2436 2437 ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB, 2438 Expr *Base, Expr *Key, 2439 ObjCMethodDecl *getterMethod, 2440 ObjCMethodDecl *setterMethod) { 2441 return getSema().BuildObjCSubscriptExpression(RB, Base, Key, 2442 getterMethod, setterMethod); 2443 } 2444 2445 /// \brief Build a new Objective-C dictionary literal. 2446 /// 2447 /// By default, performs semantic analysis to build the new expression. 2448 /// Subclasses may override this routine to provide different behavior. 2449 ExprResult RebuildObjCDictionaryLiteral(SourceRange Range, 2450 ObjCDictionaryElement *Elements, 2451 unsigned NumElements) { 2452 return getSema().BuildObjCDictionaryLiteral(Range, Elements, NumElements); 2453 } 2454 2455 /// \brief Build a new Objective-C \@encode expression. 2456 /// 2457 /// By default, performs semantic analysis to build the new expression. 2458 /// Subclasses may override this routine to provide different behavior. 2459 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 2460 TypeSourceInfo *EncodeTypeInfo, 2461 SourceLocation RParenLoc) { 2462 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, 2463 RParenLoc)); 2464 } 2465 2466 /// \brief Build a new Objective-C class message. 2467 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo, 2468 Selector Sel, 2469 ArrayRef<SourceLocation> SelectorLocs, 2470 ObjCMethodDecl *Method, 2471 SourceLocation LBracLoc, 2472 MultiExprArg Args, 2473 SourceLocation RBracLoc) { 2474 return SemaRef.BuildClassMessage(ReceiverTypeInfo, 2475 ReceiverTypeInfo->getType(), 2476 /*SuperLoc=*/SourceLocation(), 2477 Sel, Method, LBracLoc, SelectorLocs, 2478 RBracLoc, Args); 2479 } 2480 2481 /// \brief Build a new Objective-C instance message. 2482 ExprResult RebuildObjCMessageExpr(Expr *Receiver, 2483 Selector Sel, 2484 ArrayRef<SourceLocation> SelectorLocs, 2485 ObjCMethodDecl *Method, 2486 SourceLocation LBracLoc, 2487 MultiExprArg Args, 2488 SourceLocation RBracLoc) { 2489 return SemaRef.BuildInstanceMessage(Receiver, 2490 Receiver->getType(), 2491 /*SuperLoc=*/SourceLocation(), 2492 Sel, Method, LBracLoc, SelectorLocs, 2493 RBracLoc, Args); 2494 } 2495 2496 /// \brief Build a new Objective-C ivar reference expression. 2497 /// 2498 /// By default, performs semantic analysis to build the new expression. 2499 /// Subclasses may override this routine to provide different behavior. 2500 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar, 2501 SourceLocation IvarLoc, 2502 bool IsArrow, bool IsFreeIvar) { 2503 // FIXME: We lose track of the IsFreeIvar bit. 2504 CXXScopeSpec SS; 2505 ExprResult Base = getSema().Owned(BaseArg); 2506 LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc, 2507 Sema::LookupMemberName); 2508 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2509 /*FIME:*/IvarLoc, 2510 SS, nullptr, 2511 false); 2512 if (Result.isInvalid() || Base.isInvalid()) 2513 return ExprError(); 2514 2515 if (Result.get()) 2516 return Result; 2517 2518 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2519 /*FIXME:*/IvarLoc, IsArrow, 2520 SS, SourceLocation(), 2521 /*FirstQualifierInScope=*/nullptr, 2522 R, 2523 /*TemplateArgs=*/nullptr); 2524 } 2525 2526 /// \brief Build a new Objective-C property reference expression. 2527 /// 2528 /// By default, performs semantic analysis to build the new expression. 2529 /// Subclasses may override this routine to provide different behavior. 2530 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg, 2531 ObjCPropertyDecl *Property, 2532 SourceLocation PropertyLoc) { 2533 CXXScopeSpec SS; 2534 ExprResult Base = getSema().Owned(BaseArg); 2535 LookupResult R(getSema(), Property->getDeclName(), PropertyLoc, 2536 Sema::LookupMemberName); 2537 bool IsArrow = false; 2538 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2539 /*FIME:*/PropertyLoc, 2540 SS, nullptr, false); 2541 if (Result.isInvalid() || Base.isInvalid()) 2542 return ExprError(); 2543 2544 if (Result.get()) 2545 return Result; 2546 2547 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2548 /*FIXME:*/PropertyLoc, IsArrow, 2549 SS, SourceLocation(), 2550 /*FirstQualifierInScope=*/nullptr, 2551 R, /*TemplateArgs=*/nullptr); 2552 } 2553 2554 /// \brief Build a new Objective-C property reference expression. 2555 /// 2556 /// By default, performs semantic analysis to build the new expression. 2557 /// Subclasses may override this routine to provide different behavior. 2558 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T, 2559 ObjCMethodDecl *Getter, 2560 ObjCMethodDecl *Setter, 2561 SourceLocation PropertyLoc) { 2562 // Since these expressions can only be value-dependent, we do not 2563 // need to perform semantic analysis again. 2564 return Owned( 2565 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T, 2566 VK_LValue, OK_ObjCProperty, 2567 PropertyLoc, Base)); 2568 } 2569 2570 /// \brief Build a new Objective-C "isa" expression. 2571 /// 2572 /// By default, performs semantic analysis to build the new expression. 2573 /// Subclasses may override this routine to provide different behavior. 2574 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc, 2575 SourceLocation OpLoc, 2576 bool IsArrow) { 2577 CXXScopeSpec SS; 2578 ExprResult Base = getSema().Owned(BaseArg); 2579 LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc, 2580 Sema::LookupMemberName); 2581 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2582 OpLoc, 2583 SS, nullptr, false); 2584 if (Result.isInvalid() || Base.isInvalid()) 2585 return ExprError(); 2586 2587 if (Result.get()) 2588 return Result; 2589 2590 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2591 OpLoc, IsArrow, 2592 SS, SourceLocation(), 2593 /*FirstQualifierInScope=*/nullptr, 2594 R, 2595 /*TemplateArgs=*/nullptr); 2596 } 2597 2598 /// \brief Build a new shuffle vector expression. 2599 /// 2600 /// By default, performs semantic analysis to build the new expression. 2601 /// Subclasses may override this routine to provide different behavior. 2602 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 2603 MultiExprArg SubExprs, 2604 SourceLocation RParenLoc) { 2605 // Find the declaration for __builtin_shufflevector 2606 const IdentifierInfo &Name 2607 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 2608 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 2609 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 2610 assert(!Lookup.empty() && "No __builtin_shufflevector?"); 2611 2612 // Build a reference to the __builtin_shufflevector builtin 2613 FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front()); 2614 Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, false, 2615 SemaRef.Context.BuiltinFnTy, 2616 VK_RValue, BuiltinLoc); 2617 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType()); 2618 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy, 2619 CK_BuiltinFnToFnPtr).take(); 2620 2621 // Build the CallExpr 2622 ExprResult TheCall = SemaRef.Owned(new (SemaRef.Context) CallExpr( 2623 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(), 2624 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc)); 2625 2626 // Type-check the __builtin_shufflevector expression. 2627 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.take())); 2628 } 2629 2630 /// \brief Build a new convert vector expression. 2631 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc, 2632 Expr *SrcExpr, TypeSourceInfo *DstTInfo, 2633 SourceLocation RParenLoc) { 2634 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo, 2635 BuiltinLoc, RParenLoc); 2636 } 2637 2638 /// \brief Build a new template argument pack expansion. 2639 /// 2640 /// By default, performs semantic analysis to build a new pack expansion 2641 /// for a template argument. Subclasses may override this routine to provide 2642 /// different behavior. 2643 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, 2644 SourceLocation EllipsisLoc, 2645 Optional<unsigned> NumExpansions) { 2646 switch (Pattern.getArgument().getKind()) { 2647 case TemplateArgument::Expression: { 2648 ExprResult Result 2649 = getSema().CheckPackExpansion(Pattern.getSourceExpression(), 2650 EllipsisLoc, NumExpansions); 2651 if (Result.isInvalid()) 2652 return TemplateArgumentLoc(); 2653 2654 return TemplateArgumentLoc(Result.get(), Result.get()); 2655 } 2656 2657 case TemplateArgument::Template: 2658 return TemplateArgumentLoc(TemplateArgument( 2659 Pattern.getArgument().getAsTemplate(), 2660 NumExpansions), 2661 Pattern.getTemplateQualifierLoc(), 2662 Pattern.getTemplateNameLoc(), 2663 EllipsisLoc); 2664 2665 case TemplateArgument::Null: 2666 case TemplateArgument::Integral: 2667 case TemplateArgument::Declaration: 2668 case TemplateArgument::Pack: 2669 case TemplateArgument::TemplateExpansion: 2670 case TemplateArgument::NullPtr: 2671 llvm_unreachable("Pack expansion pattern has no parameter packs"); 2672 2673 case TemplateArgument::Type: 2674 if (TypeSourceInfo *Expansion 2675 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(), 2676 EllipsisLoc, 2677 NumExpansions)) 2678 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()), 2679 Expansion); 2680 break; 2681 } 2682 2683 return TemplateArgumentLoc(); 2684 } 2685 2686 /// \brief Build a new expression pack expansion. 2687 /// 2688 /// By default, performs semantic analysis to build a new pack expansion 2689 /// for an expression. Subclasses may override this routine to provide 2690 /// different behavior. 2691 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 2692 Optional<unsigned> NumExpansions) { 2693 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); 2694 } 2695 2696 /// \brief Build a new atomic operation expression. 2697 /// 2698 /// By default, performs semantic analysis to build the new expression. 2699 /// Subclasses may override this routine to provide different behavior. 2700 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, 2701 MultiExprArg SubExprs, 2702 QualType RetTy, 2703 AtomicExpr::AtomicOp Op, 2704 SourceLocation RParenLoc) { 2705 // Just create the expression; there is not any interesting semantic 2706 // analysis here because we can't actually build an AtomicExpr until 2707 // we are sure it is semantically sound. 2708 return new (SemaRef.Context) AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op, 2709 RParenLoc); 2710 } 2711 2712private: 2713 TypeLoc TransformTypeInObjectScope(TypeLoc TL, 2714 QualType ObjectType, 2715 NamedDecl *FirstQualifierInScope, 2716 CXXScopeSpec &SS); 2717 2718 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 2719 QualType ObjectType, 2720 NamedDecl *FirstQualifierInScope, 2721 CXXScopeSpec &SS); 2722 2723 TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType, 2724 NamedDecl *FirstQualifierInScope, 2725 CXXScopeSpec &SS); 2726}; 2727 2728template<typename Derived> 2729StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 2730 if (!S) 2731 return SemaRef.Owned(S); 2732 2733 switch (S->getStmtClass()) { 2734 case Stmt::NoStmtClass: break; 2735 2736 // Transform individual statement nodes 2737#define STMT(Node, Parent) \ 2738 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 2739#define ABSTRACT_STMT(Node) 2740#define EXPR(Node, Parent) 2741#include "clang/AST/StmtNodes.inc" 2742 2743 // Transform expressions by calling TransformExpr. 2744#define STMT(Node, Parent) 2745#define ABSTRACT_STMT(Stmt) 2746#define EXPR(Node, Parent) case Stmt::Node##Class: 2747#include "clang/AST/StmtNodes.inc" 2748 { 2749 ExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 2750 if (E.isInvalid()) 2751 return StmtError(); 2752 2753 return getSema().ActOnExprStmt(E); 2754 } 2755 } 2756 2757 return SemaRef.Owned(S); 2758} 2759 2760template<typename Derived> 2761OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) { 2762 if (!S) 2763 return S; 2764 2765 switch (S->getClauseKind()) { 2766 default: break; 2767 // Transform individual clause nodes 2768#define OPENMP_CLAUSE(Name, Class) \ 2769 case OMPC_ ## Name : \ 2770 return getDerived().Transform ## Class(cast<Class>(S)); 2771#include "clang/Basic/OpenMPKinds.def" 2772 } 2773 2774 return S; 2775} 2776 2777 2778template<typename Derived> 2779ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { 2780 if (!E) 2781 return SemaRef.Owned(E); 2782 2783 switch (E->getStmtClass()) { 2784 case Stmt::NoStmtClass: break; 2785#define STMT(Node, Parent) case Stmt::Node##Class: break; 2786#define ABSTRACT_STMT(Stmt) 2787#define EXPR(Node, Parent) \ 2788 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 2789#include "clang/AST/StmtNodes.inc" 2790 } 2791 2792 return SemaRef.Owned(E); 2793} 2794 2795template<typename Derived> 2796ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, 2797 bool CXXDirectInit) { 2798 // Initializers are instantiated like expressions, except that various outer 2799 // layers are stripped. 2800 if (!Init) 2801 return SemaRef.Owned(Init); 2802 2803 if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init)) 2804 Init = ExprTemp->getSubExpr(); 2805 2806 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init)) 2807 Init = MTE->GetTemporaryExpr(); 2808 2809 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init)) 2810 Init = Binder->getSubExpr(); 2811 2812 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init)) 2813 Init = ICE->getSubExprAsWritten(); 2814 2815 if (CXXStdInitializerListExpr *ILE = 2816 dyn_cast<CXXStdInitializerListExpr>(Init)) 2817 return TransformInitializer(ILE->getSubExpr(), CXXDirectInit); 2818 2819 // If this is not a direct-initializer, we only need to reconstruct 2820 // InitListExprs. Other forms of copy-initialization will be a no-op if 2821 // the initializer is already the right type. 2822 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init); 2823 if (!CXXDirectInit && !(Construct && Construct->isListInitialization())) 2824 return getDerived().TransformExpr(Init); 2825 2826 // Revert value-initialization back to empty parens. 2827 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { 2828 SourceRange Parens = VIE->getSourceRange(); 2829 return getDerived().RebuildParenListExpr(Parens.getBegin(), None, 2830 Parens.getEnd()); 2831 } 2832 2833 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. 2834 if (isa<ImplicitValueInitExpr>(Init)) 2835 return getDerived().RebuildParenListExpr(SourceLocation(), None, 2836 SourceLocation()); 2837 2838 // Revert initialization by constructor back to a parenthesized or braced list 2839 // of expressions. Any other form of initializer can just be reused directly. 2840 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct)) 2841 return getDerived().TransformExpr(Init); 2842 2843 SmallVector<Expr*, 8> NewArgs; 2844 bool ArgChanged = false; 2845 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(), 2846 /*IsCall*/true, NewArgs, &ArgChanged)) 2847 return ExprError(); 2848 2849 // If this was list initialization, revert to list form. 2850 if (Construct->isListInitialization()) 2851 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs, 2852 Construct->getLocEnd(), 2853 Construct->getType()); 2854 2855 // Build a ParenListExpr to represent anything else. 2856 SourceRange Parens = Construct->getParenOrBraceRange(); 2857 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs, 2858 Parens.getEnd()); 2859} 2860 2861template<typename Derived> 2862bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, 2863 unsigned NumInputs, 2864 bool IsCall, 2865 SmallVectorImpl<Expr *> &Outputs, 2866 bool *ArgChanged) { 2867 for (unsigned I = 0; I != NumInputs; ++I) { 2868 // If requested, drop call arguments that need to be dropped. 2869 if (IsCall && getDerived().DropCallArgument(Inputs[I])) { 2870 if (ArgChanged) 2871 *ArgChanged = true; 2872 2873 break; 2874 } 2875 2876 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { 2877 Expr *Pattern = Expansion->getPattern(); 2878 2879 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2880 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 2881 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 2882 2883 // Determine whether the set of unexpanded parameter packs can and should 2884 // be expanded. 2885 bool Expand = true; 2886 bool RetainExpansion = false; 2887 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); 2888 Optional<unsigned> NumExpansions = OrigNumExpansions; 2889 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 2890 Pattern->getSourceRange(), 2891 Unexpanded, 2892 Expand, RetainExpansion, 2893 NumExpansions)) 2894 return true; 2895 2896 if (!Expand) { 2897 // The transform has determined that we should perform a simple 2898 // transformation on the pack expansion, producing another pack 2899 // expansion. 2900 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2901 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 2902 if (OutPattern.isInvalid()) 2903 return true; 2904 2905 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 2906 Expansion->getEllipsisLoc(), 2907 NumExpansions); 2908 if (Out.isInvalid()) 2909 return true; 2910 2911 if (ArgChanged) 2912 *ArgChanged = true; 2913 Outputs.push_back(Out.get()); 2914 continue; 2915 } 2916 2917 // Record right away that the argument was changed. This needs 2918 // to happen even if the array expands to nothing. 2919 if (ArgChanged) *ArgChanged = true; 2920 2921 // The transform has determined that we should perform an elementwise 2922 // expansion of the pattern. Do so. 2923 for (unsigned I = 0; I != *NumExpansions; ++I) { 2924 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2925 ExprResult Out = getDerived().TransformExpr(Pattern); 2926 if (Out.isInvalid()) 2927 return true; 2928 2929 if (Out.get()->containsUnexpandedParameterPack()) { 2930 Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), 2931 OrigNumExpansions); 2932 if (Out.isInvalid()) 2933 return true; 2934 } 2935 2936 Outputs.push_back(Out.get()); 2937 } 2938 2939 continue; 2940 } 2941 2942 ExprResult Result = 2943 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false) 2944 : getDerived().TransformExpr(Inputs[I]); 2945 if (Result.isInvalid()) 2946 return true; 2947 2948 if (Result.get() != Inputs[I] && ArgChanged) 2949 *ArgChanged = true; 2950 2951 Outputs.push_back(Result.get()); 2952 } 2953 2954 return false; 2955} 2956 2957template<typename Derived> 2958NestedNameSpecifierLoc 2959TreeTransform<Derived>::TransformNestedNameSpecifierLoc( 2960 NestedNameSpecifierLoc NNS, 2961 QualType ObjectType, 2962 NamedDecl *FirstQualifierInScope) { 2963 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 2964 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; 2965 Qualifier = Qualifier.getPrefix()) 2966 Qualifiers.push_back(Qualifier); 2967 2968 CXXScopeSpec SS; 2969 while (!Qualifiers.empty()) { 2970 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 2971 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier(); 2972 2973 switch (QNNS->getKind()) { 2974 case NestedNameSpecifier::Identifier: 2975 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, 2976 *QNNS->getAsIdentifier(), 2977 Q.getLocalBeginLoc(), 2978 Q.getLocalEndLoc(), 2979 ObjectType, false, SS, 2980 FirstQualifierInScope, false)) 2981 return NestedNameSpecifierLoc(); 2982 2983 break; 2984 2985 case NestedNameSpecifier::Namespace: { 2986 NamespaceDecl *NS 2987 = cast_or_null<NamespaceDecl>( 2988 getDerived().TransformDecl( 2989 Q.getLocalBeginLoc(), 2990 QNNS->getAsNamespace())); 2991 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); 2992 break; 2993 } 2994 2995 case NestedNameSpecifier::NamespaceAlias: { 2996 NamespaceAliasDecl *Alias 2997 = cast_or_null<NamespaceAliasDecl>( 2998 getDerived().TransformDecl(Q.getLocalBeginLoc(), 2999 QNNS->getAsNamespaceAlias())); 3000 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(), 3001 Q.getLocalEndLoc()); 3002 break; 3003 } 3004 3005 case NestedNameSpecifier::Global: 3006 // There is no meaningful transformation that one could perform on the 3007 // global scope. 3008 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); 3009 break; 3010 3011 case NestedNameSpecifier::TypeSpecWithTemplate: 3012 case NestedNameSpecifier::TypeSpec: { 3013 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType, 3014 FirstQualifierInScope, SS); 3015 3016 if (!TL) 3017 return NestedNameSpecifierLoc(); 3018 3019 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || 3020 (SemaRef.getLangOpts().CPlusPlus11 && 3021 TL.getType()->isEnumeralType())) { 3022 assert(!TL.getType().hasLocalQualifiers() && 3023 "Can't get cv-qualifiers here"); 3024 if (TL.getType()->isEnumeralType()) 3025 SemaRef.Diag(TL.getBeginLoc(), 3026 diag::warn_cxx98_compat_enum_nested_name_spec); 3027 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL, 3028 Q.getLocalEndLoc()); 3029 break; 3030 } 3031 // If the nested-name-specifier is an invalid type def, don't emit an 3032 // error because a previous error should have already been emitted. 3033 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>(); 3034 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { 3035 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) 3036 << TL.getType() << SS.getRange(); 3037 } 3038 return NestedNameSpecifierLoc(); 3039 } 3040 } 3041 3042 // The qualifier-in-scope and object type only apply to the leftmost entity. 3043 FirstQualifierInScope = nullptr; 3044 ObjectType = QualType(); 3045 } 3046 3047 // Don't rebuild the nested-name-specifier if we don't have to. 3048 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && 3049 !getDerived().AlwaysRebuild()) 3050 return NNS; 3051 3052 // If we can re-use the source-location data from the original 3053 // nested-name-specifier, do so. 3054 if (SS.location_size() == NNS.getDataLength() && 3055 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) 3056 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); 3057 3058 // Allocate new nested-name-specifier location information. 3059 return SS.getWithLocInContext(SemaRef.Context); 3060} 3061 3062template<typename Derived> 3063DeclarationNameInfo 3064TreeTransform<Derived> 3065::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 3066 DeclarationName Name = NameInfo.getName(); 3067 if (!Name) 3068 return DeclarationNameInfo(); 3069 3070 switch (Name.getNameKind()) { 3071 case DeclarationName::Identifier: 3072 case DeclarationName::ObjCZeroArgSelector: 3073 case DeclarationName::ObjCOneArgSelector: 3074 case DeclarationName::ObjCMultiArgSelector: 3075 case DeclarationName::CXXOperatorName: 3076 case DeclarationName::CXXLiteralOperatorName: 3077 case DeclarationName::CXXUsingDirective: 3078 return NameInfo; 3079 3080 case DeclarationName::CXXConstructorName: 3081 case DeclarationName::CXXDestructorName: 3082 case DeclarationName::CXXConversionFunctionName: { 3083 TypeSourceInfo *NewTInfo; 3084 CanQualType NewCanTy; 3085 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 3086 NewTInfo = getDerived().TransformType(OldTInfo); 3087 if (!NewTInfo) 3088 return DeclarationNameInfo(); 3089 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 3090 } 3091 else { 3092 NewTInfo = nullptr; 3093 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 3094 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 3095 if (NewT.isNull()) 3096 return DeclarationNameInfo(); 3097 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 3098 } 3099 3100 DeclarationName NewName 3101 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 3102 NewCanTy); 3103 DeclarationNameInfo NewNameInfo(NameInfo); 3104 NewNameInfo.setName(NewName); 3105 NewNameInfo.setNamedTypeInfo(NewTInfo); 3106 return NewNameInfo; 3107 } 3108 } 3109 3110 llvm_unreachable("Unknown name kind."); 3111} 3112 3113template<typename Derived> 3114TemplateName 3115TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, 3116 TemplateName Name, 3117 SourceLocation NameLoc, 3118 QualType ObjectType, 3119 NamedDecl *FirstQualifierInScope) { 3120 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 3121 TemplateDecl *Template = QTN->getTemplateDecl(); 3122 assert(Template && "qualified template name must refer to a template"); 3123 3124 TemplateDecl *TransTemplate 3125 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 3126 Template)); 3127 if (!TransTemplate) 3128 return TemplateName(); 3129 3130 if (!getDerived().AlwaysRebuild() && 3131 SS.getScopeRep() == QTN->getQualifier() && 3132 TransTemplate == Template) 3133 return Name; 3134 3135 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(), 3136 TransTemplate); 3137 } 3138 3139 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 3140 if (SS.getScopeRep()) { 3141 // These apply to the scope specifier, not the template. 3142 ObjectType = QualType(); 3143 FirstQualifierInScope = nullptr; 3144 } 3145 3146 if (!getDerived().AlwaysRebuild() && 3147 SS.getScopeRep() == DTN->getQualifier() && 3148 ObjectType.isNull()) 3149 return Name; 3150 3151 if (DTN->isIdentifier()) { 3152 return getDerived().RebuildTemplateName(SS, 3153 *DTN->getIdentifier(), 3154 NameLoc, 3155 ObjectType, 3156 FirstQualifierInScope); 3157 } 3158 3159 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc, 3160 ObjectType); 3161 } 3162 3163 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 3164 TemplateDecl *TransTemplate 3165 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 3166 Template)); 3167 if (!TransTemplate) 3168 return TemplateName(); 3169 3170 if (!getDerived().AlwaysRebuild() && 3171 TransTemplate == Template) 3172 return Name; 3173 3174 return TemplateName(TransTemplate); 3175 } 3176 3177 if (SubstTemplateTemplateParmPackStorage *SubstPack 3178 = Name.getAsSubstTemplateTemplateParmPack()) { 3179 TemplateTemplateParmDecl *TransParam 3180 = cast_or_null<TemplateTemplateParmDecl>( 3181 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); 3182 if (!TransParam) 3183 return TemplateName(); 3184 3185 if (!getDerived().AlwaysRebuild() && 3186 TransParam == SubstPack->getParameterPack()) 3187 return Name; 3188 3189 return getDerived().RebuildTemplateName(TransParam, 3190 SubstPack->getArgumentPack()); 3191 } 3192 3193 // These should be getting filtered out before they reach the AST. 3194 llvm_unreachable("overloaded function decl survived to here"); 3195} 3196 3197template<typename Derived> 3198void TreeTransform<Derived>::InventTemplateArgumentLoc( 3199 const TemplateArgument &Arg, 3200 TemplateArgumentLoc &Output) { 3201 SourceLocation Loc = getDerived().getBaseLocation(); 3202 switch (Arg.getKind()) { 3203 case TemplateArgument::Null: 3204 llvm_unreachable("null template argument in TreeTransform"); 3205 break; 3206 3207 case TemplateArgument::Type: 3208 Output = TemplateArgumentLoc(Arg, 3209 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 3210 3211 break; 3212 3213 case TemplateArgument::Template: 3214 case TemplateArgument::TemplateExpansion: { 3215 NestedNameSpecifierLocBuilder Builder; 3216 TemplateName Template = Arg.getAsTemplate(); 3217 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 3218 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc); 3219 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3220 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc); 3221 3222 if (Arg.getKind() == TemplateArgument::Template) 3223 Output = TemplateArgumentLoc(Arg, 3224 Builder.getWithLocInContext(SemaRef.Context), 3225 Loc); 3226 else 3227 Output = TemplateArgumentLoc(Arg, 3228 Builder.getWithLocInContext(SemaRef.Context), 3229 Loc, Loc); 3230 3231 break; 3232 } 3233 3234 case TemplateArgument::Expression: 3235 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 3236 break; 3237 3238 case TemplateArgument::Declaration: 3239 case TemplateArgument::Integral: 3240 case TemplateArgument::Pack: 3241 case TemplateArgument::NullPtr: 3242 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 3243 break; 3244 } 3245} 3246 3247template<typename Derived> 3248bool TreeTransform<Derived>::TransformTemplateArgument( 3249 const TemplateArgumentLoc &Input, 3250 TemplateArgumentLoc &Output) { 3251 const TemplateArgument &Arg = Input.getArgument(); 3252 switch (Arg.getKind()) { 3253 case TemplateArgument::Null: 3254 case TemplateArgument::Integral: 3255 case TemplateArgument::Pack: 3256 case TemplateArgument::Declaration: 3257 case TemplateArgument::NullPtr: 3258 llvm_unreachable("Unexpected TemplateArgument"); 3259 3260 case TemplateArgument::Type: { 3261 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 3262 if (!DI) 3263 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 3264 3265 DI = getDerived().TransformType(DI); 3266 if (!DI) return true; 3267 3268 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 3269 return false; 3270 } 3271 3272 case TemplateArgument::Template: { 3273 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc(); 3274 if (QualifierLoc) { 3275 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); 3276 if (!QualifierLoc) 3277 return true; 3278 } 3279 3280 CXXScopeSpec SS; 3281 SS.Adopt(QualifierLoc); 3282 TemplateName Template 3283 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(), 3284 Input.getTemplateNameLoc()); 3285 if (Template.isNull()) 3286 return true; 3287 3288 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc, 3289 Input.getTemplateNameLoc()); 3290 return false; 3291 } 3292 3293 case TemplateArgument::TemplateExpansion: 3294 llvm_unreachable("Caller should expand pack expansions"); 3295 3296 case TemplateArgument::Expression: { 3297 // Template argument expressions are constant expressions. 3298 EnterExpressionEvaluationContext Unevaluated(getSema(), 3299 Sema::ConstantEvaluated); 3300 3301 Expr *InputExpr = Input.getSourceExpression(); 3302 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 3303 3304 ExprResult E = getDerived().TransformExpr(InputExpr); 3305 E = SemaRef.ActOnConstantExpression(E); 3306 if (E.isInvalid()) return true; 3307 Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); 3308 return false; 3309 } 3310 } 3311 3312 // Work around bogus GCC warning 3313 return true; 3314} 3315 3316/// \brief Iterator adaptor that invents template argument location information 3317/// for each of the template arguments in its underlying iterator. 3318template<typename Derived, typename InputIterator> 3319class TemplateArgumentLocInventIterator { 3320 TreeTransform<Derived> &Self; 3321 InputIterator Iter; 3322 3323public: 3324 typedef TemplateArgumentLoc value_type; 3325 typedef TemplateArgumentLoc reference; 3326 typedef typename std::iterator_traits<InputIterator>::difference_type 3327 difference_type; 3328 typedef std::input_iterator_tag iterator_category; 3329 3330 class pointer { 3331 TemplateArgumentLoc Arg; 3332 3333 public: 3334 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3335 3336 const TemplateArgumentLoc *operator->() const { return &Arg; } 3337 }; 3338 3339 TemplateArgumentLocInventIterator() { } 3340 3341 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, 3342 InputIterator Iter) 3343 : Self(Self), Iter(Iter) { } 3344 3345 TemplateArgumentLocInventIterator &operator++() { 3346 ++Iter; 3347 return *this; 3348 } 3349 3350 TemplateArgumentLocInventIterator operator++(int) { 3351 TemplateArgumentLocInventIterator Old(*this); 3352 ++(*this); 3353 return Old; 3354 } 3355 3356 reference operator*() const { 3357 TemplateArgumentLoc Result; 3358 Self.InventTemplateArgumentLoc(*Iter, Result); 3359 return Result; 3360 } 3361 3362 pointer operator->() const { return pointer(**this); } 3363 3364 friend bool operator==(const TemplateArgumentLocInventIterator &X, 3365 const TemplateArgumentLocInventIterator &Y) { 3366 return X.Iter == Y.Iter; 3367 } 3368 3369 friend bool operator!=(const TemplateArgumentLocInventIterator &X, 3370 const TemplateArgumentLocInventIterator &Y) { 3371 return X.Iter != Y.Iter; 3372 } 3373}; 3374 3375template<typename Derived> 3376template<typename InputIterator> 3377bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, 3378 InputIterator Last, 3379 TemplateArgumentListInfo &Outputs) { 3380 for (; First != Last; ++First) { 3381 TemplateArgumentLoc Out; 3382 TemplateArgumentLoc In = *First; 3383 3384 if (In.getArgument().getKind() == TemplateArgument::Pack) { 3385 // Unpack argument packs, which we translate them into separate 3386 // arguments. 3387 // FIXME: We could do much better if we could guarantee that the 3388 // TemplateArgumentLocInfo for the pack expansion would be usable for 3389 // all of the template arguments in the argument pack. 3390 typedef TemplateArgumentLocInventIterator<Derived, 3391 TemplateArgument::pack_iterator> 3392 PackLocIterator; 3393 if (TransformTemplateArguments(PackLocIterator(*this, 3394 In.getArgument().pack_begin()), 3395 PackLocIterator(*this, 3396 In.getArgument().pack_end()), 3397 Outputs)) 3398 return true; 3399 3400 continue; 3401 } 3402 3403 if (In.getArgument().isPackExpansion()) { 3404 // We have a pack expansion, for which we will be substituting into 3405 // the pattern. 3406 SourceLocation Ellipsis; 3407 Optional<unsigned> OrigNumExpansions; 3408 TemplateArgumentLoc Pattern 3409 = getSema().getTemplateArgumentPackExpansionPattern( 3410 In, Ellipsis, OrigNumExpansions); 3411 3412 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3413 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3414 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 3415 3416 // Determine whether the set of unexpanded parameter packs can and should 3417 // be expanded. 3418 bool Expand = true; 3419 bool RetainExpansion = false; 3420 Optional<unsigned> NumExpansions = OrigNumExpansions; 3421 if (getDerived().TryExpandParameterPacks(Ellipsis, 3422 Pattern.getSourceRange(), 3423 Unexpanded, 3424 Expand, 3425 RetainExpansion, 3426 NumExpansions)) 3427 return true; 3428 3429 if (!Expand) { 3430 // The transform has determined that we should perform a simple 3431 // transformation on the pack expansion, producing another pack 3432 // expansion. 3433 TemplateArgumentLoc OutPattern; 3434 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3435 if (getDerived().TransformTemplateArgument(Pattern, OutPattern)) 3436 return true; 3437 3438 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis, 3439 NumExpansions); 3440 if (Out.getArgument().isNull()) 3441 return true; 3442 3443 Outputs.addArgument(Out); 3444 continue; 3445 } 3446 3447 // The transform has determined that we should perform an elementwise 3448 // expansion of the pattern. Do so. 3449 for (unsigned I = 0; I != *NumExpansions; ++I) { 3450 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3451 3452 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3453 return true; 3454 3455 if (Out.getArgument().containsUnexpandedParameterPack()) { 3456 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3457 OrigNumExpansions); 3458 if (Out.getArgument().isNull()) 3459 return true; 3460 } 3461 3462 Outputs.addArgument(Out); 3463 } 3464 3465 // If we're supposed to retain a pack expansion, do so by temporarily 3466 // forgetting the partially-substituted parameter pack. 3467 if (RetainExpansion) { 3468 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3469 3470 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3471 return true; 3472 3473 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3474 OrigNumExpansions); 3475 if (Out.getArgument().isNull()) 3476 return true; 3477 3478 Outputs.addArgument(Out); 3479 } 3480 3481 continue; 3482 } 3483 3484 // The simple case: 3485 if (getDerived().TransformTemplateArgument(In, Out)) 3486 return true; 3487 3488 Outputs.addArgument(Out); 3489 } 3490 3491 return false; 3492 3493} 3494 3495//===----------------------------------------------------------------------===// 3496// Type transformation 3497//===----------------------------------------------------------------------===// 3498 3499template<typename Derived> 3500QualType TreeTransform<Derived>::TransformType(QualType T) { 3501 if (getDerived().AlreadyTransformed(T)) 3502 return T; 3503 3504 // Temporary workaround. All of these transformations should 3505 // eventually turn into transformations on TypeLocs. 3506 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T, 3507 getDerived().getBaseLocation()); 3508 3509 TypeSourceInfo *NewDI = getDerived().TransformType(DI); 3510 3511 if (!NewDI) 3512 return QualType(); 3513 3514 return NewDI->getType(); 3515} 3516 3517template<typename Derived> 3518TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { 3519 // Refine the base location to the type's location. 3520 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(), 3521 getDerived().getBaseEntity()); 3522 if (getDerived().AlreadyTransformed(DI->getType())) 3523 return DI; 3524 3525 TypeLocBuilder TLB; 3526 3527 TypeLoc TL = DI->getTypeLoc(); 3528 TLB.reserve(TL.getFullDataSize()); 3529 3530 QualType Result = getDerived().TransformType(TLB, TL); 3531 if (Result.isNull()) 3532 return nullptr; 3533 3534 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3535} 3536 3537template<typename Derived> 3538QualType 3539TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 3540 switch (T.getTypeLocClass()) { 3541#define ABSTRACT_TYPELOC(CLASS, PARENT) 3542#define TYPELOC(CLASS, PARENT) \ 3543 case TypeLoc::CLASS: \ 3544 return getDerived().Transform##CLASS##Type(TLB, \ 3545 T.castAs<CLASS##TypeLoc>()); 3546#include "clang/AST/TypeLocNodes.def" 3547 } 3548 3549 llvm_unreachable("unhandled type loc!"); 3550} 3551 3552/// FIXME: By default, this routine adds type qualifiers only to types 3553/// that can have qualifiers, and silently suppresses those qualifiers 3554/// that are not permitted (e.g., qualifiers on reference or function 3555/// types). This is the right thing for template instantiation, but 3556/// probably not for other clients. 3557template<typename Derived> 3558QualType 3559TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 3560 QualifiedTypeLoc T) { 3561 Qualifiers Quals = T.getType().getLocalQualifiers(); 3562 3563 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 3564 if (Result.isNull()) 3565 return QualType(); 3566 3567 // Silently suppress qualifiers if the result type can't be qualified. 3568 // FIXME: this is the right thing for template instantiation, but 3569 // probably not for other clients. 3570 if (Result->isFunctionType() || Result->isReferenceType()) 3571 return Result; 3572 3573 // Suppress Objective-C lifetime qualifiers if they don't make sense for the 3574 // resulting type. 3575 if (Quals.hasObjCLifetime()) { 3576 if (!Result->isObjCLifetimeType() && !Result->isDependentType()) 3577 Quals.removeObjCLifetime(); 3578 else if (Result.getObjCLifetime()) { 3579 // Objective-C ARC: 3580 // A lifetime qualifier applied to a substituted template parameter 3581 // overrides the lifetime qualifier from the template argument. 3582 const AutoType *AutoTy; 3583 if (const SubstTemplateTypeParmType *SubstTypeParam 3584 = dyn_cast<SubstTemplateTypeParmType>(Result)) { 3585 QualType Replacement = SubstTypeParam->getReplacementType(); 3586 Qualifiers Qs = Replacement.getQualifiers(); 3587 Qs.removeObjCLifetime(); 3588 Replacement 3589 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), 3590 Qs); 3591 Result = SemaRef.Context.getSubstTemplateTypeParmType( 3592 SubstTypeParam->getReplacedParameter(), 3593 Replacement); 3594 TLB.TypeWasModifiedSafely(Result); 3595 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) { 3596 // 'auto' types behave the same way as template parameters. 3597 QualType Deduced = AutoTy->getDeducedType(); 3598 Qualifiers Qs = Deduced.getQualifiers(); 3599 Qs.removeObjCLifetime(); 3600 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), 3601 Qs); 3602 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->isDecltypeAuto(), 3603 AutoTy->isDependentType()); 3604 TLB.TypeWasModifiedSafely(Result); 3605 } else { 3606 // Otherwise, complain about the addition of a qualifier to an 3607 // already-qualified type. 3608 SourceRange R = T.getUnqualifiedLoc().getSourceRange(); 3609 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant) 3610 << Result << R; 3611 3612 Quals.removeObjCLifetime(); 3613 } 3614 } 3615 } 3616 if (!Quals.empty()) { 3617 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals); 3618 // BuildQualifiedType might not add qualifiers if they are invalid. 3619 if (Result.hasLocalQualifiers()) 3620 TLB.push<QualifiedTypeLoc>(Result); 3621 // No location information to preserve. 3622 } 3623 3624 return Result; 3625} 3626 3627template<typename Derived> 3628TypeLoc 3629TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL, 3630 QualType ObjectType, 3631 NamedDecl *UnqualLookup, 3632 CXXScopeSpec &SS) { 3633 if (getDerived().AlreadyTransformed(TL.getType())) 3634 return TL; 3635 3636 TypeSourceInfo *TSI = 3637 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS); 3638 if (TSI) 3639 return TSI->getTypeLoc(); 3640 return TypeLoc(); 3641} 3642 3643template<typename Derived> 3644TypeSourceInfo * 3645TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 3646 QualType ObjectType, 3647 NamedDecl *UnqualLookup, 3648 CXXScopeSpec &SS) { 3649 if (getDerived().AlreadyTransformed(TSInfo->getType())) 3650 return TSInfo; 3651 3652 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType, 3653 UnqualLookup, SS); 3654} 3655 3656template <typename Derived> 3657TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope( 3658 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup, 3659 CXXScopeSpec &SS) { 3660 QualType T = TL.getType(); 3661 assert(!getDerived().AlreadyTransformed(T)); 3662 3663 TypeLocBuilder TLB; 3664 QualType Result; 3665 3666 if (isa<TemplateSpecializationType>(T)) { 3667 TemplateSpecializationTypeLoc SpecTL = 3668 TL.castAs<TemplateSpecializationTypeLoc>(); 3669 3670 TemplateName Template 3671 = getDerived().TransformTemplateName(SS, 3672 SpecTL.getTypePtr()->getTemplateName(), 3673 SpecTL.getTemplateNameLoc(), 3674 ObjectType, UnqualLookup); 3675 if (Template.isNull()) 3676 return nullptr; 3677 3678 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3679 Template); 3680 } else if (isa<DependentTemplateSpecializationType>(T)) { 3681 DependentTemplateSpecializationTypeLoc SpecTL = 3682 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3683 3684 TemplateName Template 3685 = getDerived().RebuildTemplateName(SS, 3686 *SpecTL.getTypePtr()->getIdentifier(), 3687 SpecTL.getTemplateNameLoc(), 3688 ObjectType, UnqualLookup); 3689 if (Template.isNull()) 3690 return nullptr; 3691 3692 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3693 SpecTL, 3694 Template, 3695 SS); 3696 } else { 3697 // Nothing special needs to be done for these. 3698 Result = getDerived().TransformType(TLB, TL); 3699 } 3700 3701 if (Result.isNull()) 3702 return nullptr; 3703 3704 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3705} 3706 3707template <class TyLoc> static inline 3708QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 3709 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 3710 NewT.setNameLoc(T.getNameLoc()); 3711 return T.getType(); 3712} 3713 3714template<typename Derived> 3715QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 3716 BuiltinTypeLoc T) { 3717 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 3718 NewT.setBuiltinLoc(T.getBuiltinLoc()); 3719 if (T.needsExtraLocalData()) 3720 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 3721 return T.getType(); 3722} 3723 3724template<typename Derived> 3725QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 3726 ComplexTypeLoc T) { 3727 // FIXME: recurse? 3728 return TransformTypeSpecType(TLB, T); 3729} 3730 3731template <typename Derived> 3732QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB, 3733 AdjustedTypeLoc TL) { 3734 // Adjustments applied during transformation are handled elsewhere. 3735 return getDerived().TransformType(TLB, TL.getOriginalLoc()); 3736} 3737 3738template<typename Derived> 3739QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB, 3740 DecayedTypeLoc TL) { 3741 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc()); 3742 if (OriginalType.isNull()) 3743 return QualType(); 3744 3745 QualType Result = TL.getType(); 3746 if (getDerived().AlwaysRebuild() || 3747 OriginalType != TL.getOriginalLoc().getType()) 3748 Result = SemaRef.Context.getDecayedType(OriginalType); 3749 TLB.push<DecayedTypeLoc>(Result); 3750 // Nothing to set for DecayedTypeLoc. 3751 return Result; 3752} 3753 3754template<typename Derived> 3755QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 3756 PointerTypeLoc TL) { 3757 QualType PointeeType 3758 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3759 if (PointeeType.isNull()) 3760 return QualType(); 3761 3762 QualType Result = TL.getType(); 3763 if (PointeeType->getAs<ObjCObjectType>()) { 3764 // A dependent pointer type 'T *' has is being transformed such 3765 // that an Objective-C class type is being replaced for 'T'. The 3766 // resulting pointer type is an ObjCObjectPointerType, not a 3767 // PointerType. 3768 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); 3769 3770 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 3771 NewT.setStarLoc(TL.getStarLoc()); 3772 return Result; 3773 } 3774 3775 if (getDerived().AlwaysRebuild() || 3776 PointeeType != TL.getPointeeLoc().getType()) { 3777 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 3778 if (Result.isNull()) 3779 return QualType(); 3780 } 3781 3782 // Objective-C ARC can add lifetime qualifiers to the type that we're 3783 // pointing to. 3784 TLB.TypeWasModifiedSafely(Result->getPointeeType()); 3785 3786 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 3787 NewT.setSigilLoc(TL.getSigilLoc()); 3788 return Result; 3789} 3790 3791template<typename Derived> 3792QualType 3793TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 3794 BlockPointerTypeLoc TL) { 3795 QualType PointeeType 3796 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3797 if (PointeeType.isNull()) 3798 return QualType(); 3799 3800 QualType Result = TL.getType(); 3801 if (getDerived().AlwaysRebuild() || 3802 PointeeType != TL.getPointeeLoc().getType()) { 3803 Result = getDerived().RebuildBlockPointerType(PointeeType, 3804 TL.getSigilLoc()); 3805 if (Result.isNull()) 3806 return QualType(); 3807 } 3808 3809 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); 3810 NewT.setSigilLoc(TL.getSigilLoc()); 3811 return Result; 3812} 3813 3814/// Transforms a reference type. Note that somewhat paradoxically we 3815/// don't care whether the type itself is an l-value type or an r-value 3816/// type; we only care if the type was *written* as an l-value type 3817/// or an r-value type. 3818template<typename Derived> 3819QualType 3820TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 3821 ReferenceTypeLoc TL) { 3822 const ReferenceType *T = TL.getTypePtr(); 3823 3824 // Note that this works with the pointee-as-written. 3825 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3826 if (PointeeType.isNull()) 3827 return QualType(); 3828 3829 QualType Result = TL.getType(); 3830 if (getDerived().AlwaysRebuild() || 3831 PointeeType != T->getPointeeTypeAsWritten()) { 3832 Result = getDerived().RebuildReferenceType(PointeeType, 3833 T->isSpelledAsLValue(), 3834 TL.getSigilLoc()); 3835 if (Result.isNull()) 3836 return QualType(); 3837 } 3838 3839 // Objective-C ARC can add lifetime qualifiers to the type that we're 3840 // referring to. 3841 TLB.TypeWasModifiedSafely( 3842 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten()); 3843 3844 // r-value references can be rebuilt as l-value references. 3845 ReferenceTypeLoc NewTL; 3846 if (isa<LValueReferenceType>(Result)) 3847 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 3848 else 3849 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 3850 NewTL.setSigilLoc(TL.getSigilLoc()); 3851 3852 return Result; 3853} 3854 3855template<typename Derived> 3856QualType 3857TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 3858 LValueReferenceTypeLoc TL) { 3859 return TransformReferenceType(TLB, TL); 3860} 3861 3862template<typename Derived> 3863QualType 3864TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 3865 RValueReferenceTypeLoc TL) { 3866 return TransformReferenceType(TLB, TL); 3867} 3868 3869template<typename Derived> 3870QualType 3871TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 3872 MemberPointerTypeLoc TL) { 3873 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3874 if (PointeeType.isNull()) 3875 return QualType(); 3876 3877 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo(); 3878 TypeSourceInfo *NewClsTInfo = nullptr; 3879 if (OldClsTInfo) { 3880 NewClsTInfo = getDerived().TransformType(OldClsTInfo); 3881 if (!NewClsTInfo) 3882 return QualType(); 3883 } 3884 3885 const MemberPointerType *T = TL.getTypePtr(); 3886 QualType OldClsType = QualType(T->getClass(), 0); 3887 QualType NewClsType; 3888 if (NewClsTInfo) 3889 NewClsType = NewClsTInfo->getType(); 3890 else { 3891 NewClsType = getDerived().TransformType(OldClsType); 3892 if (NewClsType.isNull()) 3893 return QualType(); 3894 } 3895 3896 QualType Result = TL.getType(); 3897 if (getDerived().AlwaysRebuild() || 3898 PointeeType != T->getPointeeType() || 3899 NewClsType != OldClsType) { 3900 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType, 3901 TL.getStarLoc()); 3902 if (Result.isNull()) 3903 return QualType(); 3904 } 3905 3906 // If we had to adjust the pointee type when building a member pointer, make 3907 // sure to push TypeLoc info for it. 3908 const MemberPointerType *MPT = Result->getAs<MemberPointerType>(); 3909 if (MPT && PointeeType != MPT->getPointeeType()) { 3910 assert(isa<AdjustedType>(MPT->getPointeeType())); 3911 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType()); 3912 } 3913 3914 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 3915 NewTL.setSigilLoc(TL.getSigilLoc()); 3916 NewTL.setClassTInfo(NewClsTInfo); 3917 3918 return Result; 3919} 3920 3921template<typename Derived> 3922QualType 3923TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 3924 ConstantArrayTypeLoc TL) { 3925 const ConstantArrayType *T = TL.getTypePtr(); 3926 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3927 if (ElementType.isNull()) 3928 return QualType(); 3929 3930 QualType Result = TL.getType(); 3931 if (getDerived().AlwaysRebuild() || 3932 ElementType != T->getElementType()) { 3933 Result = getDerived().RebuildConstantArrayType(ElementType, 3934 T->getSizeModifier(), 3935 T->getSize(), 3936 T->getIndexTypeCVRQualifiers(), 3937 TL.getBracketsRange()); 3938 if (Result.isNull()) 3939 return QualType(); 3940 } 3941 3942 // We might have either a ConstantArrayType or a VariableArrayType now: 3943 // a ConstantArrayType is allowed to have an element type which is a 3944 // VariableArrayType if the type is dependent. Fortunately, all array 3945 // types have the same location layout. 3946 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3947 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3948 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3949 3950 Expr *Size = TL.getSizeExpr(); 3951 if (Size) { 3952 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3953 Sema::ConstantEvaluated); 3954 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 3955 Size = SemaRef.ActOnConstantExpression(Size).take(); 3956 } 3957 NewTL.setSizeExpr(Size); 3958 3959 return Result; 3960} 3961 3962template<typename Derived> 3963QualType TreeTransform<Derived>::TransformIncompleteArrayType( 3964 TypeLocBuilder &TLB, 3965 IncompleteArrayTypeLoc TL) { 3966 const IncompleteArrayType *T = TL.getTypePtr(); 3967 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3968 if (ElementType.isNull()) 3969 return QualType(); 3970 3971 QualType Result = TL.getType(); 3972 if (getDerived().AlwaysRebuild() || 3973 ElementType != T->getElementType()) { 3974 Result = getDerived().RebuildIncompleteArrayType(ElementType, 3975 T->getSizeModifier(), 3976 T->getIndexTypeCVRQualifiers(), 3977 TL.getBracketsRange()); 3978 if (Result.isNull()) 3979 return QualType(); 3980 } 3981 3982 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 3983 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3984 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3985 NewTL.setSizeExpr(nullptr); 3986 3987 return Result; 3988} 3989 3990template<typename Derived> 3991QualType 3992TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 3993 VariableArrayTypeLoc TL) { 3994 const VariableArrayType *T = TL.getTypePtr(); 3995 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3996 if (ElementType.isNull()) 3997 return QualType(); 3998 3999 ExprResult SizeResult 4000 = getDerived().TransformExpr(T->getSizeExpr()); 4001 if (SizeResult.isInvalid()) 4002 return QualType(); 4003 4004 Expr *Size = SizeResult.take(); 4005 4006 QualType Result = TL.getType(); 4007 if (getDerived().AlwaysRebuild() || 4008 ElementType != T->getElementType() || 4009 Size != T->getSizeExpr()) { 4010 Result = getDerived().RebuildVariableArrayType(ElementType, 4011 T->getSizeModifier(), 4012 Size, 4013 T->getIndexTypeCVRQualifiers(), 4014 TL.getBracketsRange()); 4015 if (Result.isNull()) 4016 return QualType(); 4017 } 4018 4019 // We might have constant size array now, but fortunately it has the same 4020 // location layout. 4021 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 4022 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4023 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4024 NewTL.setSizeExpr(Size); 4025 4026 return Result; 4027} 4028 4029template<typename Derived> 4030QualType 4031TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 4032 DependentSizedArrayTypeLoc TL) { 4033 const DependentSizedArrayType *T = TL.getTypePtr(); 4034 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 4035 if (ElementType.isNull()) 4036 return QualType(); 4037 4038 // Array bounds are constant expressions. 4039 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4040 Sema::ConstantEvaluated); 4041 4042 // Prefer the expression from the TypeLoc; the other may have been uniqued. 4043 Expr *origSize = TL.getSizeExpr(); 4044 if (!origSize) origSize = T->getSizeExpr(); 4045 4046 ExprResult sizeResult 4047 = getDerived().TransformExpr(origSize); 4048 sizeResult = SemaRef.ActOnConstantExpression(sizeResult); 4049 if (sizeResult.isInvalid()) 4050 return QualType(); 4051 4052 Expr *size = sizeResult.get(); 4053 4054 QualType Result = TL.getType(); 4055 if (getDerived().AlwaysRebuild() || 4056 ElementType != T->getElementType() || 4057 size != origSize) { 4058 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 4059 T->getSizeModifier(), 4060 size, 4061 T->getIndexTypeCVRQualifiers(), 4062 TL.getBracketsRange()); 4063 if (Result.isNull()) 4064 return QualType(); 4065 } 4066 4067 // We might have any sort of array type now, but fortunately they 4068 // all have the same location layout. 4069 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 4070 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4071 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4072 NewTL.setSizeExpr(size); 4073 4074 return Result; 4075} 4076 4077template<typename Derived> 4078QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 4079 TypeLocBuilder &TLB, 4080 DependentSizedExtVectorTypeLoc TL) { 4081 const DependentSizedExtVectorType *T = TL.getTypePtr(); 4082 4083 // FIXME: ext vector locs should be nested 4084 QualType ElementType = getDerived().TransformType(T->getElementType()); 4085 if (ElementType.isNull()) 4086 return QualType(); 4087 4088 // Vector sizes are constant expressions. 4089 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4090 Sema::ConstantEvaluated); 4091 4092 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 4093 Size = SemaRef.ActOnConstantExpression(Size); 4094 if (Size.isInvalid()) 4095 return QualType(); 4096 4097 QualType Result = TL.getType(); 4098 if (getDerived().AlwaysRebuild() || 4099 ElementType != T->getElementType() || 4100 Size.get() != T->getSizeExpr()) { 4101 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 4102 Size.take(), 4103 T->getAttributeLoc()); 4104 if (Result.isNull()) 4105 return QualType(); 4106 } 4107 4108 // Result might be dependent or not. 4109 if (isa<DependentSizedExtVectorType>(Result)) { 4110 DependentSizedExtVectorTypeLoc NewTL 4111 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 4112 NewTL.setNameLoc(TL.getNameLoc()); 4113 } else { 4114 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 4115 NewTL.setNameLoc(TL.getNameLoc()); 4116 } 4117 4118 return Result; 4119} 4120 4121template<typename Derived> 4122QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 4123 VectorTypeLoc TL) { 4124 const VectorType *T = TL.getTypePtr(); 4125 QualType ElementType = getDerived().TransformType(T->getElementType()); 4126 if (ElementType.isNull()) 4127 return QualType(); 4128 4129 QualType Result = TL.getType(); 4130 if (getDerived().AlwaysRebuild() || 4131 ElementType != T->getElementType()) { 4132 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 4133 T->getVectorKind()); 4134 if (Result.isNull()) 4135 return QualType(); 4136 } 4137 4138 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 4139 NewTL.setNameLoc(TL.getNameLoc()); 4140 4141 return Result; 4142} 4143 4144template<typename Derived> 4145QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 4146 ExtVectorTypeLoc TL) { 4147 const VectorType *T = TL.getTypePtr(); 4148 QualType ElementType = getDerived().TransformType(T->getElementType()); 4149 if (ElementType.isNull()) 4150 return QualType(); 4151 4152 QualType Result = TL.getType(); 4153 if (getDerived().AlwaysRebuild() || 4154 ElementType != T->getElementType()) { 4155 Result = getDerived().RebuildExtVectorType(ElementType, 4156 T->getNumElements(), 4157 /*FIXME*/ SourceLocation()); 4158 if (Result.isNull()) 4159 return QualType(); 4160 } 4161 4162 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 4163 NewTL.setNameLoc(TL.getNameLoc()); 4164 4165 return Result; 4166} 4167 4168template <typename Derived> 4169ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( 4170 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, 4171 bool ExpectParameterPack) { 4172 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 4173 TypeSourceInfo *NewDI = nullptr; 4174 4175 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { 4176 // If we're substituting into a pack expansion type and we know the 4177 // length we want to expand to, just substitute for the pattern. 4178 TypeLoc OldTL = OldDI->getTypeLoc(); 4179 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>(); 4180 4181 TypeLocBuilder TLB; 4182 TypeLoc NewTL = OldDI->getTypeLoc(); 4183 TLB.reserve(NewTL.getFullDataSize()); 4184 4185 QualType Result = getDerived().TransformType(TLB, 4186 OldExpansionTL.getPatternLoc()); 4187 if (Result.isNull()) 4188 return nullptr; 4189 4190 Result = RebuildPackExpansionType(Result, 4191 OldExpansionTL.getPatternLoc().getSourceRange(), 4192 OldExpansionTL.getEllipsisLoc(), 4193 NumExpansions); 4194 if (Result.isNull()) 4195 return nullptr; 4196 4197 PackExpansionTypeLoc NewExpansionTL 4198 = TLB.push<PackExpansionTypeLoc>(Result); 4199 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); 4200 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result); 4201 } else 4202 NewDI = getDerived().TransformType(OldDI); 4203 if (!NewDI) 4204 return nullptr; 4205 4206 if (NewDI == OldDI && indexAdjustment == 0) 4207 return OldParm; 4208 4209 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context, 4210 OldParm->getDeclContext(), 4211 OldParm->getInnerLocStart(), 4212 OldParm->getLocation(), 4213 OldParm->getIdentifier(), 4214 NewDI->getType(), 4215 NewDI, 4216 OldParm->getStorageClass(), 4217 /* DefArg */ nullptr); 4218 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 4219 OldParm->getFunctionScopeIndex() + indexAdjustment); 4220 return newParm; 4221} 4222 4223template<typename Derived> 4224bool TreeTransform<Derived>:: 4225 TransformFunctionTypeParams(SourceLocation Loc, 4226 ParmVarDecl **Params, unsigned NumParams, 4227 const QualType *ParamTypes, 4228 SmallVectorImpl<QualType> &OutParamTypes, 4229 SmallVectorImpl<ParmVarDecl*> *PVars) { 4230 int indexAdjustment = 0; 4231 4232 for (unsigned i = 0; i != NumParams; ++i) { 4233 if (ParmVarDecl *OldParm = Params[i]) { 4234 assert(OldParm->getFunctionScopeIndex() == i); 4235 4236 Optional<unsigned> NumExpansions; 4237 ParmVarDecl *NewParm = nullptr; 4238 if (OldParm->isParameterPack()) { 4239 // We have a function parameter pack that may need to be expanded. 4240 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4241 4242 // Find the parameter packs that could be expanded. 4243 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); 4244 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); 4245 TypeLoc Pattern = ExpansionTL.getPatternLoc(); 4246 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 4247 assert(Unexpanded.size() > 0 && "Could not find parameter packs!"); 4248 4249 // Determine whether we should expand the parameter packs. 4250 bool ShouldExpand = false; 4251 bool RetainExpansion = false; 4252 Optional<unsigned> OrigNumExpansions = 4253 ExpansionTL.getTypePtr()->getNumExpansions(); 4254 NumExpansions = OrigNumExpansions; 4255 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 4256 Pattern.getSourceRange(), 4257 Unexpanded, 4258 ShouldExpand, 4259 RetainExpansion, 4260 NumExpansions)) { 4261 return true; 4262 } 4263 4264 if (ShouldExpand) { 4265 // Expand the function parameter pack into multiple, separate 4266 // parameters. 4267 getDerived().ExpandingFunctionParameterPack(OldParm); 4268 for (unsigned I = 0; I != *NumExpansions; ++I) { 4269 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4270 ParmVarDecl *NewParm 4271 = getDerived().TransformFunctionTypeParam(OldParm, 4272 indexAdjustment++, 4273 OrigNumExpansions, 4274 /*ExpectParameterPack=*/false); 4275 if (!NewParm) 4276 return true; 4277 4278 OutParamTypes.push_back(NewParm->getType()); 4279 if (PVars) 4280 PVars->push_back(NewParm); 4281 } 4282 4283 // If we're supposed to retain a pack expansion, do so by temporarily 4284 // forgetting the partially-substituted parameter pack. 4285 if (RetainExpansion) { 4286 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4287 ParmVarDecl *NewParm 4288 = getDerived().TransformFunctionTypeParam(OldParm, 4289 indexAdjustment++, 4290 OrigNumExpansions, 4291 /*ExpectParameterPack=*/false); 4292 if (!NewParm) 4293 return true; 4294 4295 OutParamTypes.push_back(NewParm->getType()); 4296 if (PVars) 4297 PVars->push_back(NewParm); 4298 } 4299 4300 // The next parameter should have the same adjustment as the 4301 // last thing we pushed, but we post-incremented indexAdjustment 4302 // on every push. Also, if we push nothing, the adjustment should 4303 // go down by one. 4304 indexAdjustment--; 4305 4306 // We're done with the pack expansion. 4307 continue; 4308 } 4309 4310 // We'll substitute the parameter now without expanding the pack 4311 // expansion. 4312 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4313 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 4314 indexAdjustment, 4315 NumExpansions, 4316 /*ExpectParameterPack=*/true); 4317 } else { 4318 NewParm = getDerived().TransformFunctionTypeParam( 4319 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); 4320 } 4321 4322 if (!NewParm) 4323 return true; 4324 4325 OutParamTypes.push_back(NewParm->getType()); 4326 if (PVars) 4327 PVars->push_back(NewParm); 4328 continue; 4329 } 4330 4331 // Deal with the possibility that we don't have a parameter 4332 // declaration for this parameter. 4333 QualType OldType = ParamTypes[i]; 4334 bool IsPackExpansion = false; 4335 Optional<unsigned> NumExpansions; 4336 QualType NewType; 4337 if (const PackExpansionType *Expansion 4338 = dyn_cast<PackExpansionType>(OldType)) { 4339 // We have a function parameter pack that may need to be expanded. 4340 QualType Pattern = Expansion->getPattern(); 4341 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4342 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 4343 4344 // Determine whether we should expand the parameter packs. 4345 bool ShouldExpand = false; 4346 bool RetainExpansion = false; 4347 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(), 4348 Unexpanded, 4349 ShouldExpand, 4350 RetainExpansion, 4351 NumExpansions)) { 4352 return true; 4353 } 4354 4355 if (ShouldExpand) { 4356 // Expand the function parameter pack into multiple, separate 4357 // parameters. 4358 for (unsigned I = 0; I != *NumExpansions; ++I) { 4359 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4360 QualType NewType = getDerived().TransformType(Pattern); 4361 if (NewType.isNull()) 4362 return true; 4363 4364 OutParamTypes.push_back(NewType); 4365 if (PVars) 4366 PVars->push_back(nullptr); 4367 } 4368 4369 // We're done with the pack expansion. 4370 continue; 4371 } 4372 4373 // If we're supposed to retain a pack expansion, do so by temporarily 4374 // forgetting the partially-substituted parameter pack. 4375 if (RetainExpansion) { 4376 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4377 QualType NewType = getDerived().TransformType(Pattern); 4378 if (NewType.isNull()) 4379 return true; 4380 4381 OutParamTypes.push_back(NewType); 4382 if (PVars) 4383 PVars->push_back(nullptr); 4384 } 4385 4386 // We'll substitute the parameter now without expanding the pack 4387 // expansion. 4388 OldType = Expansion->getPattern(); 4389 IsPackExpansion = true; 4390 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4391 NewType = getDerived().TransformType(OldType); 4392 } else { 4393 NewType = getDerived().TransformType(OldType); 4394 } 4395 4396 if (NewType.isNull()) 4397 return true; 4398 4399 if (IsPackExpansion) 4400 NewType = getSema().Context.getPackExpansionType(NewType, 4401 NumExpansions); 4402 4403 OutParamTypes.push_back(NewType); 4404 if (PVars) 4405 PVars->push_back(nullptr); 4406 } 4407 4408#ifndef NDEBUG 4409 if (PVars) { 4410 for (unsigned i = 0, e = PVars->size(); i != e; ++i) 4411 if (ParmVarDecl *parm = (*PVars)[i]) 4412 assert(parm->getFunctionScopeIndex() == i); 4413 } 4414#endif 4415 4416 return false; 4417} 4418 4419template<typename Derived> 4420QualType 4421TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4422 FunctionProtoTypeLoc TL) { 4423 return getDerived().TransformFunctionProtoType(TLB, TL, nullptr, 0); 4424} 4425 4426template<typename Derived> 4427QualType 4428TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4429 FunctionProtoTypeLoc TL, 4430 CXXRecordDecl *ThisContext, 4431 unsigned ThisTypeQuals) { 4432 // Transform the parameters and return type. 4433 // 4434 // We are required to instantiate the params and return type in source order. 4435 // When the function has a trailing return type, we instantiate the 4436 // parameters before the return type, since the return type can then refer 4437 // to the parameters themselves (via decltype, sizeof, etc.). 4438 // 4439 SmallVector<QualType, 4> ParamTypes; 4440 SmallVector<ParmVarDecl*, 4> ParamDecls; 4441 const FunctionProtoType *T = TL.getTypePtr(); 4442 4443 QualType ResultType; 4444 4445 if (T->hasTrailingReturn()) { 4446 if (getDerived().TransformFunctionTypeParams( 4447 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), 4448 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) 4449 return QualType(); 4450 4451 { 4452 // C++11 [expr.prim.general]p3: 4453 // If a declaration declares a member function or member function 4454 // template of a class X, the expression this is a prvalue of type 4455 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 4456 // and the end of the function-definition, member-declarator, or 4457 // declarator. 4458 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals); 4459 4460 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4461 if (ResultType.isNull()) 4462 return QualType(); 4463 } 4464 } 4465 else { 4466 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4467 if (ResultType.isNull()) 4468 return QualType(); 4469 4470 if (getDerived().TransformFunctionTypeParams( 4471 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), 4472 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) 4473 return QualType(); 4474 } 4475 4476 // FIXME: Need to transform the exception-specification too. 4477 4478 QualType Result = TL.getType(); 4479 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || 4480 T->getNumParams() != ParamTypes.size() || 4481 !std::equal(T->param_type_begin(), T->param_type_end(), 4482 ParamTypes.begin())) { 4483 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, 4484 T->getExtProtoInfo()); 4485 if (Result.isNull()) 4486 return QualType(); 4487 } 4488 4489 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 4490 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4491 NewTL.setLParenLoc(TL.getLParenLoc()); 4492 NewTL.setRParenLoc(TL.getRParenLoc()); 4493 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4494 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i) 4495 NewTL.setParam(i, ParamDecls[i]); 4496 4497 return Result; 4498} 4499 4500template<typename Derived> 4501QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 4502 TypeLocBuilder &TLB, 4503 FunctionNoProtoTypeLoc TL) { 4504 const FunctionNoProtoType *T = TL.getTypePtr(); 4505 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4506 if (ResultType.isNull()) 4507 return QualType(); 4508 4509 QualType Result = TL.getType(); 4510 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType()) 4511 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 4512 4513 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 4514 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4515 NewTL.setLParenLoc(TL.getLParenLoc()); 4516 NewTL.setRParenLoc(TL.getRParenLoc()); 4517 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4518 4519 return Result; 4520} 4521 4522template<typename Derived> QualType 4523TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 4524 UnresolvedUsingTypeLoc TL) { 4525 const UnresolvedUsingType *T = TL.getTypePtr(); 4526 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 4527 if (!D) 4528 return QualType(); 4529 4530 QualType Result = TL.getType(); 4531 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 4532 Result = getDerived().RebuildUnresolvedUsingType(D); 4533 if (Result.isNull()) 4534 return QualType(); 4535 } 4536 4537 // We might get an arbitrary type spec type back. We should at 4538 // least always get a type spec type, though. 4539 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 4540 NewTL.setNameLoc(TL.getNameLoc()); 4541 4542 return Result; 4543} 4544 4545template<typename Derived> 4546QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 4547 TypedefTypeLoc TL) { 4548 const TypedefType *T = TL.getTypePtr(); 4549 TypedefNameDecl *Typedef 4550 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4551 T->getDecl())); 4552 if (!Typedef) 4553 return QualType(); 4554 4555 QualType Result = TL.getType(); 4556 if (getDerived().AlwaysRebuild() || 4557 Typedef != T->getDecl()) { 4558 Result = getDerived().RebuildTypedefType(Typedef); 4559 if (Result.isNull()) 4560 return QualType(); 4561 } 4562 4563 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 4564 NewTL.setNameLoc(TL.getNameLoc()); 4565 4566 return Result; 4567} 4568 4569template<typename Derived> 4570QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 4571 TypeOfExprTypeLoc TL) { 4572 // typeof expressions are not potentially evaluated contexts 4573 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4574 Sema::ReuseLambdaContextDecl); 4575 4576 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 4577 if (E.isInvalid()) 4578 return QualType(); 4579 4580 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get()); 4581 if (E.isInvalid()) 4582 return QualType(); 4583 4584 QualType Result = TL.getType(); 4585 if (getDerived().AlwaysRebuild() || 4586 E.get() != TL.getUnderlyingExpr()) { 4587 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 4588 if (Result.isNull()) 4589 return QualType(); 4590 } 4591 else E.take(); 4592 4593 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 4594 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4595 NewTL.setLParenLoc(TL.getLParenLoc()); 4596 NewTL.setRParenLoc(TL.getRParenLoc()); 4597 4598 return Result; 4599} 4600 4601template<typename Derived> 4602QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 4603 TypeOfTypeLoc TL) { 4604 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 4605 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 4606 if (!New_Under_TI) 4607 return QualType(); 4608 4609 QualType Result = TL.getType(); 4610 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 4611 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 4612 if (Result.isNull()) 4613 return QualType(); 4614 } 4615 4616 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 4617 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4618 NewTL.setLParenLoc(TL.getLParenLoc()); 4619 NewTL.setRParenLoc(TL.getRParenLoc()); 4620 NewTL.setUnderlyingTInfo(New_Under_TI); 4621 4622 return Result; 4623} 4624 4625template<typename Derived> 4626QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 4627 DecltypeTypeLoc TL) { 4628 const DecltypeType *T = TL.getTypePtr(); 4629 4630 // decltype expressions are not potentially evaluated contexts 4631 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4632 nullptr, /*IsDecltype=*/ true); 4633 4634 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 4635 if (E.isInvalid()) 4636 return QualType(); 4637 4638 E = getSema().ActOnDecltypeExpression(E.take()); 4639 if (E.isInvalid()) 4640 return QualType(); 4641 4642 QualType Result = TL.getType(); 4643 if (getDerived().AlwaysRebuild() || 4644 E.get() != T->getUnderlyingExpr()) { 4645 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 4646 if (Result.isNull()) 4647 return QualType(); 4648 } 4649 else E.take(); 4650 4651 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 4652 NewTL.setNameLoc(TL.getNameLoc()); 4653 4654 return Result; 4655} 4656 4657template<typename Derived> 4658QualType TreeTransform<Derived>::TransformUnaryTransformType( 4659 TypeLocBuilder &TLB, 4660 UnaryTransformTypeLoc TL) { 4661 QualType Result = TL.getType(); 4662 if (Result->isDependentType()) { 4663 const UnaryTransformType *T = TL.getTypePtr(); 4664 QualType NewBase = 4665 getDerived().TransformType(TL.getUnderlyingTInfo())->getType(); 4666 Result = getDerived().RebuildUnaryTransformType(NewBase, 4667 T->getUTTKind(), 4668 TL.getKWLoc()); 4669 if (Result.isNull()) 4670 return QualType(); 4671 } 4672 4673 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result); 4674 NewTL.setKWLoc(TL.getKWLoc()); 4675 NewTL.setParensRange(TL.getParensRange()); 4676 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo()); 4677 return Result; 4678} 4679 4680template<typename Derived> 4681QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, 4682 AutoTypeLoc TL) { 4683 const AutoType *T = TL.getTypePtr(); 4684 QualType OldDeduced = T->getDeducedType(); 4685 QualType NewDeduced; 4686 if (!OldDeduced.isNull()) { 4687 NewDeduced = getDerived().TransformType(OldDeduced); 4688 if (NewDeduced.isNull()) 4689 return QualType(); 4690 } 4691 4692 QualType Result = TL.getType(); 4693 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced || 4694 T->isDependentType()) { 4695 Result = getDerived().RebuildAutoType(NewDeduced, T->isDecltypeAuto()); 4696 if (Result.isNull()) 4697 return QualType(); 4698 } 4699 4700 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 4701 NewTL.setNameLoc(TL.getNameLoc()); 4702 4703 return Result; 4704} 4705 4706template<typename Derived> 4707QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 4708 RecordTypeLoc TL) { 4709 const RecordType *T = TL.getTypePtr(); 4710 RecordDecl *Record 4711 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4712 T->getDecl())); 4713 if (!Record) 4714 return QualType(); 4715 4716 QualType Result = TL.getType(); 4717 if (getDerived().AlwaysRebuild() || 4718 Record != T->getDecl()) { 4719 Result = getDerived().RebuildRecordType(Record); 4720 if (Result.isNull()) 4721 return QualType(); 4722 } 4723 4724 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 4725 NewTL.setNameLoc(TL.getNameLoc()); 4726 4727 return Result; 4728} 4729 4730template<typename Derived> 4731QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 4732 EnumTypeLoc TL) { 4733 const EnumType *T = TL.getTypePtr(); 4734 EnumDecl *Enum 4735 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4736 T->getDecl())); 4737 if (!Enum) 4738 return QualType(); 4739 4740 QualType Result = TL.getType(); 4741 if (getDerived().AlwaysRebuild() || 4742 Enum != T->getDecl()) { 4743 Result = getDerived().RebuildEnumType(Enum); 4744 if (Result.isNull()) 4745 return QualType(); 4746 } 4747 4748 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 4749 NewTL.setNameLoc(TL.getNameLoc()); 4750 4751 return Result; 4752} 4753 4754template<typename Derived> 4755QualType TreeTransform<Derived>::TransformInjectedClassNameType( 4756 TypeLocBuilder &TLB, 4757 InjectedClassNameTypeLoc TL) { 4758 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 4759 TL.getTypePtr()->getDecl()); 4760 if (!D) return QualType(); 4761 4762 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 4763 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 4764 return T; 4765} 4766 4767template<typename Derived> 4768QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 4769 TypeLocBuilder &TLB, 4770 TemplateTypeParmTypeLoc TL) { 4771 return TransformTypeSpecType(TLB, TL); 4772} 4773 4774template<typename Derived> 4775QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 4776 TypeLocBuilder &TLB, 4777 SubstTemplateTypeParmTypeLoc TL) { 4778 const SubstTemplateTypeParmType *T = TL.getTypePtr(); 4779 4780 // Substitute into the replacement type, which itself might involve something 4781 // that needs to be transformed. This only tends to occur with default 4782 // template arguments of template template parameters. 4783 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName()); 4784 QualType Replacement = getDerived().TransformType(T->getReplacementType()); 4785 if (Replacement.isNull()) 4786 return QualType(); 4787 4788 // Always canonicalize the replacement type. 4789 Replacement = SemaRef.Context.getCanonicalType(Replacement); 4790 QualType Result 4791 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), 4792 Replacement); 4793 4794 // Propagate type-source information. 4795 SubstTemplateTypeParmTypeLoc NewTL 4796 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 4797 NewTL.setNameLoc(TL.getNameLoc()); 4798 return Result; 4799 4800} 4801 4802template<typename Derived> 4803QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( 4804 TypeLocBuilder &TLB, 4805 SubstTemplateTypeParmPackTypeLoc TL) { 4806 return TransformTypeSpecType(TLB, TL); 4807} 4808 4809template<typename Derived> 4810QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4811 TypeLocBuilder &TLB, 4812 TemplateSpecializationTypeLoc TL) { 4813 const TemplateSpecializationType *T = TL.getTypePtr(); 4814 4815 // The nested-name-specifier never matters in a TemplateSpecializationType, 4816 // because we can't have a dependent nested-name-specifier anyway. 4817 CXXScopeSpec SS; 4818 TemplateName Template 4819 = getDerived().TransformTemplateName(SS, T->getTemplateName(), 4820 TL.getTemplateNameLoc()); 4821 if (Template.isNull()) 4822 return QualType(); 4823 4824 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 4825} 4826 4827template<typename Derived> 4828QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB, 4829 AtomicTypeLoc TL) { 4830 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); 4831 if (ValueType.isNull()) 4832 return QualType(); 4833 4834 QualType Result = TL.getType(); 4835 if (getDerived().AlwaysRebuild() || 4836 ValueType != TL.getValueLoc().getType()) { 4837 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc()); 4838 if (Result.isNull()) 4839 return QualType(); 4840 } 4841 4842 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result); 4843 NewTL.setKWLoc(TL.getKWLoc()); 4844 NewTL.setLParenLoc(TL.getLParenLoc()); 4845 NewTL.setRParenLoc(TL.getRParenLoc()); 4846 4847 return Result; 4848} 4849 4850 /// \brief Simple iterator that traverses the template arguments in a 4851 /// container that provides a \c getArgLoc() member function. 4852 /// 4853 /// This iterator is intended to be used with the iterator form of 4854 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 4855 template<typename ArgLocContainer> 4856 class TemplateArgumentLocContainerIterator { 4857 ArgLocContainer *Container; 4858 unsigned Index; 4859 4860 public: 4861 typedef TemplateArgumentLoc value_type; 4862 typedef TemplateArgumentLoc reference; 4863 typedef int difference_type; 4864 typedef std::input_iterator_tag iterator_category; 4865 4866 class pointer { 4867 TemplateArgumentLoc Arg; 4868 4869 public: 4870 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 4871 4872 const TemplateArgumentLoc *operator->() const { 4873 return &Arg; 4874 } 4875 }; 4876 4877 4878 TemplateArgumentLocContainerIterator() {} 4879 4880 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 4881 unsigned Index) 4882 : Container(&Container), Index(Index) { } 4883 4884 TemplateArgumentLocContainerIterator &operator++() { 4885 ++Index; 4886 return *this; 4887 } 4888 4889 TemplateArgumentLocContainerIterator operator++(int) { 4890 TemplateArgumentLocContainerIterator Old(*this); 4891 ++(*this); 4892 return Old; 4893 } 4894 4895 TemplateArgumentLoc operator*() const { 4896 return Container->getArgLoc(Index); 4897 } 4898 4899 pointer operator->() const { 4900 return pointer(Container->getArgLoc(Index)); 4901 } 4902 4903 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 4904 const TemplateArgumentLocContainerIterator &Y) { 4905 return X.Container == Y.Container && X.Index == Y.Index; 4906 } 4907 4908 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 4909 const TemplateArgumentLocContainerIterator &Y) { 4910 return !(X == Y); 4911 } 4912 }; 4913 4914 4915template <typename Derived> 4916QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4917 TypeLocBuilder &TLB, 4918 TemplateSpecializationTypeLoc TL, 4919 TemplateName Template) { 4920 TemplateArgumentListInfo NewTemplateArgs; 4921 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4922 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4923 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 4924 ArgIterator; 4925 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4926 ArgIterator(TL, TL.getNumArgs()), 4927 NewTemplateArgs)) 4928 return QualType(); 4929 4930 // FIXME: maybe don't rebuild if all the template arguments are the same. 4931 4932 QualType Result = 4933 getDerived().RebuildTemplateSpecializationType(Template, 4934 TL.getTemplateNameLoc(), 4935 NewTemplateArgs); 4936 4937 if (!Result.isNull()) { 4938 // Specializations of template template parameters are represented as 4939 // TemplateSpecializationTypes, and substitution of type alias templates 4940 // within a dependent context can transform them into 4941 // DependentTemplateSpecializationTypes. 4942 if (isa<DependentTemplateSpecializationType>(Result)) { 4943 DependentTemplateSpecializationTypeLoc NewTL 4944 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4945 NewTL.setElaboratedKeywordLoc(SourceLocation()); 4946 NewTL.setQualifierLoc(NestedNameSpecifierLoc()); 4947 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4948 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4949 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4950 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4951 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4952 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4953 return Result; 4954 } 4955 4956 TemplateSpecializationTypeLoc NewTL 4957 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4958 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4959 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4960 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4961 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4962 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4963 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4964 } 4965 4966 return Result; 4967} 4968 4969template <typename Derived> 4970QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( 4971 TypeLocBuilder &TLB, 4972 DependentTemplateSpecializationTypeLoc TL, 4973 TemplateName Template, 4974 CXXScopeSpec &SS) { 4975 TemplateArgumentListInfo NewTemplateArgs; 4976 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4977 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4978 typedef TemplateArgumentLocContainerIterator< 4979 DependentTemplateSpecializationTypeLoc> ArgIterator; 4980 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4981 ArgIterator(TL, TL.getNumArgs()), 4982 NewTemplateArgs)) 4983 return QualType(); 4984 4985 // FIXME: maybe don't rebuild if all the template arguments are the same. 4986 4987 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 4988 QualType Result 4989 = getSema().Context.getDependentTemplateSpecializationType( 4990 TL.getTypePtr()->getKeyword(), 4991 DTN->getQualifier(), 4992 DTN->getIdentifier(), 4993 NewTemplateArgs); 4994 4995 DependentTemplateSpecializationTypeLoc NewTL 4996 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4997 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4998 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context)); 4999 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5000 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5001 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5002 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5003 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5004 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5005 return Result; 5006 } 5007 5008 QualType Result 5009 = getDerived().RebuildTemplateSpecializationType(Template, 5010 TL.getTemplateNameLoc(), 5011 NewTemplateArgs); 5012 5013 if (!Result.isNull()) { 5014 /// FIXME: Wrap this in an elaborated-type-specifier? 5015 TemplateSpecializationTypeLoc NewTL 5016 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5017 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5018 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5019 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5020 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5021 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5022 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5023 } 5024 5025 return Result; 5026} 5027 5028template<typename Derived> 5029QualType 5030TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 5031 ElaboratedTypeLoc TL) { 5032 const ElaboratedType *T = TL.getTypePtr(); 5033 5034 NestedNameSpecifierLoc QualifierLoc; 5035 // NOTE: the qualifier in an ElaboratedType is optional. 5036 if (TL.getQualifierLoc()) { 5037 QualifierLoc 5038 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5039 if (!QualifierLoc) 5040 return QualType(); 5041 } 5042 5043 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 5044 if (NamedT.isNull()) 5045 return QualType(); 5046 5047 // C++0x [dcl.type.elab]p2: 5048 // If the identifier resolves to a typedef-name or the simple-template-id 5049 // resolves to an alias template specialization, the 5050 // elaborated-type-specifier is ill-formed. 5051 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) { 5052 if (const TemplateSpecializationType *TST = 5053 NamedT->getAs<TemplateSpecializationType>()) { 5054 TemplateName Template = TST->getTemplateName(); 5055 if (TypeAliasTemplateDecl *TAT = 5056 dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) { 5057 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(), 5058 diag::err_tag_reference_non_tag) << 4; 5059 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at); 5060 } 5061 } 5062 } 5063 5064 QualType Result = TL.getType(); 5065 if (getDerived().AlwaysRebuild() || 5066 QualifierLoc != TL.getQualifierLoc() || 5067 NamedT != T->getNamedType()) { 5068 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(), 5069 T->getKeyword(), 5070 QualifierLoc, NamedT); 5071 if (Result.isNull()) 5072 return QualType(); 5073 } 5074 5075 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5076 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5077 NewTL.setQualifierLoc(QualifierLoc); 5078 return Result; 5079} 5080 5081template<typename Derived> 5082QualType TreeTransform<Derived>::TransformAttributedType( 5083 TypeLocBuilder &TLB, 5084 AttributedTypeLoc TL) { 5085 const AttributedType *oldType = TL.getTypePtr(); 5086 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); 5087 if (modifiedType.isNull()) 5088 return QualType(); 5089 5090 QualType result = TL.getType(); 5091 5092 // FIXME: dependent operand expressions? 5093 if (getDerived().AlwaysRebuild() || 5094 modifiedType != oldType->getModifiedType()) { 5095 // TODO: this is really lame; we should really be rebuilding the 5096 // equivalent type from first principles. 5097 QualType equivalentType 5098 = getDerived().TransformType(oldType->getEquivalentType()); 5099 if (equivalentType.isNull()) 5100 return QualType(); 5101 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), 5102 modifiedType, 5103 equivalentType); 5104 } 5105 5106 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); 5107 newTL.setAttrNameLoc(TL.getAttrNameLoc()); 5108 if (TL.hasAttrOperand()) 5109 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); 5110 if (TL.hasAttrExprOperand()) 5111 newTL.setAttrExprOperand(TL.getAttrExprOperand()); 5112 else if (TL.hasAttrEnumOperand()) 5113 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc()); 5114 5115 return result; 5116} 5117 5118template<typename Derived> 5119QualType 5120TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 5121 ParenTypeLoc TL) { 5122 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 5123 if (Inner.isNull()) 5124 return QualType(); 5125 5126 QualType Result = TL.getType(); 5127 if (getDerived().AlwaysRebuild() || 5128 Inner != TL.getInnerLoc().getType()) { 5129 Result = getDerived().RebuildParenType(Inner); 5130 if (Result.isNull()) 5131 return QualType(); 5132 } 5133 5134 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 5135 NewTL.setLParenLoc(TL.getLParenLoc()); 5136 NewTL.setRParenLoc(TL.getRParenLoc()); 5137 return Result; 5138} 5139 5140template<typename Derived> 5141QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 5142 DependentNameTypeLoc TL) { 5143 const DependentNameType *T = TL.getTypePtr(); 5144 5145 NestedNameSpecifierLoc QualifierLoc 5146 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5147 if (!QualifierLoc) 5148 return QualType(); 5149 5150 QualType Result 5151 = getDerived().RebuildDependentNameType(T->getKeyword(), 5152 TL.getElaboratedKeywordLoc(), 5153 QualifierLoc, 5154 T->getIdentifier(), 5155 TL.getNameLoc()); 5156 if (Result.isNull()) 5157 return QualType(); 5158 5159 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 5160 QualType NamedT = ElabT->getNamedType(); 5161 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 5162 5163 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5164 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5165 NewTL.setQualifierLoc(QualifierLoc); 5166 } else { 5167 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 5168 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5169 NewTL.setQualifierLoc(QualifierLoc); 5170 NewTL.setNameLoc(TL.getNameLoc()); 5171 } 5172 return Result; 5173} 5174 5175template<typename Derived> 5176QualType TreeTransform<Derived>:: 5177 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5178 DependentTemplateSpecializationTypeLoc TL) { 5179 NestedNameSpecifierLoc QualifierLoc; 5180 if (TL.getQualifierLoc()) { 5181 QualifierLoc 5182 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5183 if (!QualifierLoc) 5184 return QualType(); 5185 } 5186 5187 return getDerived() 5188 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc); 5189} 5190 5191template<typename Derived> 5192QualType TreeTransform<Derived>:: 5193TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5194 DependentTemplateSpecializationTypeLoc TL, 5195 NestedNameSpecifierLoc QualifierLoc) { 5196 const DependentTemplateSpecializationType *T = TL.getTypePtr(); 5197 5198 TemplateArgumentListInfo NewTemplateArgs; 5199 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 5200 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 5201 5202 typedef TemplateArgumentLocContainerIterator< 5203 DependentTemplateSpecializationTypeLoc> ArgIterator; 5204 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 5205 ArgIterator(TL, TL.getNumArgs()), 5206 NewTemplateArgs)) 5207 return QualType(); 5208 5209 QualType Result 5210 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 5211 QualifierLoc, 5212 T->getIdentifier(), 5213 TL.getTemplateNameLoc(), 5214 NewTemplateArgs); 5215 if (Result.isNull()) 5216 return QualType(); 5217 5218 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 5219 QualType NamedT = ElabT->getNamedType(); 5220 5221 // Copy information relevant to the template specialization. 5222 TemplateSpecializationTypeLoc NamedTL 5223 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 5224 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5225 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5226 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 5227 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 5228 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5229 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5230 5231 // Copy information relevant to the elaborated type. 5232 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5233 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5234 NewTL.setQualifierLoc(QualifierLoc); 5235 } else if (isa<DependentTemplateSpecializationType>(Result)) { 5236 DependentTemplateSpecializationTypeLoc SpecTL 5237 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5238 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5239 SpecTL.setQualifierLoc(QualifierLoc); 5240 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5241 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5242 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5243 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5244 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5245 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5246 } else { 5247 TemplateSpecializationTypeLoc SpecTL 5248 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5249 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5250 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5251 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5252 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5253 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5254 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5255 } 5256 return Result; 5257} 5258 5259template<typename Derived> 5260QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 5261 PackExpansionTypeLoc TL) { 5262 QualType Pattern 5263 = getDerived().TransformType(TLB, TL.getPatternLoc()); 5264 if (Pattern.isNull()) 5265 return QualType(); 5266 5267 QualType Result = TL.getType(); 5268 if (getDerived().AlwaysRebuild() || 5269 Pattern != TL.getPatternLoc().getType()) { 5270 Result = getDerived().RebuildPackExpansionType(Pattern, 5271 TL.getPatternLoc().getSourceRange(), 5272 TL.getEllipsisLoc(), 5273 TL.getTypePtr()->getNumExpansions()); 5274 if (Result.isNull()) 5275 return QualType(); 5276 } 5277 5278 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); 5279 NewT.setEllipsisLoc(TL.getEllipsisLoc()); 5280 return Result; 5281} 5282 5283template<typename Derived> 5284QualType 5285TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 5286 ObjCInterfaceTypeLoc TL) { 5287 // ObjCInterfaceType is never dependent. 5288 TLB.pushFullCopy(TL); 5289 return TL.getType(); 5290} 5291 5292template<typename Derived> 5293QualType 5294TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 5295 ObjCObjectTypeLoc TL) { 5296 // ObjCObjectType is never dependent. 5297 TLB.pushFullCopy(TL); 5298 return TL.getType(); 5299} 5300 5301template<typename Derived> 5302QualType 5303TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 5304 ObjCObjectPointerTypeLoc TL) { 5305 // ObjCObjectPointerType is never dependent. 5306 TLB.pushFullCopy(TL); 5307 return TL.getType(); 5308} 5309 5310//===----------------------------------------------------------------------===// 5311// Statement transformation 5312//===----------------------------------------------------------------------===// 5313template<typename Derived> 5314StmtResult 5315TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 5316 return SemaRef.Owned(S); 5317} 5318 5319template<typename Derived> 5320StmtResult 5321TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 5322 return getDerived().TransformCompoundStmt(S, false); 5323} 5324 5325template<typename Derived> 5326StmtResult 5327TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 5328 bool IsStmtExpr) { 5329 Sema::CompoundScopeRAII CompoundScope(getSema()); 5330 5331 bool SubStmtInvalid = false; 5332 bool SubStmtChanged = false; 5333 SmallVector<Stmt*, 8> Statements; 5334 for (auto *B : S->body()) { 5335 StmtResult Result = getDerived().TransformStmt(B); 5336 if (Result.isInvalid()) { 5337 // Immediately fail if this was a DeclStmt, since it's very 5338 // likely that this will cause problems for future statements. 5339 if (isa<DeclStmt>(B)) 5340 return StmtError(); 5341 5342 // Otherwise, just keep processing substatements and fail later. 5343 SubStmtInvalid = true; 5344 continue; 5345 } 5346 5347 SubStmtChanged = SubStmtChanged || Result.get() != B; 5348 Statements.push_back(Result.takeAs<Stmt>()); 5349 } 5350 5351 if (SubStmtInvalid) 5352 return StmtError(); 5353 5354 if (!getDerived().AlwaysRebuild() && 5355 !SubStmtChanged) 5356 return SemaRef.Owned(S); 5357 5358 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 5359 Statements, 5360 S->getRBracLoc(), 5361 IsStmtExpr); 5362} 5363 5364template<typename Derived> 5365StmtResult 5366TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 5367 ExprResult LHS, RHS; 5368 { 5369 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5370 Sema::ConstantEvaluated); 5371 5372 // Transform the left-hand case value. 5373 LHS = getDerived().TransformExpr(S->getLHS()); 5374 LHS = SemaRef.ActOnConstantExpression(LHS); 5375 if (LHS.isInvalid()) 5376 return StmtError(); 5377 5378 // Transform the right-hand case value (for the GNU case-range extension). 5379 RHS = getDerived().TransformExpr(S->getRHS()); 5380 RHS = SemaRef.ActOnConstantExpression(RHS); 5381 if (RHS.isInvalid()) 5382 return StmtError(); 5383 } 5384 5385 // Build the case statement. 5386 // Case statements are always rebuilt so that they will attached to their 5387 // transformed switch statement. 5388 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 5389 LHS.get(), 5390 S->getEllipsisLoc(), 5391 RHS.get(), 5392 S->getColonLoc()); 5393 if (Case.isInvalid()) 5394 return StmtError(); 5395 5396 // Transform the statement following the case 5397 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5398 if (SubStmt.isInvalid()) 5399 return StmtError(); 5400 5401 // Attach the body to the case statement 5402 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 5403} 5404 5405template<typename Derived> 5406StmtResult 5407TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 5408 // Transform the statement following the default case 5409 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5410 if (SubStmt.isInvalid()) 5411 return StmtError(); 5412 5413 // Default statements are always rebuilt 5414 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 5415 SubStmt.get()); 5416} 5417 5418template<typename Derived> 5419StmtResult 5420TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 5421 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5422 if (SubStmt.isInvalid()) 5423 return StmtError(); 5424 5425 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), 5426 S->getDecl()); 5427 if (!LD) 5428 return StmtError(); 5429 5430 5431 // FIXME: Pass the real colon location in. 5432 return getDerived().RebuildLabelStmt(S->getIdentLoc(), 5433 cast<LabelDecl>(LD), SourceLocation(), 5434 SubStmt.get()); 5435} 5436 5437template<typename Derived> 5438StmtResult 5439TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) { 5440 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5441 if (SubStmt.isInvalid()) 5442 return StmtError(); 5443 5444 // TODO: transform attributes 5445 if (SubStmt.get() == S->getSubStmt() /* && attrs are the same */) 5446 return S; 5447 5448 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), 5449 S->getAttrs(), 5450 SubStmt.get()); 5451} 5452 5453template<typename Derived> 5454StmtResult 5455TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 5456 // Transform the condition 5457 ExprResult Cond; 5458 VarDecl *ConditionVar = nullptr; 5459 if (S->getConditionVariable()) { 5460 ConditionVar 5461 = cast_or_null<VarDecl>( 5462 getDerived().TransformDefinition( 5463 S->getConditionVariable()->getLocation(), 5464 S->getConditionVariable())); 5465 if (!ConditionVar) 5466 return StmtError(); 5467 } else { 5468 Cond = getDerived().TransformExpr(S->getCond()); 5469 5470 if (Cond.isInvalid()) 5471 return StmtError(); 5472 5473 // Convert the condition to a boolean value. 5474 if (S->getCond()) { 5475 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, S->getIfLoc(), 5476 Cond.get()); 5477 if (CondE.isInvalid()) 5478 return StmtError(); 5479 5480 Cond = CondE.get(); 5481 } 5482 } 5483 5484 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5485 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5486 return StmtError(); 5487 5488 // Transform the "then" branch. 5489 StmtResult Then = getDerived().TransformStmt(S->getThen()); 5490 if (Then.isInvalid()) 5491 return StmtError(); 5492 5493 // Transform the "else" branch. 5494 StmtResult Else = getDerived().TransformStmt(S->getElse()); 5495 if (Else.isInvalid()) 5496 return StmtError(); 5497 5498 if (!getDerived().AlwaysRebuild() && 5499 FullCond.get() == S->getCond() && 5500 ConditionVar == S->getConditionVariable() && 5501 Then.get() == S->getThen() && 5502 Else.get() == S->getElse()) 5503 return SemaRef.Owned(S); 5504 5505 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 5506 Then.get(), 5507 S->getElseLoc(), Else.get()); 5508} 5509 5510template<typename Derived> 5511StmtResult 5512TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 5513 // Transform the condition. 5514 ExprResult Cond; 5515 VarDecl *ConditionVar = nullptr; 5516 if (S->getConditionVariable()) { 5517 ConditionVar 5518 = cast_or_null<VarDecl>( 5519 getDerived().TransformDefinition( 5520 S->getConditionVariable()->getLocation(), 5521 S->getConditionVariable())); 5522 if (!ConditionVar) 5523 return StmtError(); 5524 } else { 5525 Cond = getDerived().TransformExpr(S->getCond()); 5526 5527 if (Cond.isInvalid()) 5528 return StmtError(); 5529 } 5530 5531 // Rebuild the switch statement. 5532 StmtResult Switch 5533 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 5534 ConditionVar); 5535 if (Switch.isInvalid()) 5536 return StmtError(); 5537 5538 // Transform the body of the switch statement. 5539 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5540 if (Body.isInvalid()) 5541 return StmtError(); 5542 5543 // Complete the switch statement. 5544 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 5545 Body.get()); 5546} 5547 5548template<typename Derived> 5549StmtResult 5550TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 5551 // Transform the condition 5552 ExprResult Cond; 5553 VarDecl *ConditionVar = nullptr; 5554 if (S->getConditionVariable()) { 5555 ConditionVar 5556 = cast_or_null<VarDecl>( 5557 getDerived().TransformDefinition( 5558 S->getConditionVariable()->getLocation(), 5559 S->getConditionVariable())); 5560 if (!ConditionVar) 5561 return StmtError(); 5562 } else { 5563 Cond = getDerived().TransformExpr(S->getCond()); 5564 5565 if (Cond.isInvalid()) 5566 return StmtError(); 5567 5568 if (S->getCond()) { 5569 // Convert the condition to a boolean value. 5570 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, 5571 S->getWhileLoc(), 5572 Cond.get()); 5573 if (CondE.isInvalid()) 5574 return StmtError(); 5575 Cond = CondE; 5576 } 5577 } 5578 5579 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5580 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5581 return StmtError(); 5582 5583 // Transform the body 5584 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5585 if (Body.isInvalid()) 5586 return StmtError(); 5587 5588 if (!getDerived().AlwaysRebuild() && 5589 FullCond.get() == S->getCond() && 5590 ConditionVar == S->getConditionVariable() && 5591 Body.get() == S->getBody()) 5592 return Owned(S); 5593 5594 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 5595 ConditionVar, Body.get()); 5596} 5597 5598template<typename Derived> 5599StmtResult 5600TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 5601 // Transform the body 5602 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5603 if (Body.isInvalid()) 5604 return StmtError(); 5605 5606 // Transform the condition 5607 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5608 if (Cond.isInvalid()) 5609 return StmtError(); 5610 5611 if (!getDerived().AlwaysRebuild() && 5612 Cond.get() == S->getCond() && 5613 Body.get() == S->getBody()) 5614 return SemaRef.Owned(S); 5615 5616 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 5617 /*FIXME:*/S->getWhileLoc(), Cond.get(), 5618 S->getRParenLoc()); 5619} 5620 5621template<typename Derived> 5622StmtResult 5623TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 5624 // Transform the initialization statement 5625 StmtResult Init = getDerived().TransformStmt(S->getInit()); 5626 if (Init.isInvalid()) 5627 return StmtError(); 5628 5629 // Transform the condition 5630 ExprResult Cond; 5631 VarDecl *ConditionVar = nullptr; 5632 if (S->getConditionVariable()) { 5633 ConditionVar 5634 = cast_or_null<VarDecl>( 5635 getDerived().TransformDefinition( 5636 S->getConditionVariable()->getLocation(), 5637 S->getConditionVariable())); 5638 if (!ConditionVar) 5639 return StmtError(); 5640 } else { 5641 Cond = getDerived().TransformExpr(S->getCond()); 5642 5643 if (Cond.isInvalid()) 5644 return StmtError(); 5645 5646 if (S->getCond()) { 5647 // Convert the condition to a boolean value. 5648 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, 5649 S->getForLoc(), 5650 Cond.get()); 5651 if (CondE.isInvalid()) 5652 return StmtError(); 5653 5654 Cond = CondE.get(); 5655 } 5656 } 5657 5658 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5659 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5660 return StmtError(); 5661 5662 // Transform the increment 5663 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5664 if (Inc.isInvalid()) 5665 return StmtError(); 5666 5667 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get())); 5668 if (S->getInc() && !FullInc.get()) 5669 return StmtError(); 5670 5671 // Transform the body 5672 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5673 if (Body.isInvalid()) 5674 return StmtError(); 5675 5676 if (!getDerived().AlwaysRebuild() && 5677 Init.get() == S->getInit() && 5678 FullCond.get() == S->getCond() && 5679 Inc.get() == S->getInc() && 5680 Body.get() == S->getBody()) 5681 return SemaRef.Owned(S); 5682 5683 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 5684 Init.get(), FullCond, ConditionVar, 5685 FullInc, S->getRParenLoc(), Body.get()); 5686} 5687 5688template<typename Derived> 5689StmtResult 5690TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 5691 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), 5692 S->getLabel()); 5693 if (!LD) 5694 return StmtError(); 5695 5696 // Goto statements must always be rebuilt, to resolve the label. 5697 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 5698 cast<LabelDecl>(LD)); 5699} 5700 5701template<typename Derived> 5702StmtResult 5703TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 5704 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 5705 if (Target.isInvalid()) 5706 return StmtError(); 5707 Target = SemaRef.MaybeCreateExprWithCleanups(Target.take()); 5708 5709 if (!getDerived().AlwaysRebuild() && 5710 Target.get() == S->getTarget()) 5711 return SemaRef.Owned(S); 5712 5713 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 5714 Target.get()); 5715} 5716 5717template<typename Derived> 5718StmtResult 5719TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 5720 return SemaRef.Owned(S); 5721} 5722 5723template<typename Derived> 5724StmtResult 5725TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 5726 return SemaRef.Owned(S); 5727} 5728 5729template<typename Derived> 5730StmtResult 5731TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 5732 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 5733 if (Result.isInvalid()) 5734 return StmtError(); 5735 5736 // FIXME: We always rebuild the return statement because there is no way 5737 // to tell whether the return type of the function has changed. 5738 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 5739} 5740 5741template<typename Derived> 5742StmtResult 5743TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 5744 bool DeclChanged = false; 5745 SmallVector<Decl *, 4> Decls; 5746 for (auto *D : S->decls()) { 5747 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D); 5748 if (!Transformed) 5749 return StmtError(); 5750 5751 if (Transformed != D) 5752 DeclChanged = true; 5753 5754 Decls.push_back(Transformed); 5755 } 5756 5757 if (!getDerived().AlwaysRebuild() && !DeclChanged) 5758 return SemaRef.Owned(S); 5759 5760 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc()); 5761} 5762 5763template<typename Derived> 5764StmtResult 5765TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { 5766 5767 SmallVector<Expr*, 8> Constraints; 5768 SmallVector<Expr*, 8> Exprs; 5769 SmallVector<IdentifierInfo *, 4> Names; 5770 5771 ExprResult AsmString; 5772 SmallVector<Expr*, 8> Clobbers; 5773 5774 bool ExprsChanged = false; 5775 5776 // Go through the outputs. 5777 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 5778 Names.push_back(S->getOutputIdentifier(I)); 5779 5780 // No need to transform the constraint literal. 5781 Constraints.push_back(S->getOutputConstraintLiteral(I)); 5782 5783 // Transform the output expr. 5784 Expr *OutputExpr = S->getOutputExpr(I); 5785 ExprResult Result = getDerived().TransformExpr(OutputExpr); 5786 if (Result.isInvalid()) 5787 return StmtError(); 5788 5789 ExprsChanged |= Result.get() != OutputExpr; 5790 5791 Exprs.push_back(Result.get()); 5792 } 5793 5794 // Go through the inputs. 5795 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 5796 Names.push_back(S->getInputIdentifier(I)); 5797 5798 // No need to transform the constraint literal. 5799 Constraints.push_back(S->getInputConstraintLiteral(I)); 5800 5801 // Transform the input expr. 5802 Expr *InputExpr = S->getInputExpr(I); 5803 ExprResult Result = getDerived().TransformExpr(InputExpr); 5804 if (Result.isInvalid()) 5805 return StmtError(); 5806 5807 ExprsChanged |= Result.get() != InputExpr; 5808 5809 Exprs.push_back(Result.get()); 5810 } 5811 5812 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 5813 return SemaRef.Owned(S); 5814 5815 // Go through the clobbers. 5816 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 5817 Clobbers.push_back(S->getClobberStringLiteral(I)); 5818 5819 // No need to transform the asm string literal. 5820 AsmString = SemaRef.Owned(S->getAsmString()); 5821 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), 5822 S->isVolatile(), S->getNumOutputs(), 5823 S->getNumInputs(), Names.data(), 5824 Constraints, Exprs, AsmString.get(), 5825 Clobbers, S->getRParenLoc()); 5826} 5827 5828template<typename Derived> 5829StmtResult 5830TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { 5831 ArrayRef<Token> AsmToks = 5832 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); 5833 5834 bool HadError = false, HadChange = false; 5835 5836 ArrayRef<Expr*> SrcExprs = S->getAllExprs(); 5837 SmallVector<Expr*, 8> TransformedExprs; 5838 TransformedExprs.reserve(SrcExprs.size()); 5839 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) { 5840 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]); 5841 if (!Result.isUsable()) { 5842 HadError = true; 5843 } else { 5844 HadChange |= (Result.get() != SrcExprs[i]); 5845 TransformedExprs.push_back(Result.take()); 5846 } 5847 } 5848 5849 if (HadError) return StmtError(); 5850 if (!HadChange && !getDerived().AlwaysRebuild()) 5851 return Owned(S); 5852 5853 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(), 5854 AsmToks, S->getAsmString(), 5855 S->getNumOutputs(), S->getNumInputs(), 5856 S->getAllConstraints(), S->getClobbers(), 5857 TransformedExprs, S->getEndLoc()); 5858} 5859 5860template<typename Derived> 5861StmtResult 5862TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 5863 // Transform the body of the @try. 5864 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 5865 if (TryBody.isInvalid()) 5866 return StmtError(); 5867 5868 // Transform the @catch statements (if present). 5869 bool AnyCatchChanged = false; 5870 SmallVector<Stmt*, 8> CatchStmts; 5871 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 5872 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 5873 if (Catch.isInvalid()) 5874 return StmtError(); 5875 if (Catch.get() != S->getCatchStmt(I)) 5876 AnyCatchChanged = true; 5877 CatchStmts.push_back(Catch.release()); 5878 } 5879 5880 // Transform the @finally statement (if present). 5881 StmtResult Finally; 5882 if (S->getFinallyStmt()) { 5883 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 5884 if (Finally.isInvalid()) 5885 return StmtError(); 5886 } 5887 5888 // If nothing changed, just retain this statement. 5889 if (!getDerived().AlwaysRebuild() && 5890 TryBody.get() == S->getTryBody() && 5891 !AnyCatchChanged && 5892 Finally.get() == S->getFinallyStmt()) 5893 return SemaRef.Owned(S); 5894 5895 // Build a new statement. 5896 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 5897 CatchStmts, Finally.get()); 5898} 5899 5900template<typename Derived> 5901StmtResult 5902TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 5903 // Transform the @catch parameter, if there is one. 5904 VarDecl *Var = nullptr; 5905 if (VarDecl *FromVar = S->getCatchParamDecl()) { 5906 TypeSourceInfo *TSInfo = nullptr; 5907 if (FromVar->getTypeSourceInfo()) { 5908 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 5909 if (!TSInfo) 5910 return StmtError(); 5911 } 5912 5913 QualType T; 5914 if (TSInfo) 5915 T = TSInfo->getType(); 5916 else { 5917 T = getDerived().TransformType(FromVar->getType()); 5918 if (T.isNull()) 5919 return StmtError(); 5920 } 5921 5922 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 5923 if (!Var) 5924 return StmtError(); 5925 } 5926 5927 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 5928 if (Body.isInvalid()) 5929 return StmtError(); 5930 5931 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 5932 S->getRParenLoc(), 5933 Var, Body.get()); 5934} 5935 5936template<typename Derived> 5937StmtResult 5938TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 5939 // Transform the body. 5940 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 5941 if (Body.isInvalid()) 5942 return StmtError(); 5943 5944 // If nothing changed, just retain this statement. 5945 if (!getDerived().AlwaysRebuild() && 5946 Body.get() == S->getFinallyBody()) 5947 return SemaRef.Owned(S); 5948 5949 // Build a new statement. 5950 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 5951 Body.get()); 5952} 5953 5954template<typename Derived> 5955StmtResult 5956TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5957 ExprResult Operand; 5958 if (S->getThrowExpr()) { 5959 Operand = getDerived().TransformExpr(S->getThrowExpr()); 5960 if (Operand.isInvalid()) 5961 return StmtError(); 5962 } 5963 5964 if (!getDerived().AlwaysRebuild() && 5965 Operand.get() == S->getThrowExpr()) 5966 return getSema().Owned(S); 5967 5968 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 5969} 5970 5971template<typename Derived> 5972StmtResult 5973TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 5974 ObjCAtSynchronizedStmt *S) { 5975 // Transform the object we are locking. 5976 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 5977 if (Object.isInvalid()) 5978 return StmtError(); 5979 Object = 5980 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(), 5981 Object.get()); 5982 if (Object.isInvalid()) 5983 return StmtError(); 5984 5985 // Transform the body. 5986 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 5987 if (Body.isInvalid()) 5988 return StmtError(); 5989 5990 // If nothing change, just retain the current statement. 5991 if (!getDerived().AlwaysRebuild() && 5992 Object.get() == S->getSynchExpr() && 5993 Body.get() == S->getSynchBody()) 5994 return SemaRef.Owned(S); 5995 5996 // Build a new statement. 5997 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 5998 Object.get(), Body.get()); 5999} 6000 6001template<typename Derived> 6002StmtResult 6003TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( 6004 ObjCAutoreleasePoolStmt *S) { 6005 // Transform the body. 6006 StmtResult Body = getDerived().TransformStmt(S->getSubStmt()); 6007 if (Body.isInvalid()) 6008 return StmtError(); 6009 6010 // If nothing changed, just retain this statement. 6011 if (!getDerived().AlwaysRebuild() && 6012 Body.get() == S->getSubStmt()) 6013 return SemaRef.Owned(S); 6014 6015 // Build a new statement. 6016 return getDerived().RebuildObjCAutoreleasePoolStmt( 6017 S->getAtLoc(), Body.get()); 6018} 6019 6020template<typename Derived> 6021StmtResult 6022TreeTransform<Derived>::TransformObjCForCollectionStmt( 6023 ObjCForCollectionStmt *S) { 6024 // Transform the element statement. 6025 StmtResult Element = getDerived().TransformStmt(S->getElement()); 6026 if (Element.isInvalid()) 6027 return StmtError(); 6028 6029 // Transform the collection expression. 6030 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 6031 if (Collection.isInvalid()) 6032 return StmtError(); 6033 6034 // Transform the body. 6035 StmtResult Body = getDerived().TransformStmt(S->getBody()); 6036 if (Body.isInvalid()) 6037 return StmtError(); 6038 6039 // If nothing changed, just retain this statement. 6040 if (!getDerived().AlwaysRebuild() && 6041 Element.get() == S->getElement() && 6042 Collection.get() == S->getCollection() && 6043 Body.get() == S->getBody()) 6044 return SemaRef.Owned(S); 6045 6046 // Build a new statement. 6047 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 6048 Element.get(), 6049 Collection.get(), 6050 S->getRParenLoc(), 6051 Body.get()); 6052} 6053 6054template <typename Derived> 6055StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 6056 // Transform the exception declaration, if any. 6057 VarDecl *Var = nullptr; 6058 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) { 6059 TypeSourceInfo *T = 6060 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo()); 6061 if (!T) 6062 return StmtError(); 6063 6064 Var = getDerived().RebuildExceptionDecl( 6065 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(), 6066 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier()); 6067 if (!Var || Var->isInvalidDecl()) 6068 return StmtError(); 6069 } 6070 6071 // Transform the actual exception handler. 6072 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 6073 if (Handler.isInvalid()) 6074 return StmtError(); 6075 6076 if (!getDerived().AlwaysRebuild() && !Var && 6077 Handler.get() == S->getHandlerBlock()) 6078 return SemaRef.Owned(S); 6079 6080 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get()); 6081} 6082 6083template <typename Derived> 6084StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 6085 // Transform the try block itself. 6086 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); 6087 if (TryBlock.isInvalid()) 6088 return StmtError(); 6089 6090 // Transform the handlers. 6091 bool HandlerChanged = false; 6092 SmallVector<Stmt *, 8> Handlers; 6093 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 6094 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 6095 if (Handler.isInvalid()) 6096 return StmtError(); 6097 6098 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 6099 Handlers.push_back(Handler.takeAs<Stmt>()); 6100 } 6101 6102 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && 6103 !HandlerChanged) 6104 return SemaRef.Owned(S); 6105 6106 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 6107 Handlers); 6108} 6109 6110template<typename Derived> 6111StmtResult 6112TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { 6113 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt()); 6114 if (Range.isInvalid()) 6115 return StmtError(); 6116 6117 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt()); 6118 if (BeginEnd.isInvalid()) 6119 return StmtError(); 6120 6121 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 6122 if (Cond.isInvalid()) 6123 return StmtError(); 6124 if (Cond.get()) 6125 Cond = SemaRef.CheckBooleanCondition(Cond.take(), S->getColonLoc()); 6126 if (Cond.isInvalid()) 6127 return StmtError(); 6128 if (Cond.get()) 6129 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.take()); 6130 6131 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 6132 if (Inc.isInvalid()) 6133 return StmtError(); 6134 if (Inc.get()) 6135 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.take()); 6136 6137 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); 6138 if (LoopVar.isInvalid()) 6139 return StmtError(); 6140 6141 StmtResult NewStmt = S; 6142 if (getDerived().AlwaysRebuild() || 6143 Range.get() != S->getRangeStmt() || 6144 BeginEnd.get() != S->getBeginEndStmt() || 6145 Cond.get() != S->getCond() || 6146 Inc.get() != S->getInc() || 6147 LoopVar.get() != S->getLoopVarStmt()) { 6148 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 6149 S->getColonLoc(), Range.get(), 6150 BeginEnd.get(), Cond.get(), 6151 Inc.get(), LoopVar.get(), 6152 S->getRParenLoc()); 6153 if (NewStmt.isInvalid()) 6154 return StmtError(); 6155 } 6156 6157 StmtResult Body = getDerived().TransformStmt(S->getBody()); 6158 if (Body.isInvalid()) 6159 return StmtError(); 6160 6161 // Body has changed but we didn't rebuild the for-range statement. Rebuild 6162 // it now so we have a new statement to attach the body to. 6163 if (Body.get() != S->getBody() && NewStmt.get() == S) { 6164 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 6165 S->getColonLoc(), Range.get(), 6166 BeginEnd.get(), Cond.get(), 6167 Inc.get(), LoopVar.get(), 6168 S->getRParenLoc()); 6169 if (NewStmt.isInvalid()) 6170 return StmtError(); 6171 } 6172 6173 if (NewStmt.get() == S) 6174 return SemaRef.Owned(S); 6175 6176 return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); 6177} 6178 6179template<typename Derived> 6180StmtResult 6181TreeTransform<Derived>::TransformMSDependentExistsStmt( 6182 MSDependentExistsStmt *S) { 6183 // Transform the nested-name-specifier, if any. 6184 NestedNameSpecifierLoc QualifierLoc; 6185 if (S->getQualifierLoc()) { 6186 QualifierLoc 6187 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc()); 6188 if (!QualifierLoc) 6189 return StmtError(); 6190 } 6191 6192 // Transform the declaration name. 6193 DeclarationNameInfo NameInfo = S->getNameInfo(); 6194 if (NameInfo.getName()) { 6195 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6196 if (!NameInfo.getName()) 6197 return StmtError(); 6198 } 6199 6200 // Check whether anything changed. 6201 if (!getDerived().AlwaysRebuild() && 6202 QualifierLoc == S->getQualifierLoc() && 6203 NameInfo.getName() == S->getNameInfo().getName()) 6204 return S; 6205 6206 // Determine whether this name exists, if we can. 6207 CXXScopeSpec SS; 6208 SS.Adopt(QualifierLoc); 6209 bool Dependent = false; 6210 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) { 6211 case Sema::IER_Exists: 6212 if (S->isIfExists()) 6213 break; 6214 6215 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6216 6217 case Sema::IER_DoesNotExist: 6218 if (S->isIfNotExists()) 6219 break; 6220 6221 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6222 6223 case Sema::IER_Dependent: 6224 Dependent = true; 6225 break; 6226 6227 case Sema::IER_Error: 6228 return StmtError(); 6229 } 6230 6231 // We need to continue with the instantiation, so do so now. 6232 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt()); 6233 if (SubStmt.isInvalid()) 6234 return StmtError(); 6235 6236 // If we have resolved the name, just transform to the substatement. 6237 if (!Dependent) 6238 return SubStmt; 6239 6240 // The name is still dependent, so build a dependent expression again. 6241 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(), 6242 S->isIfExists(), 6243 QualifierLoc, 6244 NameInfo, 6245 SubStmt.get()); 6246} 6247 6248template<typename Derived> 6249ExprResult 6250TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) { 6251 NestedNameSpecifierLoc QualifierLoc; 6252 if (E->getQualifierLoc()) { 6253 QualifierLoc 6254 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6255 if (!QualifierLoc) 6256 return ExprError(); 6257 } 6258 6259 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>( 6260 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl())); 6261 if (!PD) 6262 return ExprError(); 6263 6264 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 6265 if (Base.isInvalid()) 6266 return ExprError(); 6267 6268 return new (SemaRef.getASTContext()) 6269 MSPropertyRefExpr(Base.get(), PD, E->isArrow(), 6270 SemaRef.getASTContext().PseudoObjectTy, VK_LValue, 6271 QualifierLoc, E->getMemberLoc()); 6272} 6273 6274template <typename Derived> 6275StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { 6276 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); 6277 if (TryBlock.isInvalid()) 6278 return StmtError(); 6279 6280 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler()); 6281 if (Handler.isInvalid()) 6282 return StmtError(); 6283 6284 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && 6285 Handler.get() == S->getHandler()) 6286 return SemaRef.Owned(S); 6287 6288 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(), 6289 TryBlock.take(), Handler.take()); 6290} 6291 6292template <typename Derived> 6293StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { 6294 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); 6295 if (Block.isInvalid()) 6296 return StmtError(); 6297 6298 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.take()); 6299} 6300 6301template <typename Derived> 6302StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { 6303 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr()); 6304 if (FilterExpr.isInvalid()) 6305 return StmtError(); 6306 6307 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); 6308 if (Block.isInvalid()) 6309 return StmtError(); 6310 6311 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.take(), 6312 Block.take()); 6313} 6314 6315template <typename Derived> 6316StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { 6317 if (isa<SEHFinallyStmt>(Handler)) 6318 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler)); 6319 else 6320 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler)); 6321} 6322 6323template<typename Derived> 6324StmtResult 6325TreeTransform<Derived>::TransformOMPExecutableDirective( 6326 OMPExecutableDirective *D) { 6327 6328 // Transform the clauses 6329 llvm::SmallVector<OMPClause *, 16> TClauses; 6330 ArrayRef<OMPClause *> Clauses = D->clauses(); 6331 TClauses.reserve(Clauses.size()); 6332 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); 6333 I != E; ++I) { 6334 if (*I) { 6335 OMPClause *Clause = getDerived().TransformOMPClause(*I); 6336 if (!Clause) { 6337 return StmtError(); 6338 } 6339 TClauses.push_back(Clause); 6340 } 6341 else { 6342 TClauses.push_back(nullptr); 6343 } 6344 } 6345 if (!D->getAssociatedStmt()) { 6346 return StmtError(); 6347 } 6348 StmtResult AssociatedStmt = 6349 getDerived().TransformStmt(D->getAssociatedStmt()); 6350 if (AssociatedStmt.isInvalid()) { 6351 return StmtError(); 6352 } 6353 6354 return getDerived().RebuildOMPExecutableDirective(D->getDirectiveKind(), 6355 TClauses, 6356 AssociatedStmt.take(), 6357 D->getLocStart(), 6358 D->getLocEnd()); 6359} 6360 6361template<typename Derived> 6362StmtResult 6363TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { 6364 DeclarationNameInfo DirName; 6365 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr); 6366 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6367 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6368 return Res; 6369} 6370 6371template<typename Derived> 6372StmtResult 6373TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) { 6374 DeclarationNameInfo DirName; 6375 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr); 6376 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6377 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6378 return Res; 6379} 6380 6381template<typename Derived> 6382OMPClause * 6383TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) { 6384 ExprResult Cond = getDerived().TransformExpr(C->getCondition()); 6385 if (Cond.isInvalid()) 6386 return nullptr; 6387 return getDerived().RebuildOMPIfClause(Cond.take(), C->getLocStart(), 6388 C->getLParenLoc(), C->getLocEnd()); 6389} 6390 6391template<typename Derived> 6392OMPClause * 6393TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) { 6394 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads()); 6395 if (NumThreads.isInvalid()) 6396 return nullptr; 6397 return getDerived().RebuildOMPNumThreadsClause(NumThreads.take(), 6398 C->getLocStart(), 6399 C->getLParenLoc(), 6400 C->getLocEnd()); 6401} 6402 6403template <typename Derived> 6404OMPClause * 6405TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) { 6406 ExprResult E = getDerived().TransformExpr(C->getSafelen()); 6407 if (E.isInvalid()) 6408 return nullptr; 6409 return getDerived().RebuildOMPSafelenClause( 6410 E.take(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 6411} 6412 6413template <typename Derived> 6414OMPClause * 6415TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) { 6416 ExprResult E = getDerived().TransformExpr(C->getNumForLoops()); 6417 if (E.isInvalid()) 6418 return 0; 6419 return getDerived().RebuildOMPCollapseClause( 6420 E.take(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 6421} 6422 6423template<typename Derived> 6424OMPClause * 6425TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) { 6426 return getDerived().RebuildOMPDefaultClause(C->getDefaultKind(), 6427 C->getDefaultKindKwLoc(), 6428 C->getLocStart(), 6429 C->getLParenLoc(), 6430 C->getLocEnd()); 6431} 6432 6433template<typename Derived> 6434OMPClause * 6435TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) { 6436 return getDerived().RebuildOMPProcBindClause(C->getProcBindKind(), 6437 C->getProcBindKindKwLoc(), 6438 C->getLocStart(), 6439 C->getLParenLoc(), 6440 C->getLocEnd()); 6441} 6442 6443template<typename Derived> 6444OMPClause * 6445TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { 6446 llvm::SmallVector<Expr *, 16> Vars; 6447 Vars.reserve(C->varlist_size()); 6448 for (auto *VE : C->varlists()) { 6449 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 6450 if (EVar.isInvalid()) 6451 return nullptr; 6452 Vars.push_back(EVar.take()); 6453 } 6454 return getDerived().RebuildOMPPrivateClause(Vars, 6455 C->getLocStart(), 6456 C->getLParenLoc(), 6457 C->getLocEnd()); 6458} 6459 6460template<typename Derived> 6461OMPClause * 6462TreeTransform<Derived>::TransformOMPFirstprivateClause( 6463 OMPFirstprivateClause *C) { 6464 llvm::SmallVector<Expr *, 16> Vars; 6465 Vars.reserve(C->varlist_size()); 6466 for (auto *VE : C->varlists()) { 6467 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 6468 if (EVar.isInvalid()) 6469 return nullptr; 6470 Vars.push_back(EVar.take()); 6471 } 6472 return getDerived().RebuildOMPFirstprivateClause(Vars, 6473 C->getLocStart(), 6474 C->getLParenLoc(), 6475 C->getLocEnd()); 6476} 6477 6478template<typename Derived> 6479OMPClause * 6480TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) { 6481 llvm::SmallVector<Expr *, 16> Vars; 6482 Vars.reserve(C->varlist_size()); 6483 for (auto *VE : C->varlists()) { 6484 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 6485 if (EVar.isInvalid()) 6486 return nullptr; 6487 Vars.push_back(EVar.take()); 6488 } 6489 return getDerived().RebuildOMPSharedClause(Vars, 6490 C->getLocStart(), 6491 C->getLParenLoc(), 6492 C->getLocEnd()); 6493} 6494 6495template<typename Derived> 6496OMPClause * 6497TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) { 6498 llvm::SmallVector<Expr *, 16> Vars; 6499 Vars.reserve(C->varlist_size()); 6500 for (auto *VE : C->varlists()) { 6501 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 6502 if (EVar.isInvalid()) 6503 return nullptr; 6504 Vars.push_back(EVar.take()); 6505 } 6506 ExprResult Step = getDerived().TransformExpr(C->getStep()); 6507 if (Step.isInvalid()) 6508 return nullptr; 6509 return getDerived().RebuildOMPLinearClause( 6510 Vars, Step.take(), C->getLocStart(), C->getLParenLoc(), C->getColonLoc(), 6511 C->getLocEnd()); 6512} 6513 6514template<typename Derived> 6515OMPClause * 6516TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) { 6517 llvm::SmallVector<Expr *, 16> Vars; 6518 Vars.reserve(C->varlist_size()); 6519 for (auto *VE : C->varlists()) { 6520 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 6521 if (EVar.isInvalid()) 6522 return nullptr; 6523 Vars.push_back(EVar.take()); 6524 } 6525 return getDerived().RebuildOMPCopyinClause(Vars, 6526 C->getLocStart(), 6527 C->getLParenLoc(), 6528 C->getLocEnd()); 6529} 6530 6531//===----------------------------------------------------------------------===// 6532// Expression transformation 6533//===----------------------------------------------------------------------===// 6534template<typename Derived> 6535ExprResult 6536TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 6537 return SemaRef.Owned(E); 6538} 6539 6540template<typename Derived> 6541ExprResult 6542TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 6543 NestedNameSpecifierLoc QualifierLoc; 6544 if (E->getQualifierLoc()) { 6545 QualifierLoc 6546 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6547 if (!QualifierLoc) 6548 return ExprError(); 6549 } 6550 6551 ValueDecl *ND 6552 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 6553 E->getDecl())); 6554 if (!ND) 6555 return ExprError(); 6556 6557 DeclarationNameInfo NameInfo = E->getNameInfo(); 6558 if (NameInfo.getName()) { 6559 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6560 if (!NameInfo.getName()) 6561 return ExprError(); 6562 } 6563 6564 if (!getDerived().AlwaysRebuild() && 6565 QualifierLoc == E->getQualifierLoc() && 6566 ND == E->getDecl() && 6567 NameInfo.getName() == E->getDecl()->getDeclName() && 6568 !E->hasExplicitTemplateArgs()) { 6569 6570 // Mark it referenced in the new context regardless. 6571 // FIXME: this is a bit instantiation-specific. 6572 SemaRef.MarkDeclRefReferenced(E); 6573 6574 return SemaRef.Owned(E); 6575 } 6576 6577 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr; 6578 if (E->hasExplicitTemplateArgs()) { 6579 TemplateArgs = &TransArgs; 6580 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6581 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6582 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6583 E->getNumTemplateArgs(), 6584 TransArgs)) 6585 return ExprError(); 6586 } 6587 6588 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, 6589 TemplateArgs); 6590} 6591 6592template<typename Derived> 6593ExprResult 6594TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 6595 return SemaRef.Owned(E); 6596} 6597 6598template<typename Derived> 6599ExprResult 6600TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 6601 return SemaRef.Owned(E); 6602} 6603 6604template<typename Derived> 6605ExprResult 6606TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 6607 return SemaRef.Owned(E); 6608} 6609 6610template<typename Derived> 6611ExprResult 6612TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 6613 return SemaRef.Owned(E); 6614} 6615 6616template<typename Derived> 6617ExprResult 6618TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 6619 return SemaRef.Owned(E); 6620} 6621 6622template<typename Derived> 6623ExprResult 6624TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { 6625 if (FunctionDecl *FD = E->getDirectCallee()) 6626 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD); 6627 return SemaRef.MaybeBindToTemporary(E); 6628} 6629 6630template<typename Derived> 6631ExprResult 6632TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { 6633 ExprResult ControllingExpr = 6634 getDerived().TransformExpr(E->getControllingExpr()); 6635 if (ControllingExpr.isInvalid()) 6636 return ExprError(); 6637 6638 SmallVector<Expr *, 4> AssocExprs; 6639 SmallVector<TypeSourceInfo *, 4> AssocTypes; 6640 for (unsigned i = 0; i != E->getNumAssocs(); ++i) { 6641 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i); 6642 if (TS) { 6643 TypeSourceInfo *AssocType = getDerived().TransformType(TS); 6644 if (!AssocType) 6645 return ExprError(); 6646 AssocTypes.push_back(AssocType); 6647 } else { 6648 AssocTypes.push_back(nullptr); 6649 } 6650 6651 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); 6652 if (AssocExpr.isInvalid()) 6653 return ExprError(); 6654 AssocExprs.push_back(AssocExpr.release()); 6655 } 6656 6657 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), 6658 E->getDefaultLoc(), 6659 E->getRParenLoc(), 6660 ControllingExpr.release(), 6661 AssocTypes, 6662 AssocExprs); 6663} 6664 6665template<typename Derived> 6666ExprResult 6667TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 6668 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6669 if (SubExpr.isInvalid()) 6670 return ExprError(); 6671 6672 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6673 return SemaRef.Owned(E); 6674 6675 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 6676 E->getRParen()); 6677} 6678 6679/// \brief The operand of a unary address-of operator has special rules: it's 6680/// allowed to refer to a non-static member of a class even if there's no 'this' 6681/// object available. 6682template<typename Derived> 6683ExprResult 6684TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { 6685 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) 6686 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true); 6687 else 6688 return getDerived().TransformExpr(E); 6689} 6690 6691template<typename Derived> 6692ExprResult 6693TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 6694 ExprResult SubExpr; 6695 if (E->getOpcode() == UO_AddrOf) 6696 SubExpr = TransformAddressOfOperand(E->getSubExpr()); 6697 else 6698 SubExpr = TransformExpr(E->getSubExpr()); 6699 if (SubExpr.isInvalid()) 6700 return ExprError(); 6701 6702 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6703 return SemaRef.Owned(E); 6704 6705 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 6706 E->getOpcode(), 6707 SubExpr.get()); 6708} 6709 6710template<typename Derived> 6711ExprResult 6712TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 6713 // Transform the type. 6714 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 6715 if (!Type) 6716 return ExprError(); 6717 6718 // Transform all of the components into components similar to what the 6719 // parser uses. 6720 // FIXME: It would be slightly more efficient in the non-dependent case to 6721 // just map FieldDecls, rather than requiring the rebuilder to look for 6722 // the fields again. However, __builtin_offsetof is rare enough in 6723 // template code that we don't care. 6724 bool ExprChanged = false; 6725 typedef Sema::OffsetOfComponent Component; 6726 typedef OffsetOfExpr::OffsetOfNode Node; 6727 SmallVector<Component, 4> Components; 6728 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 6729 const Node &ON = E->getComponent(I); 6730 Component Comp; 6731 Comp.isBrackets = true; 6732 Comp.LocStart = ON.getSourceRange().getBegin(); 6733 Comp.LocEnd = ON.getSourceRange().getEnd(); 6734 switch (ON.getKind()) { 6735 case Node::Array: { 6736 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 6737 ExprResult Index = getDerived().TransformExpr(FromIndex); 6738 if (Index.isInvalid()) 6739 return ExprError(); 6740 6741 ExprChanged = ExprChanged || Index.get() != FromIndex; 6742 Comp.isBrackets = true; 6743 Comp.U.E = Index.get(); 6744 break; 6745 } 6746 6747 case Node::Field: 6748 case Node::Identifier: 6749 Comp.isBrackets = false; 6750 Comp.U.IdentInfo = ON.getFieldName(); 6751 if (!Comp.U.IdentInfo) 6752 continue; 6753 6754 break; 6755 6756 case Node::Base: 6757 // Will be recomputed during the rebuild. 6758 continue; 6759 } 6760 6761 Components.push_back(Comp); 6762 } 6763 6764 // If nothing changed, retain the existing expression. 6765 if (!getDerived().AlwaysRebuild() && 6766 Type == E->getTypeSourceInfo() && 6767 !ExprChanged) 6768 return SemaRef.Owned(E); 6769 6770 // Build a new offsetof expression. 6771 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 6772 Components.data(), Components.size(), 6773 E->getRParenLoc()); 6774} 6775 6776template<typename Derived> 6777ExprResult 6778TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 6779 assert(getDerived().AlreadyTransformed(E->getType()) && 6780 "opaque value expression requires transformation"); 6781 return SemaRef.Owned(E); 6782} 6783 6784template<typename Derived> 6785ExprResult 6786TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { 6787 // Rebuild the syntactic form. The original syntactic form has 6788 // opaque-value expressions in it, so strip those away and rebuild 6789 // the result. This is a really awful way of doing this, but the 6790 // better solution (rebuilding the semantic expressions and 6791 // rebinding OVEs as necessary) doesn't work; we'd need 6792 // TreeTransform to not strip away implicit conversions. 6793 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E); 6794 ExprResult result = getDerived().TransformExpr(newSyntacticForm); 6795 if (result.isInvalid()) return ExprError(); 6796 6797 // If that gives us a pseudo-object result back, the pseudo-object 6798 // expression must have been an lvalue-to-rvalue conversion which we 6799 // should reapply. 6800 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) 6801 result = SemaRef.checkPseudoObjectRValue(result.take()); 6802 6803 return result; 6804} 6805 6806template<typename Derived> 6807ExprResult 6808TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( 6809 UnaryExprOrTypeTraitExpr *E) { 6810 if (E->isArgumentType()) { 6811 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 6812 6813 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 6814 if (!NewT) 6815 return ExprError(); 6816 6817 if (!getDerived().AlwaysRebuild() && OldT == NewT) 6818 return SemaRef.Owned(E); 6819 6820 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), 6821 E->getKind(), 6822 E->getSourceRange()); 6823 } 6824 6825 // C++0x [expr.sizeof]p1: 6826 // The operand is either an expression, which is an unevaluated operand 6827 // [...] 6828 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 6829 Sema::ReuseLambdaContextDecl); 6830 6831 ExprResult SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 6832 if (SubExpr.isInvalid()) 6833 return ExprError(); 6834 6835 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 6836 return SemaRef.Owned(E); 6837 6838 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), 6839 E->getOperatorLoc(), 6840 E->getKind(), 6841 E->getSourceRange()); 6842} 6843 6844template<typename Derived> 6845ExprResult 6846TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 6847 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6848 if (LHS.isInvalid()) 6849 return ExprError(); 6850 6851 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6852 if (RHS.isInvalid()) 6853 return ExprError(); 6854 6855 6856 if (!getDerived().AlwaysRebuild() && 6857 LHS.get() == E->getLHS() && 6858 RHS.get() == E->getRHS()) 6859 return SemaRef.Owned(E); 6860 6861 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 6862 /*FIXME:*/E->getLHS()->getLocStart(), 6863 RHS.get(), 6864 E->getRBracketLoc()); 6865} 6866 6867template<typename Derived> 6868ExprResult 6869TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 6870 // Transform the callee. 6871 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6872 if (Callee.isInvalid()) 6873 return ExprError(); 6874 6875 // Transform arguments. 6876 bool ArgChanged = false; 6877 SmallVector<Expr*, 8> Args; 6878 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6879 &ArgChanged)) 6880 return ExprError(); 6881 6882 if (!getDerived().AlwaysRebuild() && 6883 Callee.get() == E->getCallee() && 6884 !ArgChanged) 6885 return SemaRef.MaybeBindToTemporary(E); 6886 6887 // FIXME: Wrong source location information for the '('. 6888 SourceLocation FakeLParenLoc 6889 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 6890 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 6891 Args, 6892 E->getRParenLoc()); 6893} 6894 6895template<typename Derived> 6896ExprResult 6897TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 6898 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6899 if (Base.isInvalid()) 6900 return ExprError(); 6901 6902 NestedNameSpecifierLoc QualifierLoc; 6903 if (E->hasQualifier()) { 6904 QualifierLoc 6905 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6906 6907 if (!QualifierLoc) 6908 return ExprError(); 6909 } 6910 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 6911 6912 ValueDecl *Member 6913 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 6914 E->getMemberDecl())); 6915 if (!Member) 6916 return ExprError(); 6917 6918 NamedDecl *FoundDecl = E->getFoundDecl(); 6919 if (FoundDecl == E->getMemberDecl()) { 6920 FoundDecl = Member; 6921 } else { 6922 FoundDecl = cast_or_null<NamedDecl>( 6923 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 6924 if (!FoundDecl) 6925 return ExprError(); 6926 } 6927 6928 if (!getDerived().AlwaysRebuild() && 6929 Base.get() == E->getBase() && 6930 QualifierLoc == E->getQualifierLoc() && 6931 Member == E->getMemberDecl() && 6932 FoundDecl == E->getFoundDecl() && 6933 !E->hasExplicitTemplateArgs()) { 6934 6935 // Mark it referenced in the new context regardless. 6936 // FIXME: this is a bit instantiation-specific. 6937 SemaRef.MarkMemberReferenced(E); 6938 6939 return SemaRef.Owned(E); 6940 } 6941 6942 TemplateArgumentListInfo TransArgs; 6943 if (E->hasExplicitTemplateArgs()) { 6944 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6945 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6946 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6947 E->getNumTemplateArgs(), 6948 TransArgs)) 6949 return ExprError(); 6950 } 6951 6952 // FIXME: Bogus source location for the operator 6953 SourceLocation FakeOperatorLoc = 6954 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 6955 6956 // FIXME: to do this check properly, we will need to preserve the 6957 // first-qualifier-in-scope here, just in case we had a dependent 6958 // base (and therefore couldn't do the check) and a 6959 // nested-name-qualifier (and therefore could do the lookup). 6960 NamedDecl *FirstQualifierInScope = nullptr; 6961 6962 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 6963 E->isArrow(), 6964 QualifierLoc, 6965 TemplateKWLoc, 6966 E->getMemberNameInfo(), 6967 Member, 6968 FoundDecl, 6969 (E->hasExplicitTemplateArgs() 6970 ? &TransArgs : nullptr), 6971 FirstQualifierInScope); 6972} 6973 6974template<typename Derived> 6975ExprResult 6976TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 6977 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6978 if (LHS.isInvalid()) 6979 return ExprError(); 6980 6981 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6982 if (RHS.isInvalid()) 6983 return ExprError(); 6984 6985 if (!getDerived().AlwaysRebuild() && 6986 LHS.get() == E->getLHS() && 6987 RHS.get() == E->getRHS()) 6988 return SemaRef.Owned(E); 6989 6990 Sema::FPContractStateRAII FPContractState(getSema()); 6991 getSema().FPFeatures.fp_contract = E->isFPContractable(); 6992 6993 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 6994 LHS.get(), RHS.get()); 6995} 6996 6997template<typename Derived> 6998ExprResult 6999TreeTransform<Derived>::TransformCompoundAssignOperator( 7000 CompoundAssignOperator *E) { 7001 return getDerived().TransformBinaryOperator(E); 7002} 7003 7004template<typename Derived> 7005ExprResult TreeTransform<Derived>:: 7006TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { 7007 // Just rebuild the common and RHS expressions and see whether we 7008 // get any changes. 7009 7010 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); 7011 if (commonExpr.isInvalid()) 7012 return ExprError(); 7013 7014 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); 7015 if (rhs.isInvalid()) 7016 return ExprError(); 7017 7018 if (!getDerived().AlwaysRebuild() && 7019 commonExpr.get() == e->getCommon() && 7020 rhs.get() == e->getFalseExpr()) 7021 return SemaRef.Owned(e); 7022 7023 return getDerived().RebuildConditionalOperator(commonExpr.take(), 7024 e->getQuestionLoc(), 7025 nullptr, 7026 e->getColonLoc(), 7027 rhs.get()); 7028} 7029 7030template<typename Derived> 7031ExprResult 7032TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 7033 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 7034 if (Cond.isInvalid()) 7035 return ExprError(); 7036 7037 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 7038 if (LHS.isInvalid()) 7039 return ExprError(); 7040 7041 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 7042 if (RHS.isInvalid()) 7043 return ExprError(); 7044 7045 if (!getDerived().AlwaysRebuild() && 7046 Cond.get() == E->getCond() && 7047 LHS.get() == E->getLHS() && 7048 RHS.get() == E->getRHS()) 7049 return SemaRef.Owned(E); 7050 7051 return getDerived().RebuildConditionalOperator(Cond.get(), 7052 E->getQuestionLoc(), 7053 LHS.get(), 7054 E->getColonLoc(), 7055 RHS.get()); 7056} 7057 7058template<typename Derived> 7059ExprResult 7060TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 7061 // Implicit casts are eliminated during transformation, since they 7062 // will be recomputed by semantic analysis after transformation. 7063 return getDerived().TransformExpr(E->getSubExprAsWritten()); 7064} 7065 7066template<typename Derived> 7067ExprResult 7068TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 7069 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7070 if (!Type) 7071 return ExprError(); 7072 7073 ExprResult SubExpr 7074 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7075 if (SubExpr.isInvalid()) 7076 return ExprError(); 7077 7078 if (!getDerived().AlwaysRebuild() && 7079 Type == E->getTypeInfoAsWritten() && 7080 SubExpr.get() == E->getSubExpr()) 7081 return SemaRef.Owned(E); 7082 7083 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 7084 Type, 7085 E->getRParenLoc(), 7086 SubExpr.get()); 7087} 7088 7089template<typename Derived> 7090ExprResult 7091TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 7092 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 7093 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 7094 if (!NewT) 7095 return ExprError(); 7096 7097 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 7098 if (Init.isInvalid()) 7099 return ExprError(); 7100 7101 if (!getDerived().AlwaysRebuild() && 7102 OldT == NewT && 7103 Init.get() == E->getInitializer()) 7104 return SemaRef.MaybeBindToTemporary(E); 7105 7106 // Note: the expression type doesn't necessarily match the 7107 // type-as-written, but that's okay, because it should always be 7108 // derivable from the initializer. 7109 7110 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 7111 /*FIXME:*/E->getInitializer()->getLocEnd(), 7112 Init.get()); 7113} 7114 7115template<typename Derived> 7116ExprResult 7117TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 7118 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7119 if (Base.isInvalid()) 7120 return ExprError(); 7121 7122 if (!getDerived().AlwaysRebuild() && 7123 Base.get() == E->getBase()) 7124 return SemaRef.Owned(E); 7125 7126 // FIXME: Bad source location 7127 SourceLocation FakeOperatorLoc = 7128 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd()); 7129 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 7130 E->getAccessorLoc(), 7131 E->getAccessor()); 7132} 7133 7134template<typename Derived> 7135ExprResult 7136TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 7137 bool InitChanged = false; 7138 7139 SmallVector<Expr*, 4> Inits; 7140 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 7141 Inits, &InitChanged)) 7142 return ExprError(); 7143 7144 if (!getDerived().AlwaysRebuild() && !InitChanged) 7145 return SemaRef.Owned(E); 7146 7147 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, 7148 E->getRBraceLoc(), E->getType()); 7149} 7150 7151template<typename Derived> 7152ExprResult 7153TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 7154 Designation Desig; 7155 7156 // transform the initializer value 7157 ExprResult Init = getDerived().TransformExpr(E->getInit()); 7158 if (Init.isInvalid()) 7159 return ExprError(); 7160 7161 // transform the designators. 7162 SmallVector<Expr*, 4> ArrayExprs; 7163 bool ExprChanged = false; 7164 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 7165 DEnd = E->designators_end(); 7166 D != DEnd; ++D) { 7167 if (D->isFieldDesignator()) { 7168 Desig.AddDesignator(Designator::getField(D->getFieldName(), 7169 D->getDotLoc(), 7170 D->getFieldLoc())); 7171 continue; 7172 } 7173 7174 if (D->isArrayDesignator()) { 7175 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 7176 if (Index.isInvalid()) 7177 return ExprError(); 7178 7179 Desig.AddDesignator(Designator::getArray(Index.get(), 7180 D->getLBracketLoc())); 7181 7182 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 7183 ArrayExprs.push_back(Index.release()); 7184 continue; 7185 } 7186 7187 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 7188 ExprResult Start 7189 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 7190 if (Start.isInvalid()) 7191 return ExprError(); 7192 7193 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 7194 if (End.isInvalid()) 7195 return ExprError(); 7196 7197 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 7198 End.get(), 7199 D->getLBracketLoc(), 7200 D->getEllipsisLoc())); 7201 7202 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 7203 End.get() != E->getArrayRangeEnd(*D); 7204 7205 ArrayExprs.push_back(Start.release()); 7206 ArrayExprs.push_back(End.release()); 7207 } 7208 7209 if (!getDerived().AlwaysRebuild() && 7210 Init.get() == E->getInit() && 7211 !ExprChanged) 7212 return SemaRef.Owned(E); 7213 7214 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, 7215 E->getEqualOrColonLoc(), 7216 E->usesGNUSyntax(), Init.get()); 7217} 7218 7219template<typename Derived> 7220ExprResult 7221TreeTransform<Derived>::TransformImplicitValueInitExpr( 7222 ImplicitValueInitExpr *E) { 7223 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 7224 7225 // FIXME: Will we ever have proper type location here? Will we actually 7226 // need to transform the type? 7227 QualType T = getDerived().TransformType(E->getType()); 7228 if (T.isNull()) 7229 return ExprError(); 7230 7231 if (!getDerived().AlwaysRebuild() && 7232 T == E->getType()) 7233 return SemaRef.Owned(E); 7234 7235 return getDerived().RebuildImplicitValueInitExpr(T); 7236} 7237 7238template<typename Derived> 7239ExprResult 7240TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 7241 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 7242 if (!TInfo) 7243 return ExprError(); 7244 7245 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 7246 if (SubExpr.isInvalid()) 7247 return ExprError(); 7248 7249 if (!getDerived().AlwaysRebuild() && 7250 TInfo == E->getWrittenTypeInfo() && 7251 SubExpr.get() == E->getSubExpr()) 7252 return SemaRef.Owned(E); 7253 7254 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 7255 TInfo, E->getRParenLoc()); 7256} 7257 7258template<typename Derived> 7259ExprResult 7260TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 7261 bool ArgumentChanged = false; 7262 SmallVector<Expr*, 4> Inits; 7263 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 7264 &ArgumentChanged)) 7265 return ExprError(); 7266 7267 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 7268 Inits, 7269 E->getRParenLoc()); 7270} 7271 7272/// \brief Transform an address-of-label expression. 7273/// 7274/// By default, the transformation of an address-of-label expression always 7275/// rebuilds the expression, so that the label identifier can be resolved to 7276/// the corresponding label statement by semantic analysis. 7277template<typename Derived> 7278ExprResult 7279TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 7280 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), 7281 E->getLabel()); 7282 if (!LD) 7283 return ExprError(); 7284 7285 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 7286 cast<LabelDecl>(LD)); 7287} 7288 7289template<typename Derived> 7290ExprResult 7291TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 7292 SemaRef.ActOnStartStmtExpr(); 7293 StmtResult SubStmt 7294 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 7295 if (SubStmt.isInvalid()) { 7296 SemaRef.ActOnStmtExprError(); 7297 return ExprError(); 7298 } 7299 7300 if (!getDerived().AlwaysRebuild() && 7301 SubStmt.get() == E->getSubStmt()) { 7302 // Calling this an 'error' is unintuitive, but it does the right thing. 7303 SemaRef.ActOnStmtExprError(); 7304 return SemaRef.MaybeBindToTemporary(E); 7305 } 7306 7307 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 7308 SubStmt.get(), 7309 E->getRParenLoc()); 7310} 7311 7312template<typename Derived> 7313ExprResult 7314TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 7315 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 7316 if (Cond.isInvalid()) 7317 return ExprError(); 7318 7319 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 7320 if (LHS.isInvalid()) 7321 return ExprError(); 7322 7323 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 7324 if (RHS.isInvalid()) 7325 return ExprError(); 7326 7327 if (!getDerived().AlwaysRebuild() && 7328 Cond.get() == E->getCond() && 7329 LHS.get() == E->getLHS() && 7330 RHS.get() == E->getRHS()) 7331 return SemaRef.Owned(E); 7332 7333 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 7334 Cond.get(), LHS.get(), RHS.get(), 7335 E->getRParenLoc()); 7336} 7337 7338template<typename Derived> 7339ExprResult 7340TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 7341 return SemaRef.Owned(E); 7342} 7343 7344template<typename Derived> 7345ExprResult 7346TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 7347 switch (E->getOperator()) { 7348 case OO_New: 7349 case OO_Delete: 7350 case OO_Array_New: 7351 case OO_Array_Delete: 7352 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 7353 7354 case OO_Call: { 7355 // This is a call to an object's operator(). 7356 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 7357 7358 // Transform the object itself. 7359 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 7360 if (Object.isInvalid()) 7361 return ExprError(); 7362 7363 // FIXME: Poor location information 7364 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken( 7365 static_cast<Expr *>(Object.get())->getLocEnd()); 7366 7367 // Transform the call arguments. 7368 SmallVector<Expr*, 8> Args; 7369 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 7370 Args)) 7371 return ExprError(); 7372 7373 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 7374 Args, 7375 E->getLocEnd()); 7376 } 7377 7378#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 7379 case OO_##Name: 7380#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 7381#include "clang/Basic/OperatorKinds.def" 7382 case OO_Subscript: 7383 // Handled below. 7384 break; 7385 7386 case OO_Conditional: 7387 llvm_unreachable("conditional operator is not actually overloadable"); 7388 7389 case OO_None: 7390 case NUM_OVERLOADED_OPERATORS: 7391 llvm_unreachable("not an overloaded operator?"); 7392 } 7393 7394 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 7395 if (Callee.isInvalid()) 7396 return ExprError(); 7397 7398 ExprResult First; 7399 if (E->getOperator() == OO_Amp) 7400 First = getDerived().TransformAddressOfOperand(E->getArg(0)); 7401 else 7402 First = getDerived().TransformExpr(E->getArg(0)); 7403 if (First.isInvalid()) 7404 return ExprError(); 7405 7406 ExprResult Second; 7407 if (E->getNumArgs() == 2) { 7408 Second = getDerived().TransformExpr(E->getArg(1)); 7409 if (Second.isInvalid()) 7410 return ExprError(); 7411 } 7412 7413 if (!getDerived().AlwaysRebuild() && 7414 Callee.get() == E->getCallee() && 7415 First.get() == E->getArg(0) && 7416 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 7417 return SemaRef.MaybeBindToTemporary(E); 7418 7419 Sema::FPContractStateRAII FPContractState(getSema()); 7420 getSema().FPFeatures.fp_contract = E->isFPContractable(); 7421 7422 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 7423 E->getOperatorLoc(), 7424 Callee.get(), 7425 First.get(), 7426 Second.get()); 7427} 7428 7429template<typename Derived> 7430ExprResult 7431TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 7432 return getDerived().TransformCallExpr(E); 7433} 7434 7435template<typename Derived> 7436ExprResult 7437TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 7438 // Transform the callee. 7439 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 7440 if (Callee.isInvalid()) 7441 return ExprError(); 7442 7443 // Transform exec config. 7444 ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); 7445 if (EC.isInvalid()) 7446 return ExprError(); 7447 7448 // Transform arguments. 7449 bool ArgChanged = false; 7450 SmallVector<Expr*, 8> Args; 7451 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7452 &ArgChanged)) 7453 return ExprError(); 7454 7455 if (!getDerived().AlwaysRebuild() && 7456 Callee.get() == E->getCallee() && 7457 !ArgChanged) 7458 return SemaRef.MaybeBindToTemporary(E); 7459 7460 // FIXME: Wrong source location information for the '('. 7461 SourceLocation FakeLParenLoc 7462 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 7463 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 7464 Args, 7465 E->getRParenLoc(), EC.get()); 7466} 7467 7468template<typename Derived> 7469ExprResult 7470TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 7471 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7472 if (!Type) 7473 return ExprError(); 7474 7475 ExprResult SubExpr 7476 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7477 if (SubExpr.isInvalid()) 7478 return ExprError(); 7479 7480 if (!getDerived().AlwaysRebuild() && 7481 Type == E->getTypeInfoAsWritten() && 7482 SubExpr.get() == E->getSubExpr()) 7483 return SemaRef.Owned(E); 7484 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 7485 E->getStmtClass(), 7486 E->getAngleBrackets().getBegin(), 7487 Type, 7488 E->getAngleBrackets().getEnd(), 7489 // FIXME. this should be '(' location 7490 E->getAngleBrackets().getEnd(), 7491 SubExpr.get(), 7492 E->getRParenLoc()); 7493} 7494 7495template<typename Derived> 7496ExprResult 7497TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 7498 return getDerived().TransformCXXNamedCastExpr(E); 7499} 7500 7501template<typename Derived> 7502ExprResult 7503TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 7504 return getDerived().TransformCXXNamedCastExpr(E); 7505} 7506 7507template<typename Derived> 7508ExprResult 7509TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 7510 CXXReinterpretCastExpr *E) { 7511 return getDerived().TransformCXXNamedCastExpr(E); 7512} 7513 7514template<typename Derived> 7515ExprResult 7516TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 7517 return getDerived().TransformCXXNamedCastExpr(E); 7518} 7519 7520template<typename Derived> 7521ExprResult 7522TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 7523 CXXFunctionalCastExpr *E) { 7524 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7525 if (!Type) 7526 return ExprError(); 7527 7528 ExprResult SubExpr 7529 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7530 if (SubExpr.isInvalid()) 7531 return ExprError(); 7532 7533 if (!getDerived().AlwaysRebuild() && 7534 Type == E->getTypeInfoAsWritten() && 7535 SubExpr.get() == E->getSubExpr()) 7536 return SemaRef.Owned(E); 7537 7538 return getDerived().RebuildCXXFunctionalCastExpr(Type, 7539 E->getLParenLoc(), 7540 SubExpr.get(), 7541 E->getRParenLoc()); 7542} 7543 7544template<typename Derived> 7545ExprResult 7546TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 7547 if (E->isTypeOperand()) { 7548 TypeSourceInfo *TInfo 7549 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 7550 if (!TInfo) 7551 return ExprError(); 7552 7553 if (!getDerived().AlwaysRebuild() && 7554 TInfo == E->getTypeOperandSourceInfo()) 7555 return SemaRef.Owned(E); 7556 7557 return getDerived().RebuildCXXTypeidExpr(E->getType(), 7558 E->getLocStart(), 7559 TInfo, 7560 E->getLocEnd()); 7561 } 7562 7563 // We don't know whether the subexpression is potentially evaluated until 7564 // after we perform semantic analysis. We speculatively assume it is 7565 // unevaluated; it will get fixed later if the subexpression is in fact 7566 // potentially evaluated. 7567 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 7568 Sema::ReuseLambdaContextDecl); 7569 7570 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 7571 if (SubExpr.isInvalid()) 7572 return ExprError(); 7573 7574 if (!getDerived().AlwaysRebuild() && 7575 SubExpr.get() == E->getExprOperand()) 7576 return SemaRef.Owned(E); 7577 7578 return getDerived().RebuildCXXTypeidExpr(E->getType(), 7579 E->getLocStart(), 7580 SubExpr.get(), 7581 E->getLocEnd()); 7582} 7583 7584template<typename Derived> 7585ExprResult 7586TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 7587 if (E->isTypeOperand()) { 7588 TypeSourceInfo *TInfo 7589 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 7590 if (!TInfo) 7591 return ExprError(); 7592 7593 if (!getDerived().AlwaysRebuild() && 7594 TInfo == E->getTypeOperandSourceInfo()) 7595 return SemaRef.Owned(E); 7596 7597 return getDerived().RebuildCXXUuidofExpr(E->getType(), 7598 E->getLocStart(), 7599 TInfo, 7600 E->getLocEnd()); 7601 } 7602 7603 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7604 7605 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 7606 if (SubExpr.isInvalid()) 7607 return ExprError(); 7608 7609 if (!getDerived().AlwaysRebuild() && 7610 SubExpr.get() == E->getExprOperand()) 7611 return SemaRef.Owned(E); 7612 7613 return getDerived().RebuildCXXUuidofExpr(E->getType(), 7614 E->getLocStart(), 7615 SubExpr.get(), 7616 E->getLocEnd()); 7617} 7618 7619template<typename Derived> 7620ExprResult 7621TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 7622 return SemaRef.Owned(E); 7623} 7624 7625template<typename Derived> 7626ExprResult 7627TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 7628 CXXNullPtrLiteralExpr *E) { 7629 return SemaRef.Owned(E); 7630} 7631 7632template<typename Derived> 7633ExprResult 7634TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 7635 QualType T = getSema().getCurrentThisType(); 7636 7637 if (!getDerived().AlwaysRebuild() && T == E->getType()) { 7638 // Make sure that we capture 'this'. 7639 getSema().CheckCXXThisCapture(E->getLocStart()); 7640 return SemaRef.Owned(E); 7641 } 7642 7643 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 7644} 7645 7646template<typename Derived> 7647ExprResult 7648TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 7649 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 7650 if (SubExpr.isInvalid()) 7651 return ExprError(); 7652 7653 if (!getDerived().AlwaysRebuild() && 7654 SubExpr.get() == E->getSubExpr()) 7655 return SemaRef.Owned(E); 7656 7657 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(), 7658 E->isThrownVariableInScope()); 7659} 7660 7661template<typename Derived> 7662ExprResult 7663TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 7664 ParmVarDecl *Param 7665 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 7666 E->getParam())); 7667 if (!Param) 7668 return ExprError(); 7669 7670 if (!getDerived().AlwaysRebuild() && 7671 Param == E->getParam()) 7672 return SemaRef.Owned(E); 7673 7674 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 7675} 7676 7677template<typename Derived> 7678ExprResult 7679TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 7680 FieldDecl *Field 7681 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(), 7682 E->getField())); 7683 if (!Field) 7684 return ExprError(); 7685 7686 if (!getDerived().AlwaysRebuild() && Field == E->getField()) 7687 return SemaRef.Owned(E); 7688 7689 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field); 7690} 7691 7692template<typename Derived> 7693ExprResult 7694TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 7695 CXXScalarValueInitExpr *E) { 7696 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 7697 if (!T) 7698 return ExprError(); 7699 7700 if (!getDerived().AlwaysRebuild() && 7701 T == E->getTypeSourceInfo()) 7702 return SemaRef.Owned(E); 7703 7704 return getDerived().RebuildCXXScalarValueInitExpr(T, 7705 /*FIXME:*/T->getTypeLoc().getEndLoc(), 7706 E->getRParenLoc()); 7707} 7708 7709template<typename Derived> 7710ExprResult 7711TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 7712 // Transform the type that we're allocating 7713 TypeSourceInfo *AllocTypeInfo 7714 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 7715 if (!AllocTypeInfo) 7716 return ExprError(); 7717 7718 // Transform the size of the array we're allocating (if any). 7719 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 7720 if (ArraySize.isInvalid()) 7721 return ExprError(); 7722 7723 // Transform the placement arguments (if any). 7724 bool ArgumentChanged = false; 7725 SmallVector<Expr*, 8> PlacementArgs; 7726 if (getDerived().TransformExprs(E->getPlacementArgs(), 7727 E->getNumPlacementArgs(), true, 7728 PlacementArgs, &ArgumentChanged)) 7729 return ExprError(); 7730 7731 // Transform the initializer (if any). 7732 Expr *OldInit = E->getInitializer(); 7733 ExprResult NewInit; 7734 if (OldInit) 7735 NewInit = getDerived().TransformExpr(OldInit); 7736 if (NewInit.isInvalid()) 7737 return ExprError(); 7738 7739 // Transform new operator and delete operator. 7740 FunctionDecl *OperatorNew = nullptr; 7741 if (E->getOperatorNew()) { 7742 OperatorNew = cast_or_null<FunctionDecl>( 7743 getDerived().TransformDecl(E->getLocStart(), 7744 E->getOperatorNew())); 7745 if (!OperatorNew) 7746 return ExprError(); 7747 } 7748 7749 FunctionDecl *OperatorDelete = nullptr; 7750 if (E->getOperatorDelete()) { 7751 OperatorDelete = cast_or_null<FunctionDecl>( 7752 getDerived().TransformDecl(E->getLocStart(), 7753 E->getOperatorDelete())); 7754 if (!OperatorDelete) 7755 return ExprError(); 7756 } 7757 7758 if (!getDerived().AlwaysRebuild() && 7759 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 7760 ArraySize.get() == E->getArraySize() && 7761 NewInit.get() == OldInit && 7762 OperatorNew == E->getOperatorNew() && 7763 OperatorDelete == E->getOperatorDelete() && 7764 !ArgumentChanged) { 7765 // Mark any declarations we need as referenced. 7766 // FIXME: instantiation-specific. 7767 if (OperatorNew) 7768 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew); 7769 if (OperatorDelete) 7770 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 7771 7772 if (E->isArray() && !E->getAllocatedType()->isDependentType()) { 7773 QualType ElementType 7774 = SemaRef.Context.getBaseElementType(E->getAllocatedType()); 7775 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) { 7776 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl()); 7777 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) { 7778 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor); 7779 } 7780 } 7781 } 7782 7783 return SemaRef.Owned(E); 7784 } 7785 7786 QualType AllocType = AllocTypeInfo->getType(); 7787 if (!ArraySize.get()) { 7788 // If no array size was specified, but the new expression was 7789 // instantiated with an array type (e.g., "new T" where T is 7790 // instantiated with "int[4]"), extract the outer bound from the 7791 // array type as our array size. We do this with constant and 7792 // dependently-sized array types. 7793 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 7794 if (!ArrayT) { 7795 // Do nothing 7796 } else if (const ConstantArrayType *ConsArrayT 7797 = dyn_cast<ConstantArrayType>(ArrayT)) { 7798 ArraySize 7799 = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, 7800 ConsArrayT->getSize(), 7801 SemaRef.Context.getSizeType(), 7802 /*FIXME:*/E->getLocStart())); 7803 AllocType = ConsArrayT->getElementType(); 7804 } else if (const DependentSizedArrayType *DepArrayT 7805 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 7806 if (DepArrayT->getSizeExpr()) { 7807 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); 7808 AllocType = DepArrayT->getElementType(); 7809 } 7810 } 7811 } 7812 7813 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 7814 E->isGlobalNew(), 7815 /*FIXME:*/E->getLocStart(), 7816 PlacementArgs, 7817 /*FIXME:*/E->getLocStart(), 7818 E->getTypeIdParens(), 7819 AllocType, 7820 AllocTypeInfo, 7821 ArraySize.get(), 7822 E->getDirectInitRange(), 7823 NewInit.take()); 7824} 7825 7826template<typename Derived> 7827ExprResult 7828TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 7829 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 7830 if (Operand.isInvalid()) 7831 return ExprError(); 7832 7833 // Transform the delete operator, if known. 7834 FunctionDecl *OperatorDelete = nullptr; 7835 if (E->getOperatorDelete()) { 7836 OperatorDelete = cast_or_null<FunctionDecl>( 7837 getDerived().TransformDecl(E->getLocStart(), 7838 E->getOperatorDelete())); 7839 if (!OperatorDelete) 7840 return ExprError(); 7841 } 7842 7843 if (!getDerived().AlwaysRebuild() && 7844 Operand.get() == E->getArgument() && 7845 OperatorDelete == E->getOperatorDelete()) { 7846 // Mark any declarations we need as referenced. 7847 // FIXME: instantiation-specific. 7848 if (OperatorDelete) 7849 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 7850 7851 if (!E->getArgument()->isTypeDependent()) { 7852 QualType Destroyed = SemaRef.Context.getBaseElementType( 7853 E->getDestroyedType()); 7854 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 7855 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 7856 SemaRef.MarkFunctionReferenced(E->getLocStart(), 7857 SemaRef.LookupDestructor(Record)); 7858 } 7859 } 7860 7861 return SemaRef.Owned(E); 7862 } 7863 7864 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 7865 E->isGlobalDelete(), 7866 E->isArrayForm(), 7867 Operand.get()); 7868} 7869 7870template<typename Derived> 7871ExprResult 7872TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 7873 CXXPseudoDestructorExpr *E) { 7874 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7875 if (Base.isInvalid()) 7876 return ExprError(); 7877 7878 ParsedType ObjectTypePtr; 7879 bool MayBePseudoDestructor = false; 7880 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), 7881 E->getOperatorLoc(), 7882 E->isArrow()? tok::arrow : tok::period, 7883 ObjectTypePtr, 7884 MayBePseudoDestructor); 7885 if (Base.isInvalid()) 7886 return ExprError(); 7887 7888 QualType ObjectType = ObjectTypePtr.get(); 7889 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc(); 7890 if (QualifierLoc) { 7891 QualifierLoc 7892 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType); 7893 if (!QualifierLoc) 7894 return ExprError(); 7895 } 7896 CXXScopeSpec SS; 7897 SS.Adopt(QualifierLoc); 7898 7899 PseudoDestructorTypeStorage Destroyed; 7900 if (E->getDestroyedTypeInfo()) { 7901 TypeSourceInfo *DestroyedTypeInfo 7902 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 7903 ObjectType, nullptr, SS); 7904 if (!DestroyedTypeInfo) 7905 return ExprError(); 7906 Destroyed = DestroyedTypeInfo; 7907 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) { 7908 // We aren't likely to be able to resolve the identifier down to a type 7909 // now anyway, so just retain the identifier. 7910 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 7911 E->getDestroyedTypeLoc()); 7912 } else { 7913 // Look for a destructor known with the given name. 7914 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 7915 *E->getDestroyedTypeIdentifier(), 7916 E->getDestroyedTypeLoc(), 7917 /*Scope=*/nullptr, 7918 SS, ObjectTypePtr, 7919 false); 7920 if (!T) 7921 return ExprError(); 7922 7923 Destroyed 7924 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 7925 E->getDestroyedTypeLoc()); 7926 } 7927 7928 TypeSourceInfo *ScopeTypeInfo = nullptr; 7929 if (E->getScopeTypeInfo()) { 7930 CXXScopeSpec EmptySS; 7931 ScopeTypeInfo = getDerived().TransformTypeInObjectScope( 7932 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS); 7933 if (!ScopeTypeInfo) 7934 return ExprError(); 7935 } 7936 7937 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 7938 E->getOperatorLoc(), 7939 E->isArrow(), 7940 SS, 7941 ScopeTypeInfo, 7942 E->getColonColonLoc(), 7943 E->getTildeLoc(), 7944 Destroyed); 7945} 7946 7947template<typename Derived> 7948ExprResult 7949TreeTransform<Derived>::TransformUnresolvedLookupExpr( 7950 UnresolvedLookupExpr *Old) { 7951 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 7952 Sema::LookupOrdinaryName); 7953 7954 // Transform all the decls. 7955 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 7956 E = Old->decls_end(); I != E; ++I) { 7957 NamedDecl *InstD = static_cast<NamedDecl*>( 7958 getDerived().TransformDecl(Old->getNameLoc(), 7959 *I)); 7960 if (!InstD) { 7961 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 7962 // This can happen because of dependent hiding. 7963 if (isa<UsingShadowDecl>(*I)) 7964 continue; 7965 else { 7966 R.clear(); 7967 return ExprError(); 7968 } 7969 } 7970 7971 // Expand using declarations. 7972 if (isa<UsingDecl>(InstD)) { 7973 UsingDecl *UD = cast<UsingDecl>(InstD); 7974 for (auto *I : UD->shadows()) 7975 R.addDecl(I); 7976 continue; 7977 } 7978 7979 R.addDecl(InstD); 7980 } 7981 7982 // Resolve a kind, but don't do any further analysis. If it's 7983 // ambiguous, the callee needs to deal with it. 7984 R.resolveKind(); 7985 7986 // Rebuild the nested-name qualifier, if present. 7987 CXXScopeSpec SS; 7988 if (Old->getQualifierLoc()) { 7989 NestedNameSpecifierLoc QualifierLoc 7990 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 7991 if (!QualifierLoc) 7992 return ExprError(); 7993 7994 SS.Adopt(QualifierLoc); 7995 } 7996 7997 if (Old->getNamingClass()) { 7998 CXXRecordDecl *NamingClass 7999 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 8000 Old->getNameLoc(), 8001 Old->getNamingClass())); 8002 if (!NamingClass) { 8003 R.clear(); 8004 return ExprError(); 8005 } 8006 8007 R.setNamingClass(NamingClass); 8008 } 8009 8010 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 8011 8012 // If we have neither explicit template arguments, nor the template keyword, 8013 // it's a normal declaration name. 8014 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) 8015 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 8016 8017 // If we have template arguments, rebuild them, then rebuild the 8018 // templateid expression. 8019 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 8020 if (Old->hasExplicitTemplateArgs() && 8021 getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 8022 Old->getNumTemplateArgs(), 8023 TransArgs)) { 8024 R.clear(); 8025 return ExprError(); 8026 } 8027 8028 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R, 8029 Old->requiresADL(), &TransArgs); 8030} 8031 8032template<typename Derived> 8033ExprResult 8034TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { 8035 bool ArgChanged = false; 8036 SmallVector<TypeSourceInfo *, 4> Args; 8037 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 8038 TypeSourceInfo *From = E->getArg(I); 8039 TypeLoc FromTL = From->getTypeLoc(); 8040 if (!FromTL.getAs<PackExpansionTypeLoc>()) { 8041 TypeLocBuilder TLB; 8042 TLB.reserve(FromTL.getFullDataSize()); 8043 QualType To = getDerived().TransformType(TLB, FromTL); 8044 if (To.isNull()) 8045 return ExprError(); 8046 8047 if (To == From->getType()) 8048 Args.push_back(From); 8049 else { 8050 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8051 ArgChanged = true; 8052 } 8053 continue; 8054 } 8055 8056 ArgChanged = true; 8057 8058 // We have a pack expansion. Instantiate it. 8059 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>(); 8060 TypeLoc PatternTL = ExpansionTL.getPatternLoc(); 8061 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 8062 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded); 8063 8064 // Determine whether the set of unexpanded parameter packs can and should 8065 // be expanded. 8066 bool Expand = true; 8067 bool RetainExpansion = false; 8068 Optional<unsigned> OrigNumExpansions = 8069 ExpansionTL.getTypePtr()->getNumExpansions(); 8070 Optional<unsigned> NumExpansions = OrigNumExpansions; 8071 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 8072 PatternTL.getSourceRange(), 8073 Unexpanded, 8074 Expand, RetainExpansion, 8075 NumExpansions)) 8076 return ExprError(); 8077 8078 if (!Expand) { 8079 // The transform has determined that we should perform a simple 8080 // transformation on the pack expansion, producing another pack 8081 // expansion. 8082 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 8083 8084 TypeLocBuilder TLB; 8085 TLB.reserve(From->getTypeLoc().getFullDataSize()); 8086 8087 QualType To = getDerived().TransformType(TLB, PatternTL); 8088 if (To.isNull()) 8089 return ExprError(); 8090 8091 To = getDerived().RebuildPackExpansionType(To, 8092 PatternTL.getSourceRange(), 8093 ExpansionTL.getEllipsisLoc(), 8094 NumExpansions); 8095 if (To.isNull()) 8096 return ExprError(); 8097 8098 PackExpansionTypeLoc ToExpansionTL 8099 = TLB.push<PackExpansionTypeLoc>(To); 8100 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8101 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8102 continue; 8103 } 8104 8105 // Expand the pack expansion by substituting for each argument in the 8106 // pack(s). 8107 for (unsigned I = 0; I != *NumExpansions; ++I) { 8108 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 8109 TypeLocBuilder TLB; 8110 TLB.reserve(PatternTL.getFullDataSize()); 8111 QualType To = getDerived().TransformType(TLB, PatternTL); 8112 if (To.isNull()) 8113 return ExprError(); 8114 8115 if (To->containsUnexpandedParameterPack()) { 8116 To = getDerived().RebuildPackExpansionType(To, 8117 PatternTL.getSourceRange(), 8118 ExpansionTL.getEllipsisLoc(), 8119 NumExpansions); 8120 if (To.isNull()) 8121 return ExprError(); 8122 8123 PackExpansionTypeLoc ToExpansionTL 8124 = TLB.push<PackExpansionTypeLoc>(To); 8125 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8126 } 8127 8128 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8129 } 8130 8131 if (!RetainExpansion) 8132 continue; 8133 8134 // If we're supposed to retain a pack expansion, do so by temporarily 8135 // forgetting the partially-substituted parameter pack. 8136 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 8137 8138 TypeLocBuilder TLB; 8139 TLB.reserve(From->getTypeLoc().getFullDataSize()); 8140 8141 QualType To = getDerived().TransformType(TLB, PatternTL); 8142 if (To.isNull()) 8143 return ExprError(); 8144 8145 To = getDerived().RebuildPackExpansionType(To, 8146 PatternTL.getSourceRange(), 8147 ExpansionTL.getEllipsisLoc(), 8148 NumExpansions); 8149 if (To.isNull()) 8150 return ExprError(); 8151 8152 PackExpansionTypeLoc ToExpansionTL 8153 = TLB.push<PackExpansionTypeLoc>(To); 8154 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8155 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8156 } 8157 8158 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8159 return SemaRef.Owned(E); 8160 8161 return getDerived().RebuildTypeTrait(E->getTrait(), 8162 E->getLocStart(), 8163 Args, 8164 E->getLocEnd()); 8165} 8166 8167template<typename Derived> 8168ExprResult 8169TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 8170 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 8171 if (!T) 8172 return ExprError(); 8173 8174 if (!getDerived().AlwaysRebuild() && 8175 T == E->getQueriedTypeSourceInfo()) 8176 return SemaRef.Owned(E); 8177 8178 ExprResult SubExpr; 8179 { 8180 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8181 SubExpr = getDerived().TransformExpr(E->getDimensionExpression()); 8182 if (SubExpr.isInvalid()) 8183 return ExprError(); 8184 8185 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression()) 8186 return SemaRef.Owned(E); 8187 } 8188 8189 return getDerived().RebuildArrayTypeTrait(E->getTrait(), 8190 E->getLocStart(), 8191 T, 8192 SubExpr.get(), 8193 E->getLocEnd()); 8194} 8195 8196template<typename Derived> 8197ExprResult 8198TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { 8199 ExprResult SubExpr; 8200 { 8201 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8202 SubExpr = getDerived().TransformExpr(E->getQueriedExpression()); 8203 if (SubExpr.isInvalid()) 8204 return ExprError(); 8205 8206 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) 8207 return SemaRef.Owned(E); 8208 } 8209 8210 return getDerived().RebuildExpressionTrait( 8211 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd()); 8212} 8213 8214template<typename Derived> 8215ExprResult 8216TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 8217 DependentScopeDeclRefExpr *E) { 8218 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand*/false); 8219} 8220 8221template<typename Derived> 8222ExprResult 8223TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 8224 DependentScopeDeclRefExpr *E, 8225 bool IsAddressOfOperand) { 8226 assert(E->getQualifierLoc()); 8227 NestedNameSpecifierLoc QualifierLoc 8228 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 8229 if (!QualifierLoc) 8230 return ExprError(); 8231 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 8232 8233 // TODO: If this is a conversion-function-id, verify that the 8234 // destination type name (if present) resolves the same way after 8235 // instantiation as it did in the local scope. 8236 8237 DeclarationNameInfo NameInfo 8238 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 8239 if (!NameInfo.getName()) 8240 return ExprError(); 8241 8242 if (!E->hasExplicitTemplateArgs()) { 8243 if (!getDerived().AlwaysRebuild() && 8244 QualifierLoc == E->getQualifierLoc() && 8245 // Note: it is sufficient to compare the Name component of NameInfo: 8246 // if name has not changed, DNLoc has not changed either. 8247 NameInfo.getName() == E->getDeclName()) 8248 return SemaRef.Owned(E); 8249 8250 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 8251 TemplateKWLoc, 8252 NameInfo, 8253 /*TemplateArgs*/nullptr, 8254 IsAddressOfOperand); 8255 } 8256 8257 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 8258 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 8259 E->getNumTemplateArgs(), 8260 TransArgs)) 8261 return ExprError(); 8262 8263 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 8264 TemplateKWLoc, 8265 NameInfo, 8266 &TransArgs, 8267 IsAddressOfOperand); 8268} 8269 8270template<typename Derived> 8271ExprResult 8272TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 8273 // CXXConstructExprs other than for list-initialization and 8274 // CXXTemporaryObjectExpr are always implicit, so when we have 8275 // a 1-argument construction we just transform that argument. 8276 if ((E->getNumArgs() == 1 || 8277 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) && 8278 (!getDerived().DropCallArgument(E->getArg(0))) && 8279 !E->isListInitialization()) 8280 return getDerived().TransformExpr(E->getArg(0)); 8281 8282 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 8283 8284 QualType T = getDerived().TransformType(E->getType()); 8285 if (T.isNull()) 8286 return ExprError(); 8287 8288 CXXConstructorDecl *Constructor 8289 = cast_or_null<CXXConstructorDecl>( 8290 getDerived().TransformDecl(E->getLocStart(), 8291 E->getConstructor())); 8292 if (!Constructor) 8293 return ExprError(); 8294 8295 bool ArgumentChanged = false; 8296 SmallVector<Expr*, 8> Args; 8297 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 8298 &ArgumentChanged)) 8299 return ExprError(); 8300 8301 if (!getDerived().AlwaysRebuild() && 8302 T == E->getType() && 8303 Constructor == E->getConstructor() && 8304 !ArgumentChanged) { 8305 // Mark the constructor as referenced. 8306 // FIXME: Instantiation-specific 8307 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 8308 return SemaRef.Owned(E); 8309 } 8310 8311 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 8312 Constructor, E->isElidable(), 8313 Args, 8314 E->hadMultipleCandidates(), 8315 E->isListInitialization(), 8316 E->requiresZeroInitialization(), 8317 E->getConstructionKind(), 8318 E->getParenOrBraceRange()); 8319} 8320 8321/// \brief Transform a C++ temporary-binding expression. 8322/// 8323/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 8324/// transform the subexpression and return that. 8325template<typename Derived> 8326ExprResult 8327TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 8328 return getDerived().TransformExpr(E->getSubExpr()); 8329} 8330 8331/// \brief Transform a C++ expression that contains cleanups that should 8332/// be run after the expression is evaluated. 8333/// 8334/// Since ExprWithCleanups nodes are implicitly generated, we 8335/// just transform the subexpression and return that. 8336template<typename Derived> 8337ExprResult 8338TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 8339 return getDerived().TransformExpr(E->getSubExpr()); 8340} 8341 8342template<typename Derived> 8343ExprResult 8344TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 8345 CXXTemporaryObjectExpr *E) { 8346 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8347 if (!T) 8348 return ExprError(); 8349 8350 CXXConstructorDecl *Constructor 8351 = cast_or_null<CXXConstructorDecl>( 8352 getDerived().TransformDecl(E->getLocStart(), 8353 E->getConstructor())); 8354 if (!Constructor) 8355 return ExprError(); 8356 8357 bool ArgumentChanged = false; 8358 SmallVector<Expr*, 8> Args; 8359 Args.reserve(E->getNumArgs()); 8360 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 8361 &ArgumentChanged)) 8362 return ExprError(); 8363 8364 if (!getDerived().AlwaysRebuild() && 8365 T == E->getTypeSourceInfo() && 8366 Constructor == E->getConstructor() && 8367 !ArgumentChanged) { 8368 // FIXME: Instantiation-specific 8369 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 8370 return SemaRef.MaybeBindToTemporary(E); 8371 } 8372 8373 // FIXME: Pass in E->isListInitialization(). 8374 return getDerived().RebuildCXXTemporaryObjectExpr(T, 8375 /*FIXME:*/T->getTypeLoc().getEndLoc(), 8376 Args, 8377 E->getLocEnd()); 8378} 8379 8380template<typename Derived> 8381ExprResult 8382TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { 8383 8384 // Transform any init-capture expressions before entering the scope of the 8385 // lambda body, because they are not semantically within that scope. 8386 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes; 8387 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() - 8388 E->explicit_capture_begin()); 8389 8390 for (LambdaExpr::capture_iterator C = E->capture_begin(), 8391 CEnd = E->capture_end(); 8392 C != CEnd; ++C) { 8393 if (!C->isInitCapture()) 8394 continue; 8395 EnterExpressionEvaluationContext EEEC(getSema(), 8396 Sema::PotentiallyEvaluated); 8397 ExprResult NewExprInitResult = getDerived().TransformInitializer( 8398 C->getCapturedVar()->getInit(), 8399 C->getCapturedVar()->getInitStyle() == VarDecl::CallInit); 8400 8401 if (NewExprInitResult.isInvalid()) 8402 return ExprError(); 8403 Expr *NewExprInit = NewExprInitResult.get(); 8404 8405 VarDecl *OldVD = C->getCapturedVar(); 8406 QualType NewInitCaptureType = 8407 getSema().performLambdaInitCaptureInitialization(C->getLocation(), 8408 OldVD->getType()->isReferenceType(), OldVD->getIdentifier(), 8409 NewExprInit); 8410 NewExprInitResult = NewExprInit; 8411 InitCaptureExprsAndTypes[C - E->capture_begin()] = 8412 std::make_pair(NewExprInitResult, NewInitCaptureType); 8413 8414 } 8415 8416 LambdaScopeInfo *LSI = getSema().PushLambdaScope(); 8417 // Transform the template parameters, and add them to the current 8418 // instantiation scope. The null case is handled correctly. 8419 LSI->GLTemplateParameterList = getDerived().TransformTemplateParameterList( 8420 E->getTemplateParameterList()); 8421 8422 // Check to see if the TypeSourceInfo of the call operator needs to 8423 // be transformed, and if so do the transformation in the 8424 // CurrentInstantiationScope. 8425 8426 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo(); 8427 FunctionProtoTypeLoc OldCallOpFPTL = 8428 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); 8429 TypeSourceInfo *NewCallOpTSI = nullptr; 8430 8431 const bool CallOpWasAlreadyTransformed = 8432 getDerived().AlreadyTransformed(OldCallOpTSI->getType()); 8433 8434 // Use the Old Call Operator's TypeSourceInfo if it is already transformed. 8435 if (CallOpWasAlreadyTransformed) 8436 NewCallOpTSI = OldCallOpTSI; 8437 else { 8438 // Transform the TypeSourceInfo of the Original Lambda's Call Operator. 8439 // The transformation MUST be done in the CurrentInstantiationScope since 8440 // it introduces a mapping of the original to the newly created 8441 // transformed parameters. 8442 8443 TypeLocBuilder NewCallOpTLBuilder; 8444 QualType NewCallOpType = TransformFunctionProtoType(NewCallOpTLBuilder, 8445 OldCallOpFPTL, 8446 nullptr, 0); 8447 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, 8448 NewCallOpType); 8449 } 8450 // Extract the ParmVarDecls from the NewCallOpTSI and add them to 8451 // the vector below - this will be used to synthesize the 8452 // NewCallOperator. Additionally, add the parameters of the untransformed 8453 // lambda call operator to the CurrentInstantiationScope. 8454 SmallVector<ParmVarDecl *, 4> Params; 8455 { 8456 FunctionProtoTypeLoc NewCallOpFPTL = 8457 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>(); 8458 ParmVarDecl **NewParamDeclArray = NewCallOpFPTL.getParmArray(); 8459 const unsigned NewNumArgs = NewCallOpFPTL.getNumParams(); 8460 8461 for (unsigned I = 0; I < NewNumArgs; ++I) { 8462 // If this call operator's type does not require transformation, 8463 // the parameters do not get added to the current instantiation scope, 8464 // - so ADD them! This allows the following to compile when the enclosing 8465 // template is specialized and the entire lambda expression has to be 8466 // transformed. 8467 // template<class T> void foo(T t) { 8468 // auto L = [](auto a) { 8469 // auto M = [](char b) { <-- note: non-generic lambda 8470 // auto N = [](auto c) { 8471 // int x = sizeof(a); 8472 // x = sizeof(b); <-- specifically this line 8473 // x = sizeof(c); 8474 // }; 8475 // }; 8476 // }; 8477 // } 8478 // foo('a') 8479 if (CallOpWasAlreadyTransformed) 8480 getDerived().transformedLocalDecl(NewParamDeclArray[I], 8481 NewParamDeclArray[I]); 8482 // Add to Params array, so these parameters can be used to create 8483 // the newly transformed call operator. 8484 Params.push_back(NewParamDeclArray[I]); 8485 } 8486 } 8487 8488 if (!NewCallOpTSI) 8489 return ExprError(); 8490 8491 // Create the local class that will describe the lambda. 8492 CXXRecordDecl *Class 8493 = getSema().createLambdaClosureType(E->getIntroducerRange(), 8494 NewCallOpTSI, 8495 /*KnownDependent=*/false, 8496 E->getCaptureDefault()); 8497 8498 getDerived().transformedLocalDecl(E->getLambdaClass(), Class); 8499 8500 // Build the call operator. 8501 CXXMethodDecl *NewCallOperator 8502 = getSema().startLambdaDefinition(Class, E->getIntroducerRange(), 8503 NewCallOpTSI, 8504 E->getCallOperator()->getLocEnd(), 8505 Params); 8506 LSI->CallOperator = NewCallOperator; 8507 8508 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator); 8509 8510 return getDerived().TransformLambdaScope(E, NewCallOperator, 8511 InitCaptureExprsAndTypes); 8512} 8513 8514template<typename Derived> 8515ExprResult 8516TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, 8517 CXXMethodDecl *CallOperator, 8518 ArrayRef<InitCaptureInfoTy> InitCaptureExprsAndTypes) { 8519 bool Invalid = false; 8520 8521 // Introduce the context of the call operator. 8522 Sema::ContextRAII SavedContext(getSema(), CallOperator, 8523 /*NewThisContext*/false); 8524 8525 LambdaScopeInfo *const LSI = getSema().getCurLambda(); 8526 // Enter the scope of the lambda. 8527 getSema().buildLambdaScope(LSI, CallOperator, E->getIntroducerRange(), 8528 E->getCaptureDefault(), 8529 E->getCaptureDefaultLoc(), 8530 E->hasExplicitParameters(), 8531 E->hasExplicitResultType(), 8532 E->isMutable()); 8533 8534 // Transform captures. 8535 bool FinishedExplicitCaptures = false; 8536 for (LambdaExpr::capture_iterator C = E->capture_begin(), 8537 CEnd = E->capture_end(); 8538 C != CEnd; ++C) { 8539 // When we hit the first implicit capture, tell Sema that we've finished 8540 // the list of explicit captures. 8541 if (!FinishedExplicitCaptures && C->isImplicit()) { 8542 getSema().finishLambdaExplicitCaptures(LSI); 8543 FinishedExplicitCaptures = true; 8544 } 8545 8546 // Capturing 'this' is trivial. 8547 if (C->capturesThis()) { 8548 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit()); 8549 continue; 8550 } 8551 8552 // Rebuild init-captures, including the implied field declaration. 8553 if (C->isInitCapture()) { 8554 8555 InitCaptureInfoTy InitExprTypePair = 8556 InitCaptureExprsAndTypes[C - E->capture_begin()]; 8557 ExprResult Init = InitExprTypePair.first; 8558 QualType InitQualType = InitExprTypePair.second; 8559 if (Init.isInvalid() || InitQualType.isNull()) { 8560 Invalid = true; 8561 continue; 8562 } 8563 VarDecl *OldVD = C->getCapturedVar(); 8564 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl( 8565 OldVD->getLocation(), InitExprTypePair.second, 8566 OldVD->getIdentifier(), Init.get()); 8567 if (!NewVD) 8568 Invalid = true; 8569 else { 8570 getDerived().transformedLocalDecl(OldVD, NewVD); 8571 } 8572 getSema().buildInitCaptureField(LSI, NewVD); 8573 continue; 8574 } 8575 8576 assert(C->capturesVariable() && "unexpected kind of lambda capture"); 8577 8578 // Determine the capture kind for Sema. 8579 Sema::TryCaptureKind Kind 8580 = C->isImplicit()? Sema::TryCapture_Implicit 8581 : C->getCaptureKind() == LCK_ByCopy 8582 ? Sema::TryCapture_ExplicitByVal 8583 : Sema::TryCapture_ExplicitByRef; 8584 SourceLocation EllipsisLoc; 8585 if (C->isPackExpansion()) { 8586 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); 8587 bool ShouldExpand = false; 8588 bool RetainExpansion = false; 8589 Optional<unsigned> NumExpansions; 8590 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), 8591 C->getLocation(), 8592 Unexpanded, 8593 ShouldExpand, RetainExpansion, 8594 NumExpansions)) { 8595 Invalid = true; 8596 continue; 8597 } 8598 8599 if (ShouldExpand) { 8600 // The transform has determined that we should perform an expansion; 8601 // transform and capture each of the arguments. 8602 // expansion of the pattern. Do so. 8603 VarDecl *Pack = C->getCapturedVar(); 8604 for (unsigned I = 0; I != *NumExpansions; ++I) { 8605 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 8606 VarDecl *CapturedVar 8607 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8608 Pack)); 8609 if (!CapturedVar) { 8610 Invalid = true; 8611 continue; 8612 } 8613 8614 // Capture the transformed variable. 8615 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8616 } 8617 continue; 8618 } 8619 8620 EllipsisLoc = C->getEllipsisLoc(); 8621 } 8622 8623 // Transform the captured variable. 8624 VarDecl *CapturedVar 8625 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8626 C->getCapturedVar())); 8627 if (!CapturedVar) { 8628 Invalid = true; 8629 continue; 8630 } 8631 8632 // Capture the transformed variable. 8633 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8634 } 8635 if (!FinishedExplicitCaptures) 8636 getSema().finishLambdaExplicitCaptures(LSI); 8637 8638 8639 // Enter a new evaluation context to insulate the lambda from any 8640 // cleanups from the enclosing full-expression. 8641 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 8642 8643 if (Invalid) { 8644 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, 8645 /*IsInstantiation=*/true); 8646 return ExprError(); 8647 } 8648 8649 // Instantiate the body of the lambda expression. 8650 StmtResult Body = getDerived().TransformStmt(E->getBody()); 8651 if (Body.isInvalid()) { 8652 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, 8653 /*IsInstantiation=*/true); 8654 return ExprError(); 8655 } 8656 8657 return getSema().ActOnLambdaExpr(E->getLocStart(), Body.take(), 8658 /*CurScope=*/nullptr, 8659 /*IsInstantiation=*/true); 8660} 8661 8662template<typename Derived> 8663ExprResult 8664TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 8665 CXXUnresolvedConstructExpr *E) { 8666 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8667 if (!T) 8668 return ExprError(); 8669 8670 bool ArgumentChanged = false; 8671 SmallVector<Expr*, 8> Args; 8672 Args.reserve(E->arg_size()); 8673 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 8674 &ArgumentChanged)) 8675 return ExprError(); 8676 8677 if (!getDerived().AlwaysRebuild() && 8678 T == E->getTypeSourceInfo() && 8679 !ArgumentChanged) 8680 return SemaRef.Owned(E); 8681 8682 // FIXME: we're faking the locations of the commas 8683 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 8684 E->getLParenLoc(), 8685 Args, 8686 E->getRParenLoc()); 8687} 8688 8689template<typename Derived> 8690ExprResult 8691TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 8692 CXXDependentScopeMemberExpr *E) { 8693 // Transform the base of the expression. 8694 ExprResult Base((Expr*) nullptr); 8695 Expr *OldBase; 8696 QualType BaseType; 8697 QualType ObjectType; 8698 if (!E->isImplicitAccess()) { 8699 OldBase = E->getBase(); 8700 Base = getDerived().TransformExpr(OldBase); 8701 if (Base.isInvalid()) 8702 return ExprError(); 8703 8704 // Start the member reference and compute the object's type. 8705 ParsedType ObjectTy; 8706 bool MayBePseudoDestructor = false; 8707 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), 8708 E->getOperatorLoc(), 8709 E->isArrow()? tok::arrow : tok::period, 8710 ObjectTy, 8711 MayBePseudoDestructor); 8712 if (Base.isInvalid()) 8713 return ExprError(); 8714 8715 ObjectType = ObjectTy.get(); 8716 BaseType = ((Expr*) Base.get())->getType(); 8717 } else { 8718 OldBase = nullptr; 8719 BaseType = getDerived().TransformType(E->getBaseType()); 8720 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 8721 } 8722 8723 // Transform the first part of the nested-name-specifier that qualifies 8724 // the member name. 8725 NamedDecl *FirstQualifierInScope 8726 = getDerived().TransformFirstQualifierInScope( 8727 E->getFirstQualifierFoundInScope(), 8728 E->getQualifierLoc().getBeginLoc()); 8729 8730 NestedNameSpecifierLoc QualifierLoc; 8731 if (E->getQualifier()) { 8732 QualifierLoc 8733 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 8734 ObjectType, 8735 FirstQualifierInScope); 8736 if (!QualifierLoc) 8737 return ExprError(); 8738 } 8739 8740 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 8741 8742 // TODO: If this is a conversion-function-id, verify that the 8743 // destination type name (if present) resolves the same way after 8744 // instantiation as it did in the local scope. 8745 8746 DeclarationNameInfo NameInfo 8747 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 8748 if (!NameInfo.getName()) 8749 return ExprError(); 8750 8751 if (!E->hasExplicitTemplateArgs()) { 8752 // This is a reference to a member without an explicitly-specified 8753 // template argument list. Optimize for this common case. 8754 if (!getDerived().AlwaysRebuild() && 8755 Base.get() == OldBase && 8756 BaseType == E->getBaseType() && 8757 QualifierLoc == E->getQualifierLoc() && 8758 NameInfo.getName() == E->getMember() && 8759 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 8760 return SemaRef.Owned(E); 8761 8762 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8763 BaseType, 8764 E->isArrow(), 8765 E->getOperatorLoc(), 8766 QualifierLoc, 8767 TemplateKWLoc, 8768 FirstQualifierInScope, 8769 NameInfo, 8770 /*TemplateArgs*/nullptr); 8771 } 8772 8773 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 8774 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 8775 E->getNumTemplateArgs(), 8776 TransArgs)) 8777 return ExprError(); 8778 8779 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8780 BaseType, 8781 E->isArrow(), 8782 E->getOperatorLoc(), 8783 QualifierLoc, 8784 TemplateKWLoc, 8785 FirstQualifierInScope, 8786 NameInfo, 8787 &TransArgs); 8788} 8789 8790template<typename Derived> 8791ExprResult 8792TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 8793 // Transform the base of the expression. 8794 ExprResult Base((Expr*) nullptr); 8795 QualType BaseType; 8796 if (!Old->isImplicitAccess()) { 8797 Base = getDerived().TransformExpr(Old->getBase()); 8798 if (Base.isInvalid()) 8799 return ExprError(); 8800 Base = getSema().PerformMemberExprBaseConversion(Base.take(), 8801 Old->isArrow()); 8802 if (Base.isInvalid()) 8803 return ExprError(); 8804 BaseType = Base.get()->getType(); 8805 } else { 8806 BaseType = getDerived().TransformType(Old->getBaseType()); 8807 } 8808 8809 NestedNameSpecifierLoc QualifierLoc; 8810 if (Old->getQualifierLoc()) { 8811 QualifierLoc 8812 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 8813 if (!QualifierLoc) 8814 return ExprError(); 8815 } 8816 8817 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 8818 8819 LookupResult R(SemaRef, Old->getMemberNameInfo(), 8820 Sema::LookupOrdinaryName); 8821 8822 // Transform all the decls. 8823 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 8824 E = Old->decls_end(); I != E; ++I) { 8825 NamedDecl *InstD = static_cast<NamedDecl*>( 8826 getDerived().TransformDecl(Old->getMemberLoc(), 8827 *I)); 8828 if (!InstD) { 8829 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 8830 // This can happen because of dependent hiding. 8831 if (isa<UsingShadowDecl>(*I)) 8832 continue; 8833 else { 8834 R.clear(); 8835 return ExprError(); 8836 } 8837 } 8838 8839 // Expand using declarations. 8840 if (isa<UsingDecl>(InstD)) { 8841 UsingDecl *UD = cast<UsingDecl>(InstD); 8842 for (auto *I : UD->shadows()) 8843 R.addDecl(I); 8844 continue; 8845 } 8846 8847 R.addDecl(InstD); 8848 } 8849 8850 R.resolveKind(); 8851 8852 // Determine the naming class. 8853 if (Old->getNamingClass()) { 8854 CXXRecordDecl *NamingClass 8855 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 8856 Old->getMemberLoc(), 8857 Old->getNamingClass())); 8858 if (!NamingClass) 8859 return ExprError(); 8860 8861 R.setNamingClass(NamingClass); 8862 } 8863 8864 TemplateArgumentListInfo TransArgs; 8865 if (Old->hasExplicitTemplateArgs()) { 8866 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 8867 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 8868 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 8869 Old->getNumTemplateArgs(), 8870 TransArgs)) 8871 return ExprError(); 8872 } 8873 8874 // FIXME: to do this check properly, we will need to preserve the 8875 // first-qualifier-in-scope here, just in case we had a dependent 8876 // base (and therefore couldn't do the check) and a 8877 // nested-name-qualifier (and therefore could do the lookup). 8878 NamedDecl *FirstQualifierInScope = nullptr; 8879 8880 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 8881 BaseType, 8882 Old->getOperatorLoc(), 8883 Old->isArrow(), 8884 QualifierLoc, 8885 TemplateKWLoc, 8886 FirstQualifierInScope, 8887 R, 8888 (Old->hasExplicitTemplateArgs() 8889 ? &TransArgs : nullptr)); 8890} 8891 8892template<typename Derived> 8893ExprResult 8894TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 8895 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8896 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 8897 if (SubExpr.isInvalid()) 8898 return ExprError(); 8899 8900 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 8901 return SemaRef.Owned(E); 8902 8903 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 8904} 8905 8906template<typename Derived> 8907ExprResult 8908TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 8909 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 8910 if (Pattern.isInvalid()) 8911 return ExprError(); 8912 8913 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 8914 return SemaRef.Owned(E); 8915 8916 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 8917 E->getNumExpansions()); 8918} 8919 8920template<typename Derived> 8921ExprResult 8922TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 8923 // If E is not value-dependent, then nothing will change when we transform it. 8924 // Note: This is an instantiation-centric view. 8925 if (!E->isValueDependent()) 8926 return SemaRef.Owned(E); 8927 8928 // Note: None of the implementations of TryExpandParameterPacks can ever 8929 // produce a diagnostic when given only a single unexpanded parameter pack, 8930 // so 8931 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 8932 bool ShouldExpand = false; 8933 bool RetainExpansion = false; 8934 Optional<unsigned> NumExpansions; 8935 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 8936 Unexpanded, 8937 ShouldExpand, RetainExpansion, 8938 NumExpansions)) 8939 return ExprError(); 8940 8941 if (RetainExpansion) 8942 return SemaRef.Owned(E); 8943 8944 NamedDecl *Pack = E->getPack(); 8945 if (!ShouldExpand) { 8946 Pack = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getPackLoc(), 8947 Pack)); 8948 if (!Pack) 8949 return ExprError(); 8950 } 8951 8952 8953 // We now know the length of the parameter pack, so build a new expression 8954 // that stores that length. 8955 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, 8956 E->getPackLoc(), E->getRParenLoc(), 8957 NumExpansions); 8958} 8959 8960template<typename Derived> 8961ExprResult 8962TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 8963 SubstNonTypeTemplateParmPackExpr *E) { 8964 // Default behavior is to do nothing with this transformation. 8965 return SemaRef.Owned(E); 8966} 8967 8968template<typename Derived> 8969ExprResult 8970TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( 8971 SubstNonTypeTemplateParmExpr *E) { 8972 // Default behavior is to do nothing with this transformation. 8973 return SemaRef.Owned(E); 8974} 8975 8976template<typename Derived> 8977ExprResult 8978TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { 8979 // Default behavior is to do nothing with this transformation. 8980 return SemaRef.Owned(E); 8981} 8982 8983template<typename Derived> 8984ExprResult 8985TreeTransform<Derived>::TransformMaterializeTemporaryExpr( 8986 MaterializeTemporaryExpr *E) { 8987 return getDerived().TransformExpr(E->GetTemporaryExpr()); 8988} 8989 8990template<typename Derived> 8991ExprResult 8992TreeTransform<Derived>::TransformCXXStdInitializerListExpr( 8993 CXXStdInitializerListExpr *E) { 8994 return getDerived().TransformExpr(E->getSubExpr()); 8995} 8996 8997template<typename Derived> 8998ExprResult 8999TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 9000 return SemaRef.MaybeBindToTemporary(E); 9001} 9002 9003template<typename Derived> 9004ExprResult 9005TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 9006 return SemaRef.Owned(E); 9007} 9008 9009template<typename Derived> 9010ExprResult 9011TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { 9012 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 9013 if (SubExpr.isInvalid()) 9014 return ExprError(); 9015 9016 if (!getDerived().AlwaysRebuild() && 9017 SubExpr.get() == E->getSubExpr()) 9018 return SemaRef.Owned(E); 9019 9020 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); 9021} 9022 9023template<typename Derived> 9024ExprResult 9025TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) { 9026 // Transform each of the elements. 9027 SmallVector<Expr *, 8> Elements; 9028 bool ArgChanged = false; 9029 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(), 9030 /*IsCall=*/false, Elements, &ArgChanged)) 9031 return ExprError(); 9032 9033 if (!getDerived().AlwaysRebuild() && !ArgChanged) 9034 return SemaRef.MaybeBindToTemporary(E); 9035 9036 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(), 9037 Elements.data(), 9038 Elements.size()); 9039} 9040 9041template<typename Derived> 9042ExprResult 9043TreeTransform<Derived>::TransformObjCDictionaryLiteral( 9044 ObjCDictionaryLiteral *E) { 9045 // Transform each of the elements. 9046 SmallVector<ObjCDictionaryElement, 8> Elements; 9047 bool ArgChanged = false; 9048 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 9049 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I); 9050 9051 if (OrigElement.isPackExpansion()) { 9052 // This key/value element is a pack expansion. 9053 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 9054 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded); 9055 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded); 9056 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 9057 9058 // Determine whether the set of unexpanded parameter packs can 9059 // and should be expanded. 9060 bool Expand = true; 9061 bool RetainExpansion = false; 9062 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; 9063 Optional<unsigned> NumExpansions = OrigNumExpansions; 9064 SourceRange PatternRange(OrigElement.Key->getLocStart(), 9065 OrigElement.Value->getLocEnd()); 9066 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, 9067 PatternRange, 9068 Unexpanded, 9069 Expand, RetainExpansion, 9070 NumExpansions)) 9071 return ExprError(); 9072 9073 if (!Expand) { 9074 // The transform has determined that we should perform a simple 9075 // transformation on the pack expansion, producing another pack 9076 // expansion. 9077 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 9078 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9079 if (Key.isInvalid()) 9080 return ExprError(); 9081 9082 if (Key.get() != OrigElement.Key) 9083 ArgChanged = true; 9084 9085 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 9086 if (Value.isInvalid()) 9087 return ExprError(); 9088 9089 if (Value.get() != OrigElement.Value) 9090 ArgChanged = true; 9091 9092 ObjCDictionaryElement Expansion = { 9093 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions 9094 }; 9095 Elements.push_back(Expansion); 9096 continue; 9097 } 9098 9099 // Record right away that the argument was changed. This needs 9100 // to happen even if the array expands to nothing. 9101 ArgChanged = true; 9102 9103 // The transform has determined that we should perform an elementwise 9104 // expansion of the pattern. Do so. 9105 for (unsigned I = 0; I != *NumExpansions; ++I) { 9106 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 9107 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9108 if (Key.isInvalid()) 9109 return ExprError(); 9110 9111 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 9112 if (Value.isInvalid()) 9113 return ExprError(); 9114 9115 ObjCDictionaryElement Element = { 9116 Key.get(), Value.get(), SourceLocation(), NumExpansions 9117 }; 9118 9119 // If any unexpanded parameter packs remain, we still have a 9120 // pack expansion. 9121 if (Key.get()->containsUnexpandedParameterPack() || 9122 Value.get()->containsUnexpandedParameterPack()) 9123 Element.EllipsisLoc = OrigElement.EllipsisLoc; 9124 9125 Elements.push_back(Element); 9126 } 9127 9128 // We've finished with this pack expansion. 9129 continue; 9130 } 9131 9132 // Transform and check key. 9133 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9134 if (Key.isInvalid()) 9135 return ExprError(); 9136 9137 if (Key.get() != OrigElement.Key) 9138 ArgChanged = true; 9139 9140 // Transform and check value. 9141 ExprResult Value 9142 = getDerived().TransformExpr(OrigElement.Value); 9143 if (Value.isInvalid()) 9144 return ExprError(); 9145 9146 if (Value.get() != OrigElement.Value) 9147 ArgChanged = true; 9148 9149 ObjCDictionaryElement Element = { 9150 Key.get(), Value.get(), SourceLocation(), None 9151 }; 9152 Elements.push_back(Element); 9153 } 9154 9155 if (!getDerived().AlwaysRebuild() && !ArgChanged) 9156 return SemaRef.MaybeBindToTemporary(E); 9157 9158 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(), 9159 Elements.data(), 9160 Elements.size()); 9161} 9162 9163template<typename Derived> 9164ExprResult 9165TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 9166 TypeSourceInfo *EncodedTypeInfo 9167 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 9168 if (!EncodedTypeInfo) 9169 return ExprError(); 9170 9171 if (!getDerived().AlwaysRebuild() && 9172 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 9173 return SemaRef.Owned(E); 9174 9175 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 9176 EncodedTypeInfo, 9177 E->getRParenLoc()); 9178} 9179 9180template<typename Derived> 9181ExprResult TreeTransform<Derived>:: 9182TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 9183 // This is a kind of implicit conversion, and it needs to get dropped 9184 // and recomputed for the same general reasons that ImplicitCastExprs 9185 // do, as well a more specific one: this expression is only valid when 9186 // it appears *immediately* as an argument expression. 9187 return getDerived().TransformExpr(E->getSubExpr()); 9188} 9189 9190template<typename Derived> 9191ExprResult TreeTransform<Derived>:: 9192TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 9193 TypeSourceInfo *TSInfo 9194 = getDerived().TransformType(E->getTypeInfoAsWritten()); 9195 if (!TSInfo) 9196 return ExprError(); 9197 9198 ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); 9199 if (Result.isInvalid()) 9200 return ExprError(); 9201 9202 if (!getDerived().AlwaysRebuild() && 9203 TSInfo == E->getTypeInfoAsWritten() && 9204 Result.get() == E->getSubExpr()) 9205 return SemaRef.Owned(E); 9206 9207 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), 9208 E->getBridgeKeywordLoc(), TSInfo, 9209 Result.get()); 9210} 9211 9212template<typename Derived> 9213ExprResult 9214TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 9215 // Transform arguments. 9216 bool ArgChanged = false; 9217 SmallVector<Expr*, 8> Args; 9218 Args.reserve(E->getNumArgs()); 9219 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 9220 &ArgChanged)) 9221 return ExprError(); 9222 9223 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 9224 // Class message: transform the receiver type. 9225 TypeSourceInfo *ReceiverTypeInfo 9226 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 9227 if (!ReceiverTypeInfo) 9228 return ExprError(); 9229 9230 // If nothing changed, just retain the existing message send. 9231 if (!getDerived().AlwaysRebuild() && 9232 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 9233 return SemaRef.MaybeBindToTemporary(E); 9234 9235 // Build a new class message send. 9236 SmallVector<SourceLocation, 16> SelLocs; 9237 E->getSelectorLocs(SelLocs); 9238 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 9239 E->getSelector(), 9240 SelLocs, 9241 E->getMethodDecl(), 9242 E->getLeftLoc(), 9243 Args, 9244 E->getRightLoc()); 9245 } 9246 9247 // Instance message: transform the receiver 9248 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 9249 "Only class and instance messages may be instantiated"); 9250 ExprResult Receiver 9251 = getDerived().TransformExpr(E->getInstanceReceiver()); 9252 if (Receiver.isInvalid()) 9253 return ExprError(); 9254 9255 // If nothing changed, just retain the existing message send. 9256 if (!getDerived().AlwaysRebuild() && 9257 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 9258 return SemaRef.MaybeBindToTemporary(E); 9259 9260 // Build a new instance message send. 9261 SmallVector<SourceLocation, 16> SelLocs; 9262 E->getSelectorLocs(SelLocs); 9263 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 9264 E->getSelector(), 9265 SelLocs, 9266 E->getMethodDecl(), 9267 E->getLeftLoc(), 9268 Args, 9269 E->getRightLoc()); 9270} 9271 9272template<typename Derived> 9273ExprResult 9274TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 9275 return SemaRef.Owned(E); 9276} 9277 9278template<typename Derived> 9279ExprResult 9280TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 9281 return SemaRef.Owned(E); 9282} 9283 9284template<typename Derived> 9285ExprResult 9286TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 9287 // Transform the base expression. 9288 ExprResult Base = getDerived().TransformExpr(E->getBase()); 9289 if (Base.isInvalid()) 9290 return ExprError(); 9291 9292 // We don't need to transform the ivar; it will never change. 9293 9294 // If nothing changed, just retain the existing expression. 9295 if (!getDerived().AlwaysRebuild() && 9296 Base.get() == E->getBase()) 9297 return SemaRef.Owned(E); 9298 9299 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 9300 E->getLocation(), 9301 E->isArrow(), E->isFreeIvar()); 9302} 9303 9304template<typename Derived> 9305ExprResult 9306TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 9307 // 'super' and types never change. Property never changes. Just 9308 // retain the existing expression. 9309 if (!E->isObjectReceiver()) 9310 return SemaRef.Owned(E); 9311 9312 // Transform the base expression. 9313 ExprResult Base = getDerived().TransformExpr(E->getBase()); 9314 if (Base.isInvalid()) 9315 return ExprError(); 9316 9317 // We don't need to transform the property; it will never change. 9318 9319 // If nothing changed, just retain the existing expression. 9320 if (!getDerived().AlwaysRebuild() && 9321 Base.get() == E->getBase()) 9322 return SemaRef.Owned(E); 9323 9324 if (E->isExplicitProperty()) 9325 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 9326 E->getExplicitProperty(), 9327 E->getLocation()); 9328 9329 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 9330 SemaRef.Context.PseudoObjectTy, 9331 E->getImplicitPropertyGetter(), 9332 E->getImplicitPropertySetter(), 9333 E->getLocation()); 9334} 9335 9336template<typename Derived> 9337ExprResult 9338TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 9339 // Transform the base expression. 9340 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 9341 if (Base.isInvalid()) 9342 return ExprError(); 9343 9344 // Transform the key expression. 9345 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr()); 9346 if (Key.isInvalid()) 9347 return ExprError(); 9348 9349 // If nothing changed, just retain the existing expression. 9350 if (!getDerived().AlwaysRebuild() && 9351 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) 9352 return SemaRef.Owned(E); 9353 9354 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), 9355 Base.get(), Key.get(), 9356 E->getAtIndexMethodDecl(), 9357 E->setAtIndexMethodDecl()); 9358} 9359 9360template<typename Derived> 9361ExprResult 9362TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 9363 // Transform the base expression. 9364 ExprResult Base = getDerived().TransformExpr(E->getBase()); 9365 if (Base.isInvalid()) 9366 return ExprError(); 9367 9368 // If nothing changed, just retain the existing expression. 9369 if (!getDerived().AlwaysRebuild() && 9370 Base.get() == E->getBase()) 9371 return SemaRef.Owned(E); 9372 9373 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 9374 E->getOpLoc(), 9375 E->isArrow()); 9376} 9377 9378template<typename Derived> 9379ExprResult 9380TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 9381 bool ArgumentChanged = false; 9382 SmallVector<Expr*, 8> SubExprs; 9383 SubExprs.reserve(E->getNumSubExprs()); 9384 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 9385 SubExprs, &ArgumentChanged)) 9386 return ExprError(); 9387 9388 if (!getDerived().AlwaysRebuild() && 9389 !ArgumentChanged) 9390 return SemaRef.Owned(E); 9391 9392 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 9393 SubExprs, 9394 E->getRParenLoc()); 9395} 9396 9397template<typename Derived> 9398ExprResult 9399TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) { 9400 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr()); 9401 if (SrcExpr.isInvalid()) 9402 return ExprError(); 9403 9404 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 9405 if (!Type) 9406 return ExprError(); 9407 9408 if (!getDerived().AlwaysRebuild() && 9409 Type == E->getTypeSourceInfo() && 9410 SrcExpr.get() == E->getSrcExpr()) 9411 return SemaRef.Owned(E); 9412 9413 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(), 9414 SrcExpr.get(), Type, 9415 E->getRParenLoc()); 9416} 9417 9418template<typename Derived> 9419ExprResult 9420TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 9421 BlockDecl *oldBlock = E->getBlockDecl(); 9422 9423 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr); 9424 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 9425 9426 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 9427 blockScope->TheDecl->setBlockMissingReturnType( 9428 oldBlock->blockMissingReturnType()); 9429 9430 SmallVector<ParmVarDecl*, 4> params; 9431 SmallVector<QualType, 4> paramTypes; 9432 9433 // Parameter substitution. 9434 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 9435 oldBlock->param_begin(), 9436 oldBlock->param_size(), 9437 nullptr, paramTypes, ¶ms)) { 9438 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); 9439 return ExprError(); 9440 } 9441 9442 const FunctionProtoType *exprFunctionType = E->getFunctionType(); 9443 QualType exprResultType = 9444 getDerived().TransformType(exprFunctionType->getReturnType()); 9445 9446 QualType functionType = 9447 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, 9448 exprFunctionType->getExtProtoInfo()); 9449 blockScope->FunctionType = functionType; 9450 9451 // Set the parameters on the block decl. 9452 if (!params.empty()) 9453 blockScope->TheDecl->setParams(params); 9454 9455 if (!oldBlock->blockMissingReturnType()) { 9456 blockScope->HasImplicitReturnType = false; 9457 blockScope->ReturnType = exprResultType; 9458 } 9459 9460 // Transform the body 9461 StmtResult body = getDerived().TransformStmt(E->getBody()); 9462 if (body.isInvalid()) { 9463 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); 9464 return ExprError(); 9465 } 9466 9467#ifndef NDEBUG 9468 // In builds with assertions, make sure that we captured everything we 9469 // captured before. 9470 if (!SemaRef.getDiagnostics().hasErrorOccurred()) { 9471 for (const auto &I : oldBlock->captures()) { 9472 VarDecl *oldCapture = I.getVariable(); 9473 9474 // Ignore parameter packs. 9475 if (isa<ParmVarDecl>(oldCapture) && 9476 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 9477 continue; 9478 9479 VarDecl *newCapture = 9480 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 9481 oldCapture)); 9482 assert(blockScope->CaptureMap.count(newCapture)); 9483 } 9484 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()); 9485 } 9486#endif 9487 9488 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 9489 /*Scope=*/nullptr); 9490} 9491 9492template<typename Derived> 9493ExprResult 9494TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { 9495 llvm_unreachable("Cannot transform asType expressions yet"); 9496} 9497 9498template<typename Derived> 9499ExprResult 9500TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { 9501 QualType RetTy = getDerived().TransformType(E->getType()); 9502 bool ArgumentChanged = false; 9503 SmallVector<Expr*, 8> SubExprs; 9504 SubExprs.reserve(E->getNumSubExprs()); 9505 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 9506 SubExprs, &ArgumentChanged)) 9507 return ExprError(); 9508 9509 if (!getDerived().AlwaysRebuild() && 9510 !ArgumentChanged) 9511 return SemaRef.Owned(E); 9512 9513 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, 9514 RetTy, E->getOp(), E->getRParenLoc()); 9515} 9516 9517//===----------------------------------------------------------------------===// 9518// Type reconstruction 9519//===----------------------------------------------------------------------===// 9520 9521template<typename Derived> 9522QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 9523 SourceLocation Star) { 9524 return SemaRef.BuildPointerType(PointeeType, Star, 9525 getDerived().getBaseEntity()); 9526} 9527 9528template<typename Derived> 9529QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 9530 SourceLocation Star) { 9531 return SemaRef.BuildBlockPointerType(PointeeType, Star, 9532 getDerived().getBaseEntity()); 9533} 9534 9535template<typename Derived> 9536QualType 9537TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 9538 bool WrittenAsLValue, 9539 SourceLocation Sigil) { 9540 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 9541 Sigil, getDerived().getBaseEntity()); 9542} 9543 9544template<typename Derived> 9545QualType 9546TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 9547 QualType ClassType, 9548 SourceLocation Sigil) { 9549 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil, 9550 getDerived().getBaseEntity()); 9551} 9552 9553template<typename Derived> 9554QualType 9555TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 9556 ArrayType::ArraySizeModifier SizeMod, 9557 const llvm::APInt *Size, 9558 Expr *SizeExpr, 9559 unsigned IndexTypeQuals, 9560 SourceRange BracketsRange) { 9561 if (SizeExpr || !Size) 9562 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 9563 IndexTypeQuals, BracketsRange, 9564 getDerived().getBaseEntity()); 9565 9566 QualType Types[] = { 9567 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 9568 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 9569 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 9570 }; 9571 const unsigned NumTypes = llvm::array_lengthof(Types); 9572 QualType SizeType; 9573 for (unsigned I = 0; I != NumTypes; ++I) 9574 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 9575 SizeType = Types[I]; 9576 break; 9577 } 9578 9579 // Note that we can return a VariableArrayType here in the case where 9580 // the element type was a dependent VariableArrayType. 9581 IntegerLiteral *ArraySize 9582 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType, 9583 /*FIXME*/BracketsRange.getBegin()); 9584 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize, 9585 IndexTypeQuals, BracketsRange, 9586 getDerived().getBaseEntity()); 9587} 9588 9589template<typename Derived> 9590QualType 9591TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 9592 ArrayType::ArraySizeModifier SizeMod, 9593 const llvm::APInt &Size, 9594 unsigned IndexTypeQuals, 9595 SourceRange BracketsRange) { 9596 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr, 9597 IndexTypeQuals, BracketsRange); 9598} 9599 9600template<typename Derived> 9601QualType 9602TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 9603 ArrayType::ArraySizeModifier SizeMod, 9604 unsigned IndexTypeQuals, 9605 SourceRange BracketsRange) { 9606 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr, 9607 IndexTypeQuals, BracketsRange); 9608} 9609 9610template<typename Derived> 9611QualType 9612TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 9613 ArrayType::ArraySizeModifier SizeMod, 9614 Expr *SizeExpr, 9615 unsigned IndexTypeQuals, 9616 SourceRange BracketsRange) { 9617 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, 9618 SizeExpr, 9619 IndexTypeQuals, BracketsRange); 9620} 9621 9622template<typename Derived> 9623QualType 9624TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 9625 ArrayType::ArraySizeModifier SizeMod, 9626 Expr *SizeExpr, 9627 unsigned IndexTypeQuals, 9628 SourceRange BracketsRange) { 9629 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, 9630 SizeExpr, 9631 IndexTypeQuals, BracketsRange); 9632} 9633 9634template<typename Derived> 9635QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 9636 unsigned NumElements, 9637 VectorType::VectorKind VecKind) { 9638 // FIXME: semantic checking! 9639 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 9640} 9641 9642template<typename Derived> 9643QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 9644 unsigned NumElements, 9645 SourceLocation AttributeLoc) { 9646 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 9647 NumElements, true); 9648 IntegerLiteral *VectorSize 9649 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 9650 AttributeLoc); 9651 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 9652} 9653 9654template<typename Derived> 9655QualType 9656TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 9657 Expr *SizeExpr, 9658 SourceLocation AttributeLoc) { 9659 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 9660} 9661 9662template<typename Derived> 9663QualType TreeTransform<Derived>::RebuildFunctionProtoType( 9664 QualType T, 9665 llvm::MutableArrayRef<QualType> ParamTypes, 9666 const FunctionProtoType::ExtProtoInfo &EPI) { 9667 return SemaRef.BuildFunctionType(T, ParamTypes, 9668 getDerived().getBaseLocation(), 9669 getDerived().getBaseEntity(), 9670 EPI); 9671} 9672 9673template<typename Derived> 9674QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 9675 return SemaRef.Context.getFunctionNoProtoType(T); 9676} 9677 9678template<typename Derived> 9679QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 9680 assert(D && "no decl found"); 9681 if (D->isInvalidDecl()) return QualType(); 9682 9683 // FIXME: Doesn't account for ObjCInterfaceDecl! 9684 TypeDecl *Ty; 9685 if (isa<UsingDecl>(D)) { 9686 UsingDecl *Using = cast<UsingDecl>(D); 9687 assert(Using->hasTypename() && 9688 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 9689 9690 // A valid resolved using typename decl points to exactly one type decl. 9691 assert(++Using->shadow_begin() == Using->shadow_end()); 9692 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 9693 9694 } else { 9695 assert(isa<UnresolvedUsingTypenameDecl>(D) && 9696 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 9697 Ty = cast<UnresolvedUsingTypenameDecl>(D); 9698 } 9699 9700 return SemaRef.Context.getTypeDeclType(Ty); 9701} 9702 9703template<typename Derived> 9704QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 9705 SourceLocation Loc) { 9706 return SemaRef.BuildTypeofExprType(E, Loc); 9707} 9708 9709template<typename Derived> 9710QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 9711 return SemaRef.Context.getTypeOfType(Underlying); 9712} 9713 9714template<typename Derived> 9715QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 9716 SourceLocation Loc) { 9717 return SemaRef.BuildDecltypeType(E, Loc); 9718} 9719 9720template<typename Derived> 9721QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, 9722 UnaryTransformType::UTTKind UKind, 9723 SourceLocation Loc) { 9724 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); 9725} 9726 9727template<typename Derived> 9728QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 9729 TemplateName Template, 9730 SourceLocation TemplateNameLoc, 9731 TemplateArgumentListInfo &TemplateArgs) { 9732 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 9733} 9734 9735template<typename Derived> 9736QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType, 9737 SourceLocation KWLoc) { 9738 return SemaRef.BuildAtomicType(ValueType, KWLoc); 9739} 9740 9741template<typename Derived> 9742TemplateName 9743TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9744 bool TemplateKW, 9745 TemplateDecl *Template) { 9746 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 9747 Template); 9748} 9749 9750template<typename Derived> 9751TemplateName 9752TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9753 const IdentifierInfo &Name, 9754 SourceLocation NameLoc, 9755 QualType ObjectType, 9756 NamedDecl *FirstQualifierInScope) { 9757 UnqualifiedId TemplateName; 9758 TemplateName.setIdentifier(&Name, NameLoc); 9759 Sema::TemplateTy Template; 9760 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9761 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, 9762 SS, TemplateKWLoc, TemplateName, 9763 ParsedType::make(ObjectType), 9764 /*EnteringContext=*/false, 9765 Template); 9766 return Template.get(); 9767} 9768 9769template<typename Derived> 9770TemplateName 9771TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9772 OverloadedOperatorKind Operator, 9773 SourceLocation NameLoc, 9774 QualType ObjectType) { 9775 UnqualifiedId Name; 9776 // FIXME: Bogus location information. 9777 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 9778 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 9779 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9780 Sema::TemplateTy Template; 9781 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, 9782 SS, TemplateKWLoc, Name, 9783 ParsedType::make(ObjectType), 9784 /*EnteringContext=*/false, 9785 Template); 9786 return Template.get(); 9787} 9788 9789template<typename Derived> 9790ExprResult 9791TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 9792 SourceLocation OpLoc, 9793 Expr *OrigCallee, 9794 Expr *First, 9795 Expr *Second) { 9796 Expr *Callee = OrigCallee->IgnoreParenCasts(); 9797 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 9798 9799 // Determine whether this should be a builtin operation. 9800 if (Op == OO_Subscript) { 9801 if (!First->getType()->isOverloadableType() && 9802 !Second->getType()->isOverloadableType()) 9803 return getSema().CreateBuiltinArraySubscriptExpr(First, 9804 Callee->getLocStart(), 9805 Second, OpLoc); 9806 } else if (Op == OO_Arrow) { 9807 // -> is never a builtin operation. 9808 return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc); 9809 } else if (Second == nullptr || isPostIncDec) { 9810 if (!First->getType()->isOverloadableType()) { 9811 // The argument is not of overloadable type, so try to create a 9812 // built-in unary operation. 9813 UnaryOperatorKind Opc 9814 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9815 9816 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 9817 } 9818 } else { 9819 if (!First->getType()->isOverloadableType() && 9820 !Second->getType()->isOverloadableType()) { 9821 // Neither of the arguments is an overloadable type, so try to 9822 // create a built-in binary operation. 9823 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9824 ExprResult Result 9825 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 9826 if (Result.isInvalid()) 9827 return ExprError(); 9828 9829 return Result; 9830 } 9831 } 9832 9833 // Compute the transformed set of functions (and function templates) to be 9834 // used during overload resolution. 9835 UnresolvedSet<16> Functions; 9836 9837 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 9838 assert(ULE->requiresADL()); 9839 Functions.append(ULE->decls_begin(), ULE->decls_end()); 9840 } else { 9841 // If we've resolved this to a particular non-member function, just call 9842 // that function. If we resolved it to a member function, 9843 // CreateOverloaded* will find that function for us. 9844 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl(); 9845 if (!isa<CXXMethodDecl>(ND)) 9846 Functions.addDecl(ND); 9847 } 9848 9849 // Add any functions found via argument-dependent lookup. 9850 Expr *Args[2] = { First, Second }; 9851 unsigned NumArgs = 1 + (Second != nullptr); 9852 9853 // Create the overloaded operator invocation for unary operators. 9854 if (NumArgs == 1 || isPostIncDec) { 9855 UnaryOperatorKind Opc 9856 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9857 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 9858 } 9859 9860 if (Op == OO_Subscript) { 9861 SourceLocation LBrace; 9862 SourceLocation RBrace; 9863 9864 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { 9865 DeclarationNameLoc &NameLoc = DRE->getNameInfo().getInfo(); 9866 LBrace = SourceLocation::getFromRawEncoding( 9867 NameLoc.CXXOperatorName.BeginOpNameLoc); 9868 RBrace = SourceLocation::getFromRawEncoding( 9869 NameLoc.CXXOperatorName.EndOpNameLoc); 9870 } else { 9871 LBrace = Callee->getLocStart(); 9872 RBrace = OpLoc; 9873 } 9874 9875 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, 9876 First, Second); 9877 } 9878 9879 // Create the overloaded operator invocation for binary operators. 9880 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9881 ExprResult Result 9882 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 9883 if (Result.isInvalid()) 9884 return ExprError(); 9885 9886 return Result; 9887} 9888 9889template<typename Derived> 9890ExprResult 9891TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 9892 SourceLocation OperatorLoc, 9893 bool isArrow, 9894 CXXScopeSpec &SS, 9895 TypeSourceInfo *ScopeType, 9896 SourceLocation CCLoc, 9897 SourceLocation TildeLoc, 9898 PseudoDestructorTypeStorage Destroyed) { 9899 QualType BaseType = Base->getType(); 9900 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 9901 (!isArrow && !BaseType->getAs<RecordType>()) || 9902 (isArrow && BaseType->getAs<PointerType>() && 9903 !BaseType->getAs<PointerType>()->getPointeeType() 9904 ->template getAs<RecordType>())){ 9905 // This pseudo-destructor expression is still a pseudo-destructor. 9906 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 9907 isArrow? tok::arrow : tok::period, 9908 SS, ScopeType, CCLoc, TildeLoc, 9909 Destroyed, 9910 /*FIXME?*/true); 9911 } 9912 9913 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 9914 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 9915 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 9916 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 9917 NameInfo.setNamedTypeInfo(DestroyedType); 9918 9919 // The scope type is now known to be a valid nested name specifier 9920 // component. Tack it on to the end of the nested name specifier. 9921 if (ScopeType) 9922 SS.Extend(SemaRef.Context, SourceLocation(), 9923 ScopeType->getTypeLoc(), CCLoc); 9924 9925 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9926 return getSema().BuildMemberReferenceExpr(Base, BaseType, 9927 OperatorLoc, isArrow, 9928 SS, TemplateKWLoc, 9929 /*FIXME: FirstQualifier*/ nullptr, 9930 NameInfo, 9931 /*TemplateArgs*/ nullptr); 9932} 9933 9934template<typename Derived> 9935StmtResult 9936TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) { 9937 SourceLocation Loc = S->getLocStart(); 9938 CapturedDecl *CD = S->getCapturedDecl(); 9939 unsigned NumParams = CD->getNumParams(); 9940 unsigned ContextParamPos = CD->getContextParamPosition(); 9941 SmallVector<Sema::CapturedParamNameType, 4> Params; 9942 for (unsigned I = 0; I < NumParams; ++I) { 9943 if (I != ContextParamPos) { 9944 Params.push_back( 9945 std::make_pair( 9946 CD->getParam(I)->getName(), 9947 getDerived().TransformType(CD->getParam(I)->getType()))); 9948 } else { 9949 Params.push_back(std::make_pair(StringRef(), QualType())); 9950 } 9951 } 9952 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr, 9953 S->getCapturedRegionKind(), Params); 9954 StmtResult Body = getDerived().TransformStmt(S->getCapturedStmt()); 9955 9956 if (Body.isInvalid()) { 9957 getSema().ActOnCapturedRegionError(); 9958 return StmtError(); 9959 } 9960 9961 return getSema().ActOnCapturedRegionEnd(Body.take()); 9962} 9963 9964} // end namespace clang 9965 9966#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 9967