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