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 39 namespace clang { 40 using 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()). 93 template<typename Derived> 94 class 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 112 protected: 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 120 public: 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 instance/class message to 'super'. 2627 ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc, 2628 Selector Sel, 2629 ArrayRef<SourceLocation> SelectorLocs, 2630 ObjCMethodDecl *Method, 2631 SourceLocation LBracLoc, 2632 MultiExprArg Args, 2633 SourceLocation RBracLoc) { 2634 ObjCInterfaceDecl *Class = Method->getClassInterface(); 2635 QualType ReceiverTy = SemaRef.Context.getObjCInterfaceType(Class); 2636 2637 return Method->isInstanceMethod() ? SemaRef.BuildInstanceMessage(nullptr, 2638 ReceiverTy, 2639 SuperLoc, 2640 Sel, Method, LBracLoc, SelectorLocs, 2641 RBracLoc, Args) 2642 : SemaRef.BuildClassMessage(nullptr, 2643 ReceiverTy, 2644 SuperLoc, 2645 Sel, Method, LBracLoc, SelectorLocs, 2646 RBracLoc, Args); 2647 2648 2649 } 2650 2651 /// \brief Build a new Objective-C ivar reference expression. 2652 /// 2653 /// By default, performs semantic analysis to build the new expression. 2654 /// Subclasses may override this routine to provide different behavior. 2655 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar, 2656 SourceLocation IvarLoc, 2657 bool IsArrow, bool IsFreeIvar) { 2658 // FIXME: We lose track of the IsFreeIvar bit. 2659 CXXScopeSpec SS; 2660 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc); 2661 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), 2662 /*FIXME:*/IvarLoc, IsArrow, 2663 SS, SourceLocation(), 2664 /*FirstQualifierInScope=*/nullptr, 2665 NameInfo, 2666 /*TemplateArgs=*/nullptr); 2667 } 2668 2669 /// \brief Build a new Objective-C property reference expression. 2670 /// 2671 /// By default, performs semantic analysis to build the new expression. 2672 /// Subclasses may override this routine to provide different behavior. 2673 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg, 2674 ObjCPropertyDecl *Property, 2675 SourceLocation PropertyLoc) { 2676 CXXScopeSpec SS; 2677 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc); 2678 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), 2679 /*FIXME:*/PropertyLoc, 2680 /*IsArrow=*/false, 2681 SS, SourceLocation(), 2682 /*FirstQualifierInScope=*/nullptr, 2683 NameInfo, 2684 /*TemplateArgs=*/nullptr); 2685 } 2686 2687 /// \brief Build a new Objective-C property reference expression. 2688 /// 2689 /// By default, performs semantic analysis to build the new expression. 2690 /// Subclasses may override this routine to provide different behavior. 2691 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T, 2692 ObjCMethodDecl *Getter, 2693 ObjCMethodDecl *Setter, 2694 SourceLocation PropertyLoc) { 2695 // Since these expressions can only be value-dependent, we do not 2696 // need to perform semantic analysis again. 2697 return Owned( 2698 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T, 2699 VK_LValue, OK_ObjCProperty, 2700 PropertyLoc, Base)); 2701 } 2702 2703 /// \brief Build a new Objective-C "isa" expression. 2704 /// 2705 /// By default, performs semantic analysis to build the new expression. 2706 /// Subclasses may override this routine to provide different behavior. 2707 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc, 2708 SourceLocation OpLoc, bool IsArrow) { 2709 CXXScopeSpec SS; 2710 DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc); 2711 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(), 2712 OpLoc, IsArrow, 2713 SS, SourceLocation(), 2714 /*FirstQualifierInScope=*/nullptr, 2715 NameInfo, 2716 /*TemplateArgs=*/nullptr); 2717 } 2718 2719 /// \brief Build a new shuffle vector expression. 2720 /// 2721 /// By default, performs semantic analysis to build the new expression. 2722 /// Subclasses may override this routine to provide different behavior. 2723 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 2724 MultiExprArg SubExprs, 2725 SourceLocation RParenLoc) { 2726 // Find the declaration for __builtin_shufflevector 2727 const IdentifierInfo &Name 2728 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 2729 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 2730 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 2731 assert(!Lookup.empty() && "No __builtin_shufflevector?"); 2732 2733 // Build a reference to the __builtin_shufflevector builtin 2734 FunctionDecl *Builtin = cast<FunctionDecl>(Lookup.front()); 2735 Expr *Callee = new (SemaRef.Context) DeclRefExpr(Builtin, false, 2736 SemaRef.Context.BuiltinFnTy, 2737 VK_RValue, BuiltinLoc); 2738 QualType CalleePtrTy = SemaRef.Context.getPointerType(Builtin->getType()); 2739 Callee = SemaRef.ImpCastExprToType(Callee, CalleePtrTy, 2740 CK_BuiltinFnToFnPtr).get(); 2741 2742 // Build the CallExpr 2743 ExprResult TheCall = new (SemaRef.Context) CallExpr( 2744 SemaRef.Context, Callee, SubExprs, Builtin->getCallResultType(), 2745 Expr::getValueKindForType(Builtin->getReturnType()), RParenLoc); 2746 2747 // Type-check the __builtin_shufflevector expression. 2748 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get())); 2749 } 2750 2751 /// \brief Build a new convert vector expression. 2752 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc, 2753 Expr *SrcExpr, TypeSourceInfo *DstTInfo, 2754 SourceLocation RParenLoc) { 2755 return SemaRef.SemaConvertVectorExpr(SrcExpr, DstTInfo, 2756 BuiltinLoc, RParenLoc); 2757 } 2758 2759 /// \brief Build a new template argument pack expansion. 2760 /// 2761 /// By default, performs semantic analysis to build a new pack expansion 2762 /// for a template argument. Subclasses may override this routine to provide 2763 /// different behavior. 2764 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, 2765 SourceLocation EllipsisLoc, 2766 Optional<unsigned> NumExpansions) { 2767 switch (Pattern.getArgument().getKind()) { 2768 case TemplateArgument::Expression: { 2769 ExprResult Result 2770 = getSema().CheckPackExpansion(Pattern.getSourceExpression(), 2771 EllipsisLoc, NumExpansions); 2772 if (Result.isInvalid()) 2773 return TemplateArgumentLoc(); 2774 2775 return TemplateArgumentLoc(Result.get(), Result.get()); 2776 } 2777 2778 case TemplateArgument::Template: 2779 return TemplateArgumentLoc(TemplateArgument( 2780 Pattern.getArgument().getAsTemplate(), 2781 NumExpansions), 2782 Pattern.getTemplateQualifierLoc(), 2783 Pattern.getTemplateNameLoc(), 2784 EllipsisLoc); 2785 2786 case TemplateArgument::Null: 2787 case TemplateArgument::Integral: 2788 case TemplateArgument::Declaration: 2789 case TemplateArgument::Pack: 2790 case TemplateArgument::TemplateExpansion: 2791 case TemplateArgument::NullPtr: 2792 llvm_unreachable("Pack expansion pattern has no parameter packs"); 2793 2794 case TemplateArgument::Type: 2795 if (TypeSourceInfo *Expansion 2796 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(), 2797 EllipsisLoc, 2798 NumExpansions)) 2799 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()), 2800 Expansion); 2801 break; 2802 } 2803 2804 return TemplateArgumentLoc(); 2805 } 2806 2807 /// \brief Build a new expression pack expansion. 2808 /// 2809 /// By default, performs semantic analysis to build a new pack expansion 2810 /// for an expression. Subclasses may override this routine to provide 2811 /// different behavior. 2812 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 2813 Optional<unsigned> NumExpansions) { 2814 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); 2815 } 2816 2817 /// \brief Build a new C++1z fold-expression. 2818 /// 2819 /// By default, performs semantic analysis in order to build a new fold 2820 /// expression. 2821 ExprResult RebuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, 2822 BinaryOperatorKind Operator, 2823 SourceLocation EllipsisLoc, Expr *RHS, 2824 SourceLocation RParenLoc) { 2825 return getSema().BuildCXXFoldExpr(LParenLoc, LHS, Operator, EllipsisLoc, 2826 RHS, RParenLoc); 2827 } 2828 2829 /// \brief Build an empty C++1z fold-expression with the given operator. 2830 /// 2831 /// By default, produces the fallback value for the fold-expression, or 2832 /// produce an error if there is no fallback value. 2833 ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, 2834 BinaryOperatorKind Operator) { 2835 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator); 2836 } 2837 2838 /// \brief Build a new atomic operation expression. 2839 /// 2840 /// By default, performs semantic analysis to build the new expression. 2841 /// Subclasses may override this routine to provide different behavior. 2842 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, 2843 MultiExprArg SubExprs, 2844 QualType RetTy, 2845 AtomicExpr::AtomicOp Op, 2846 SourceLocation RParenLoc) { 2847 // Just create the expression; there is not any interesting semantic 2848 // analysis here because we can't actually build an AtomicExpr until 2849 // we are sure it is semantically sound. 2850 return new (SemaRef.Context) AtomicExpr(BuiltinLoc, SubExprs, RetTy, Op, 2851 RParenLoc); 2852 } 2853 2854 private: 2855 TypeLoc TransformTypeInObjectScope(TypeLoc TL, 2856 QualType ObjectType, 2857 NamedDecl *FirstQualifierInScope, 2858 CXXScopeSpec &SS); 2859 2860 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 2861 QualType ObjectType, 2862 NamedDecl *FirstQualifierInScope, 2863 CXXScopeSpec &SS); 2864 2865 TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType, 2866 NamedDecl *FirstQualifierInScope, 2867 CXXScopeSpec &SS); 2868 }; 2869 2870 template<typename Derived> 2871 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 2872 if (!S) 2873 return S; 2874 2875 switch (S->getStmtClass()) { 2876 case Stmt::NoStmtClass: break; 2877 2878 // Transform individual statement nodes 2879 #define STMT(Node, Parent) \ 2880 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 2881 #define ABSTRACT_STMT(Node) 2882 #define EXPR(Node, Parent) 2883 #include "clang/AST/StmtNodes.inc" 2884 2885 // Transform expressions by calling TransformExpr. 2886 #define STMT(Node, Parent) 2887 #define ABSTRACT_STMT(Stmt) 2888 #define EXPR(Node, Parent) case Stmt::Node##Class: 2889 #include "clang/AST/StmtNodes.inc" 2890 { 2891 ExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 2892 if (E.isInvalid()) 2893 return StmtError(); 2894 2895 return getSema().ActOnExprStmt(E); 2896 } 2897 } 2898 2899 return S; 2900 } 2901 2902 template<typename Derived> 2903 OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) { 2904 if (!S) 2905 return S; 2906 2907 switch (S->getClauseKind()) { 2908 default: break; 2909 // Transform individual clause nodes 2910 #define OPENMP_CLAUSE(Name, Class) \ 2911 case OMPC_ ## Name : \ 2912 return getDerived().Transform ## Class(cast<Class>(S)); 2913 #include "clang/Basic/OpenMPKinds.def" 2914 } 2915 2916 return S; 2917 } 2918 2919 2920 template<typename Derived> 2921 ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { 2922 if (!E) 2923 return E; 2924 2925 switch (E->getStmtClass()) { 2926 case Stmt::NoStmtClass: break; 2927 #define STMT(Node, Parent) case Stmt::Node##Class: break; 2928 #define ABSTRACT_STMT(Stmt) 2929 #define EXPR(Node, Parent) \ 2930 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 2931 #include "clang/AST/StmtNodes.inc" 2932 } 2933 2934 return E; 2935 } 2936 2937 template<typename Derived> 2938 ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init, 2939 bool NotCopyInit) { 2940 // Initializers are instantiated like expressions, except that various outer 2941 // layers are stripped. 2942 if (!Init) 2943 return Init; 2944 2945 if (ExprWithCleanups *ExprTemp = dyn_cast<ExprWithCleanups>(Init)) 2946 Init = ExprTemp->getSubExpr(); 2947 2948 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init)) 2949 Init = MTE->GetTemporaryExpr(); 2950 2951 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init)) 2952 Init = Binder->getSubExpr(); 2953 2954 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init)) 2955 Init = ICE->getSubExprAsWritten(); 2956 2957 if (CXXStdInitializerListExpr *ILE = 2958 dyn_cast<CXXStdInitializerListExpr>(Init)) 2959 return TransformInitializer(ILE->getSubExpr(), NotCopyInit); 2960 2961 // If this is copy-initialization, we only need to reconstruct 2962 // InitListExprs. Other forms of copy-initialization will be a no-op if 2963 // the initializer is already the right type. 2964 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init); 2965 if (!NotCopyInit && !(Construct && Construct->isListInitialization())) 2966 return getDerived().TransformExpr(Init); 2967 2968 // Revert value-initialization back to empty parens. 2969 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { 2970 SourceRange Parens = VIE->getSourceRange(); 2971 return getDerived().RebuildParenListExpr(Parens.getBegin(), None, 2972 Parens.getEnd()); 2973 } 2974 2975 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. 2976 if (isa<ImplicitValueInitExpr>(Init)) 2977 return getDerived().RebuildParenListExpr(SourceLocation(), None, 2978 SourceLocation()); 2979 2980 // Revert initialization by constructor back to a parenthesized or braced list 2981 // of expressions. Any other form of initializer can just be reused directly. 2982 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct)) 2983 return getDerived().TransformExpr(Init); 2984 2985 // If the initialization implicitly converted an initializer list to a 2986 // std::initializer_list object, unwrap the std::initializer_list too. 2987 if (Construct && Construct->isStdInitListInitialization()) 2988 return TransformInitializer(Construct->getArg(0), NotCopyInit); 2989 2990 SmallVector<Expr*, 8> NewArgs; 2991 bool ArgChanged = false; 2992 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(), 2993 /*IsCall*/true, NewArgs, &ArgChanged)) 2994 return ExprError(); 2995 2996 // If this was list initialization, revert to list form. 2997 if (Construct->isListInitialization()) 2998 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs, 2999 Construct->getLocEnd(), 3000 Construct->getType()); 3001 3002 // Build a ParenListExpr to represent anything else. 3003 SourceRange Parens = Construct->getParenOrBraceRange(); 3004 if (Parens.isInvalid()) { 3005 // This was a variable declaration's initialization for which no initializer 3006 // was specified. 3007 assert(NewArgs.empty() && 3008 "no parens or braces but have direct init with arguments?"); 3009 return ExprEmpty(); 3010 } 3011 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs, 3012 Parens.getEnd()); 3013 } 3014 3015 template<typename Derived> 3016 bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, 3017 unsigned NumInputs, 3018 bool IsCall, 3019 SmallVectorImpl<Expr *> &Outputs, 3020 bool *ArgChanged) { 3021 for (unsigned I = 0; I != NumInputs; ++I) { 3022 // If requested, drop call arguments that need to be dropped. 3023 if (IsCall && getDerived().DropCallArgument(Inputs[I])) { 3024 if (ArgChanged) 3025 *ArgChanged = true; 3026 3027 break; 3028 } 3029 3030 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { 3031 Expr *Pattern = Expansion->getPattern(); 3032 3033 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3034 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3035 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 3036 3037 // Determine whether the set of unexpanded parameter packs can and should 3038 // be expanded. 3039 bool Expand = true; 3040 bool RetainExpansion = false; 3041 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); 3042 Optional<unsigned> NumExpansions = OrigNumExpansions; 3043 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 3044 Pattern->getSourceRange(), 3045 Unexpanded, 3046 Expand, RetainExpansion, 3047 NumExpansions)) 3048 return true; 3049 3050 if (!Expand) { 3051 // The transform has determined that we should perform a simple 3052 // transformation on the pack expansion, producing another pack 3053 // expansion. 3054 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3055 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 3056 if (OutPattern.isInvalid()) 3057 return true; 3058 3059 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 3060 Expansion->getEllipsisLoc(), 3061 NumExpansions); 3062 if (Out.isInvalid()) 3063 return true; 3064 3065 if (ArgChanged) 3066 *ArgChanged = true; 3067 Outputs.push_back(Out.get()); 3068 continue; 3069 } 3070 3071 // Record right away that the argument was changed. This needs 3072 // to happen even if the array expands to nothing. 3073 if (ArgChanged) *ArgChanged = true; 3074 3075 // The transform has determined that we should perform an elementwise 3076 // expansion of the pattern. Do so. 3077 for (unsigned I = 0; I != *NumExpansions; ++I) { 3078 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3079 ExprResult Out = getDerived().TransformExpr(Pattern); 3080 if (Out.isInvalid()) 3081 return true; 3082 3083 // FIXME: Can this happen? We should not try to expand the pack 3084 // in this case. 3085 if (Out.get()->containsUnexpandedParameterPack()) { 3086 Out = getDerived().RebuildPackExpansion( 3087 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); 3088 if (Out.isInvalid()) 3089 return true; 3090 } 3091 3092 Outputs.push_back(Out.get()); 3093 } 3094 3095 // If we're supposed to retain a pack expansion, do so by temporarily 3096 // forgetting the partially-substituted parameter pack. 3097 if (RetainExpansion) { 3098 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3099 3100 ExprResult Out = getDerived().TransformExpr(Pattern); 3101 if (Out.isInvalid()) 3102 return true; 3103 3104 Out = getDerived().RebuildPackExpansion( 3105 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions); 3106 if (Out.isInvalid()) 3107 return true; 3108 3109 Outputs.push_back(Out.get()); 3110 } 3111 3112 continue; 3113 } 3114 3115 ExprResult Result = 3116 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false) 3117 : getDerived().TransformExpr(Inputs[I]); 3118 if (Result.isInvalid()) 3119 return true; 3120 3121 if (Result.get() != Inputs[I] && ArgChanged) 3122 *ArgChanged = true; 3123 3124 Outputs.push_back(Result.get()); 3125 } 3126 3127 return false; 3128 } 3129 3130 template<typename Derived> 3131 NestedNameSpecifierLoc 3132 TreeTransform<Derived>::TransformNestedNameSpecifierLoc( 3133 NestedNameSpecifierLoc NNS, 3134 QualType ObjectType, 3135 NamedDecl *FirstQualifierInScope) { 3136 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 3137 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; 3138 Qualifier = Qualifier.getPrefix()) 3139 Qualifiers.push_back(Qualifier); 3140 3141 CXXScopeSpec SS; 3142 while (!Qualifiers.empty()) { 3143 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 3144 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier(); 3145 3146 switch (QNNS->getKind()) { 3147 case NestedNameSpecifier::Identifier: 3148 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/nullptr, 3149 *QNNS->getAsIdentifier(), 3150 Q.getLocalBeginLoc(), 3151 Q.getLocalEndLoc(), 3152 ObjectType, false, SS, 3153 FirstQualifierInScope, false)) 3154 return NestedNameSpecifierLoc(); 3155 3156 break; 3157 3158 case NestedNameSpecifier::Namespace: { 3159 NamespaceDecl *NS 3160 = cast_or_null<NamespaceDecl>( 3161 getDerived().TransformDecl( 3162 Q.getLocalBeginLoc(), 3163 QNNS->getAsNamespace())); 3164 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); 3165 break; 3166 } 3167 3168 case NestedNameSpecifier::NamespaceAlias: { 3169 NamespaceAliasDecl *Alias 3170 = cast_or_null<NamespaceAliasDecl>( 3171 getDerived().TransformDecl(Q.getLocalBeginLoc(), 3172 QNNS->getAsNamespaceAlias())); 3173 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(), 3174 Q.getLocalEndLoc()); 3175 break; 3176 } 3177 3178 case NestedNameSpecifier::Global: 3179 // There is no meaningful transformation that one could perform on the 3180 // global scope. 3181 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); 3182 break; 3183 3184 case NestedNameSpecifier::Super: { 3185 CXXRecordDecl *RD = 3186 cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 3187 SourceLocation(), QNNS->getAsRecordDecl())); 3188 SS.MakeSuper(SemaRef.Context, RD, Q.getBeginLoc(), Q.getEndLoc()); 3189 break; 3190 } 3191 3192 case NestedNameSpecifier::TypeSpecWithTemplate: 3193 case NestedNameSpecifier::TypeSpec: { 3194 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType, 3195 FirstQualifierInScope, SS); 3196 3197 if (!TL) 3198 return NestedNameSpecifierLoc(); 3199 3200 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || 3201 (SemaRef.getLangOpts().CPlusPlus11 && 3202 TL.getType()->isEnumeralType())) { 3203 assert(!TL.getType().hasLocalQualifiers() && 3204 "Can't get cv-qualifiers here"); 3205 if (TL.getType()->isEnumeralType()) 3206 SemaRef.Diag(TL.getBeginLoc(), 3207 diag::warn_cxx98_compat_enum_nested_name_spec); 3208 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL, 3209 Q.getLocalEndLoc()); 3210 break; 3211 } 3212 // If the nested-name-specifier is an invalid type def, don't emit an 3213 // error because a previous error should have already been emitted. 3214 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>(); 3215 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { 3216 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) 3217 << TL.getType() << SS.getRange(); 3218 } 3219 return NestedNameSpecifierLoc(); 3220 } 3221 } 3222 3223 // The qualifier-in-scope and object type only apply to the leftmost entity. 3224 FirstQualifierInScope = nullptr; 3225 ObjectType = QualType(); 3226 } 3227 3228 // Don't rebuild the nested-name-specifier if we don't have to. 3229 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && 3230 !getDerived().AlwaysRebuild()) 3231 return NNS; 3232 3233 // If we can re-use the source-location data from the original 3234 // nested-name-specifier, do so. 3235 if (SS.location_size() == NNS.getDataLength() && 3236 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) 3237 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); 3238 3239 // Allocate new nested-name-specifier location information. 3240 return SS.getWithLocInContext(SemaRef.Context); 3241 } 3242 3243 template<typename Derived> 3244 DeclarationNameInfo 3245 TreeTransform<Derived> 3246 ::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 3247 DeclarationName Name = NameInfo.getName(); 3248 if (!Name) 3249 return DeclarationNameInfo(); 3250 3251 switch (Name.getNameKind()) { 3252 case DeclarationName::Identifier: 3253 case DeclarationName::ObjCZeroArgSelector: 3254 case DeclarationName::ObjCOneArgSelector: 3255 case DeclarationName::ObjCMultiArgSelector: 3256 case DeclarationName::CXXOperatorName: 3257 case DeclarationName::CXXLiteralOperatorName: 3258 case DeclarationName::CXXUsingDirective: 3259 return NameInfo; 3260 3261 case DeclarationName::CXXConstructorName: 3262 case DeclarationName::CXXDestructorName: 3263 case DeclarationName::CXXConversionFunctionName: { 3264 TypeSourceInfo *NewTInfo; 3265 CanQualType NewCanTy; 3266 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 3267 NewTInfo = getDerived().TransformType(OldTInfo); 3268 if (!NewTInfo) 3269 return DeclarationNameInfo(); 3270 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 3271 } 3272 else { 3273 NewTInfo = nullptr; 3274 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 3275 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 3276 if (NewT.isNull()) 3277 return DeclarationNameInfo(); 3278 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 3279 } 3280 3281 DeclarationName NewName 3282 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 3283 NewCanTy); 3284 DeclarationNameInfo NewNameInfo(NameInfo); 3285 NewNameInfo.setName(NewName); 3286 NewNameInfo.setNamedTypeInfo(NewTInfo); 3287 return NewNameInfo; 3288 } 3289 } 3290 3291 llvm_unreachable("Unknown name kind."); 3292 } 3293 3294 template<typename Derived> 3295 TemplateName 3296 TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, 3297 TemplateName Name, 3298 SourceLocation NameLoc, 3299 QualType ObjectType, 3300 NamedDecl *FirstQualifierInScope) { 3301 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 3302 TemplateDecl *Template = QTN->getTemplateDecl(); 3303 assert(Template && "qualified template name must refer to a template"); 3304 3305 TemplateDecl *TransTemplate 3306 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 3307 Template)); 3308 if (!TransTemplate) 3309 return TemplateName(); 3310 3311 if (!getDerived().AlwaysRebuild() && 3312 SS.getScopeRep() == QTN->getQualifier() && 3313 TransTemplate == Template) 3314 return Name; 3315 3316 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(), 3317 TransTemplate); 3318 } 3319 3320 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 3321 if (SS.getScopeRep()) { 3322 // These apply to the scope specifier, not the template. 3323 ObjectType = QualType(); 3324 FirstQualifierInScope = nullptr; 3325 } 3326 3327 if (!getDerived().AlwaysRebuild() && 3328 SS.getScopeRep() == DTN->getQualifier() && 3329 ObjectType.isNull()) 3330 return Name; 3331 3332 if (DTN->isIdentifier()) { 3333 return getDerived().RebuildTemplateName(SS, 3334 *DTN->getIdentifier(), 3335 NameLoc, 3336 ObjectType, 3337 FirstQualifierInScope); 3338 } 3339 3340 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc, 3341 ObjectType); 3342 } 3343 3344 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 3345 TemplateDecl *TransTemplate 3346 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 3347 Template)); 3348 if (!TransTemplate) 3349 return TemplateName(); 3350 3351 if (!getDerived().AlwaysRebuild() && 3352 TransTemplate == Template) 3353 return Name; 3354 3355 return TemplateName(TransTemplate); 3356 } 3357 3358 if (SubstTemplateTemplateParmPackStorage *SubstPack 3359 = Name.getAsSubstTemplateTemplateParmPack()) { 3360 TemplateTemplateParmDecl *TransParam 3361 = cast_or_null<TemplateTemplateParmDecl>( 3362 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); 3363 if (!TransParam) 3364 return TemplateName(); 3365 3366 if (!getDerived().AlwaysRebuild() && 3367 TransParam == SubstPack->getParameterPack()) 3368 return Name; 3369 3370 return getDerived().RebuildTemplateName(TransParam, 3371 SubstPack->getArgumentPack()); 3372 } 3373 3374 // These should be getting filtered out before they reach the AST. 3375 llvm_unreachable("overloaded function decl survived to here"); 3376 } 3377 3378 template<typename Derived> 3379 void TreeTransform<Derived>::InventTemplateArgumentLoc( 3380 const TemplateArgument &Arg, 3381 TemplateArgumentLoc &Output) { 3382 SourceLocation Loc = getDerived().getBaseLocation(); 3383 switch (Arg.getKind()) { 3384 case TemplateArgument::Null: 3385 llvm_unreachable("null template argument in TreeTransform"); 3386 break; 3387 3388 case TemplateArgument::Type: 3389 Output = TemplateArgumentLoc(Arg, 3390 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 3391 3392 break; 3393 3394 case TemplateArgument::Template: 3395 case TemplateArgument::TemplateExpansion: { 3396 NestedNameSpecifierLocBuilder Builder; 3397 TemplateName Template = Arg.getAsTemplate(); 3398 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 3399 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc); 3400 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3401 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc); 3402 3403 if (Arg.getKind() == TemplateArgument::Template) 3404 Output = TemplateArgumentLoc(Arg, 3405 Builder.getWithLocInContext(SemaRef.Context), 3406 Loc); 3407 else 3408 Output = TemplateArgumentLoc(Arg, 3409 Builder.getWithLocInContext(SemaRef.Context), 3410 Loc, Loc); 3411 3412 break; 3413 } 3414 3415 case TemplateArgument::Expression: 3416 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 3417 break; 3418 3419 case TemplateArgument::Declaration: 3420 case TemplateArgument::Integral: 3421 case TemplateArgument::Pack: 3422 case TemplateArgument::NullPtr: 3423 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 3424 break; 3425 } 3426 } 3427 3428 template<typename Derived> 3429 bool TreeTransform<Derived>::TransformTemplateArgument( 3430 const TemplateArgumentLoc &Input, 3431 TemplateArgumentLoc &Output) { 3432 const TemplateArgument &Arg = Input.getArgument(); 3433 switch (Arg.getKind()) { 3434 case TemplateArgument::Null: 3435 case TemplateArgument::Integral: 3436 case TemplateArgument::Pack: 3437 case TemplateArgument::Declaration: 3438 case TemplateArgument::NullPtr: 3439 llvm_unreachable("Unexpected TemplateArgument"); 3440 3441 case TemplateArgument::Type: { 3442 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 3443 if (!DI) 3444 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 3445 3446 DI = getDerived().TransformType(DI); 3447 if (!DI) return true; 3448 3449 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 3450 return false; 3451 } 3452 3453 case TemplateArgument::Template: { 3454 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc(); 3455 if (QualifierLoc) { 3456 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); 3457 if (!QualifierLoc) 3458 return true; 3459 } 3460 3461 CXXScopeSpec SS; 3462 SS.Adopt(QualifierLoc); 3463 TemplateName Template 3464 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(), 3465 Input.getTemplateNameLoc()); 3466 if (Template.isNull()) 3467 return true; 3468 3469 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc, 3470 Input.getTemplateNameLoc()); 3471 return false; 3472 } 3473 3474 case TemplateArgument::TemplateExpansion: 3475 llvm_unreachable("Caller should expand pack expansions"); 3476 3477 case TemplateArgument::Expression: { 3478 // Template argument expressions are constant expressions. 3479 EnterExpressionEvaluationContext Unevaluated(getSema(), 3480 Sema::ConstantEvaluated); 3481 3482 Expr *InputExpr = Input.getSourceExpression(); 3483 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 3484 3485 ExprResult E = getDerived().TransformExpr(InputExpr); 3486 E = SemaRef.ActOnConstantExpression(E); 3487 if (E.isInvalid()) return true; 3488 Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get()); 3489 return false; 3490 } 3491 } 3492 3493 // Work around bogus GCC warning 3494 return true; 3495 } 3496 3497 /// \brief Iterator adaptor that invents template argument location information 3498 /// for each of the template arguments in its underlying iterator. 3499 template<typename Derived, typename InputIterator> 3500 class TemplateArgumentLocInventIterator { 3501 TreeTransform<Derived> &Self; 3502 InputIterator Iter; 3503 3504 public: 3505 typedef TemplateArgumentLoc value_type; 3506 typedef TemplateArgumentLoc reference; 3507 typedef typename std::iterator_traits<InputIterator>::difference_type 3508 difference_type; 3509 typedef std::input_iterator_tag iterator_category; 3510 3511 class pointer { 3512 TemplateArgumentLoc Arg; 3513 3514 public: 3515 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3516 3517 const TemplateArgumentLoc *operator->() const { return &Arg; } 3518 }; 3519 3520 TemplateArgumentLocInventIterator() { } 3521 3522 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, 3523 InputIterator Iter) 3524 : Self(Self), Iter(Iter) { } 3525 3526 TemplateArgumentLocInventIterator &operator++() { 3527 ++Iter; 3528 return *this; 3529 } 3530 3531 TemplateArgumentLocInventIterator operator++(int) { 3532 TemplateArgumentLocInventIterator Old(*this); 3533 ++(*this); 3534 return Old; 3535 } 3536 3537 reference operator*() const { 3538 TemplateArgumentLoc Result; 3539 Self.InventTemplateArgumentLoc(*Iter, Result); 3540 return Result; 3541 } 3542 3543 pointer operator->() const { return pointer(**this); } 3544 3545 friend bool operator==(const TemplateArgumentLocInventIterator &X, 3546 const TemplateArgumentLocInventIterator &Y) { 3547 return X.Iter == Y.Iter; 3548 } 3549 3550 friend bool operator!=(const TemplateArgumentLocInventIterator &X, 3551 const TemplateArgumentLocInventIterator &Y) { 3552 return X.Iter != Y.Iter; 3553 } 3554 }; 3555 3556 template<typename Derived> 3557 template<typename InputIterator> 3558 bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, 3559 InputIterator Last, 3560 TemplateArgumentListInfo &Outputs) { 3561 for (; First != Last; ++First) { 3562 TemplateArgumentLoc Out; 3563 TemplateArgumentLoc In = *First; 3564 3565 if (In.getArgument().getKind() == TemplateArgument::Pack) { 3566 // Unpack argument packs, which we translate them into separate 3567 // arguments. 3568 // FIXME: We could do much better if we could guarantee that the 3569 // TemplateArgumentLocInfo for the pack expansion would be usable for 3570 // all of the template arguments in the argument pack. 3571 typedef TemplateArgumentLocInventIterator<Derived, 3572 TemplateArgument::pack_iterator> 3573 PackLocIterator; 3574 if (TransformTemplateArguments(PackLocIterator(*this, 3575 In.getArgument().pack_begin()), 3576 PackLocIterator(*this, 3577 In.getArgument().pack_end()), 3578 Outputs)) 3579 return true; 3580 3581 continue; 3582 } 3583 3584 if (In.getArgument().isPackExpansion()) { 3585 // We have a pack expansion, for which we will be substituting into 3586 // the pattern. 3587 SourceLocation Ellipsis; 3588 Optional<unsigned> OrigNumExpansions; 3589 TemplateArgumentLoc Pattern 3590 = getSema().getTemplateArgumentPackExpansionPattern( 3591 In, Ellipsis, OrigNumExpansions); 3592 3593 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3594 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3595 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 3596 3597 // Determine whether the set of unexpanded parameter packs can and should 3598 // be expanded. 3599 bool Expand = true; 3600 bool RetainExpansion = false; 3601 Optional<unsigned> NumExpansions = OrigNumExpansions; 3602 if (getDerived().TryExpandParameterPacks(Ellipsis, 3603 Pattern.getSourceRange(), 3604 Unexpanded, 3605 Expand, 3606 RetainExpansion, 3607 NumExpansions)) 3608 return true; 3609 3610 if (!Expand) { 3611 // The transform has determined that we should perform a simple 3612 // transformation on the pack expansion, producing another pack 3613 // expansion. 3614 TemplateArgumentLoc OutPattern; 3615 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3616 if (getDerived().TransformTemplateArgument(Pattern, OutPattern)) 3617 return true; 3618 3619 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis, 3620 NumExpansions); 3621 if (Out.getArgument().isNull()) 3622 return true; 3623 3624 Outputs.addArgument(Out); 3625 continue; 3626 } 3627 3628 // The transform has determined that we should perform an elementwise 3629 // expansion of the pattern. Do so. 3630 for (unsigned I = 0; I != *NumExpansions; ++I) { 3631 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3632 3633 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3634 return true; 3635 3636 if (Out.getArgument().containsUnexpandedParameterPack()) { 3637 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3638 OrigNumExpansions); 3639 if (Out.getArgument().isNull()) 3640 return true; 3641 } 3642 3643 Outputs.addArgument(Out); 3644 } 3645 3646 // If we're supposed to retain a pack expansion, do so by temporarily 3647 // forgetting the partially-substituted parameter pack. 3648 if (RetainExpansion) { 3649 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3650 3651 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3652 return true; 3653 3654 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3655 OrigNumExpansions); 3656 if (Out.getArgument().isNull()) 3657 return true; 3658 3659 Outputs.addArgument(Out); 3660 } 3661 3662 continue; 3663 } 3664 3665 // The simple case: 3666 if (getDerived().TransformTemplateArgument(In, Out)) 3667 return true; 3668 3669 Outputs.addArgument(Out); 3670 } 3671 3672 return false; 3673 3674 } 3675 3676 //===----------------------------------------------------------------------===// 3677 // Type transformation 3678 //===----------------------------------------------------------------------===// 3679 3680 template<typename Derived> 3681 QualType TreeTransform<Derived>::TransformType(QualType T) { 3682 if (getDerived().AlreadyTransformed(T)) 3683 return T; 3684 3685 // Temporary workaround. All of these transformations should 3686 // eventually turn into transformations on TypeLocs. 3687 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T, 3688 getDerived().getBaseLocation()); 3689 3690 TypeSourceInfo *NewDI = getDerived().TransformType(DI); 3691 3692 if (!NewDI) 3693 return QualType(); 3694 3695 return NewDI->getType(); 3696 } 3697 3698 template<typename Derived> 3699 TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { 3700 // Refine the base location to the type's location. 3701 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(), 3702 getDerived().getBaseEntity()); 3703 if (getDerived().AlreadyTransformed(DI->getType())) 3704 return DI; 3705 3706 TypeLocBuilder TLB; 3707 3708 TypeLoc TL = DI->getTypeLoc(); 3709 TLB.reserve(TL.getFullDataSize()); 3710 3711 QualType Result = getDerived().TransformType(TLB, TL); 3712 if (Result.isNull()) 3713 return nullptr; 3714 3715 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3716 } 3717 3718 template<typename Derived> 3719 QualType 3720 TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 3721 switch (T.getTypeLocClass()) { 3722 #define ABSTRACT_TYPELOC(CLASS, PARENT) 3723 #define TYPELOC(CLASS, PARENT) \ 3724 case TypeLoc::CLASS: \ 3725 return getDerived().Transform##CLASS##Type(TLB, \ 3726 T.castAs<CLASS##TypeLoc>()); 3727 #include "clang/AST/TypeLocNodes.def" 3728 } 3729 3730 llvm_unreachable("unhandled type loc!"); 3731 } 3732 3733 /// FIXME: By default, this routine adds type qualifiers only to types 3734 /// that can have qualifiers, and silently suppresses those qualifiers 3735 /// that are not permitted (e.g., qualifiers on reference or function 3736 /// types). This is the right thing for template instantiation, but 3737 /// probably not for other clients. 3738 template<typename Derived> 3739 QualType 3740 TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 3741 QualifiedTypeLoc T) { 3742 Qualifiers Quals = T.getType().getLocalQualifiers(); 3743 3744 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 3745 if (Result.isNull()) 3746 return QualType(); 3747 3748 // Silently suppress qualifiers if the result type can't be qualified. 3749 // FIXME: this is the right thing for template instantiation, but 3750 // probably not for other clients. 3751 if (Result->isFunctionType() || Result->isReferenceType()) 3752 return Result; 3753 3754 // Suppress Objective-C lifetime qualifiers if they don't make sense for the 3755 // resulting type. 3756 if (Quals.hasObjCLifetime()) { 3757 if (!Result->isObjCLifetimeType() && !Result->isDependentType()) 3758 Quals.removeObjCLifetime(); 3759 else if (Result.getObjCLifetime()) { 3760 // Objective-C ARC: 3761 // A lifetime qualifier applied to a substituted template parameter 3762 // overrides the lifetime qualifier from the template argument. 3763 const AutoType *AutoTy; 3764 if (const SubstTemplateTypeParmType *SubstTypeParam 3765 = dyn_cast<SubstTemplateTypeParmType>(Result)) { 3766 QualType Replacement = SubstTypeParam->getReplacementType(); 3767 Qualifiers Qs = Replacement.getQualifiers(); 3768 Qs.removeObjCLifetime(); 3769 Replacement 3770 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), 3771 Qs); 3772 Result = SemaRef.Context.getSubstTemplateTypeParmType( 3773 SubstTypeParam->getReplacedParameter(), 3774 Replacement); 3775 TLB.TypeWasModifiedSafely(Result); 3776 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) { 3777 // 'auto' types behave the same way as template parameters. 3778 QualType Deduced = AutoTy->getDeducedType(); 3779 Qualifiers Qs = Deduced.getQualifiers(); 3780 Qs.removeObjCLifetime(); 3781 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), 3782 Qs); 3783 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->isDecltypeAuto(), 3784 AutoTy->isDependentType()); 3785 TLB.TypeWasModifiedSafely(Result); 3786 } else { 3787 // Otherwise, complain about the addition of a qualifier to an 3788 // already-qualified type. 3789 SourceRange R = T.getUnqualifiedLoc().getSourceRange(); 3790 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant) 3791 << Result << R; 3792 3793 Quals.removeObjCLifetime(); 3794 } 3795 } 3796 } 3797 if (!Quals.empty()) { 3798 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals); 3799 // BuildQualifiedType might not add qualifiers if they are invalid. 3800 if (Result.hasLocalQualifiers()) 3801 TLB.push<QualifiedTypeLoc>(Result); 3802 // No location information to preserve. 3803 } 3804 3805 return Result; 3806 } 3807 3808 template<typename Derived> 3809 TypeLoc 3810 TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL, 3811 QualType ObjectType, 3812 NamedDecl *UnqualLookup, 3813 CXXScopeSpec &SS) { 3814 if (getDerived().AlreadyTransformed(TL.getType())) 3815 return TL; 3816 3817 TypeSourceInfo *TSI = 3818 TransformTSIInObjectScope(TL, ObjectType, UnqualLookup, SS); 3819 if (TSI) 3820 return TSI->getTypeLoc(); 3821 return TypeLoc(); 3822 } 3823 3824 template<typename Derived> 3825 TypeSourceInfo * 3826 TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 3827 QualType ObjectType, 3828 NamedDecl *UnqualLookup, 3829 CXXScopeSpec &SS) { 3830 if (getDerived().AlreadyTransformed(TSInfo->getType())) 3831 return TSInfo; 3832 3833 return TransformTSIInObjectScope(TSInfo->getTypeLoc(), ObjectType, 3834 UnqualLookup, SS); 3835 } 3836 3837 template <typename Derived> 3838 TypeSourceInfo *TreeTransform<Derived>::TransformTSIInObjectScope( 3839 TypeLoc TL, QualType ObjectType, NamedDecl *UnqualLookup, 3840 CXXScopeSpec &SS) { 3841 QualType T = TL.getType(); 3842 assert(!getDerived().AlreadyTransformed(T)); 3843 3844 TypeLocBuilder TLB; 3845 QualType Result; 3846 3847 if (isa<TemplateSpecializationType>(T)) { 3848 TemplateSpecializationTypeLoc SpecTL = 3849 TL.castAs<TemplateSpecializationTypeLoc>(); 3850 3851 TemplateName Template 3852 = getDerived().TransformTemplateName(SS, 3853 SpecTL.getTypePtr()->getTemplateName(), 3854 SpecTL.getTemplateNameLoc(), 3855 ObjectType, UnqualLookup); 3856 if (Template.isNull()) 3857 return nullptr; 3858 3859 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3860 Template); 3861 } else if (isa<DependentTemplateSpecializationType>(T)) { 3862 DependentTemplateSpecializationTypeLoc SpecTL = 3863 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3864 3865 TemplateName Template 3866 = getDerived().RebuildTemplateName(SS, 3867 *SpecTL.getTypePtr()->getIdentifier(), 3868 SpecTL.getTemplateNameLoc(), 3869 ObjectType, UnqualLookup); 3870 if (Template.isNull()) 3871 return nullptr; 3872 3873 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3874 SpecTL, 3875 Template, 3876 SS); 3877 } else { 3878 // Nothing special needs to be done for these. 3879 Result = getDerived().TransformType(TLB, TL); 3880 } 3881 3882 if (Result.isNull()) 3883 return nullptr; 3884 3885 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3886 } 3887 3888 template <class TyLoc> static inline 3889 QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 3890 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 3891 NewT.setNameLoc(T.getNameLoc()); 3892 return T.getType(); 3893 } 3894 3895 template<typename Derived> 3896 QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 3897 BuiltinTypeLoc T) { 3898 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 3899 NewT.setBuiltinLoc(T.getBuiltinLoc()); 3900 if (T.needsExtraLocalData()) 3901 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 3902 return T.getType(); 3903 } 3904 3905 template<typename Derived> 3906 QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 3907 ComplexTypeLoc T) { 3908 // FIXME: recurse? 3909 return TransformTypeSpecType(TLB, T); 3910 } 3911 3912 template <typename Derived> 3913 QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB, 3914 AdjustedTypeLoc TL) { 3915 // Adjustments applied during transformation are handled elsewhere. 3916 return getDerived().TransformType(TLB, TL.getOriginalLoc()); 3917 } 3918 3919 template<typename Derived> 3920 QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB, 3921 DecayedTypeLoc TL) { 3922 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc()); 3923 if (OriginalType.isNull()) 3924 return QualType(); 3925 3926 QualType Result = TL.getType(); 3927 if (getDerived().AlwaysRebuild() || 3928 OriginalType != TL.getOriginalLoc().getType()) 3929 Result = SemaRef.Context.getDecayedType(OriginalType); 3930 TLB.push<DecayedTypeLoc>(Result); 3931 // Nothing to set for DecayedTypeLoc. 3932 return Result; 3933 } 3934 3935 template<typename Derived> 3936 QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 3937 PointerTypeLoc TL) { 3938 QualType PointeeType 3939 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3940 if (PointeeType.isNull()) 3941 return QualType(); 3942 3943 QualType Result = TL.getType(); 3944 if (PointeeType->getAs<ObjCObjectType>()) { 3945 // A dependent pointer type 'T *' has is being transformed such 3946 // that an Objective-C class type is being replaced for 'T'. The 3947 // resulting pointer type is an ObjCObjectPointerType, not a 3948 // PointerType. 3949 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); 3950 3951 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 3952 NewT.setStarLoc(TL.getStarLoc()); 3953 return Result; 3954 } 3955 3956 if (getDerived().AlwaysRebuild() || 3957 PointeeType != TL.getPointeeLoc().getType()) { 3958 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 3959 if (Result.isNull()) 3960 return QualType(); 3961 } 3962 3963 // Objective-C ARC can add lifetime qualifiers to the type that we're 3964 // pointing to. 3965 TLB.TypeWasModifiedSafely(Result->getPointeeType()); 3966 3967 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 3968 NewT.setSigilLoc(TL.getSigilLoc()); 3969 return Result; 3970 } 3971 3972 template<typename Derived> 3973 QualType 3974 TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 3975 BlockPointerTypeLoc TL) { 3976 QualType PointeeType 3977 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3978 if (PointeeType.isNull()) 3979 return QualType(); 3980 3981 QualType Result = TL.getType(); 3982 if (getDerived().AlwaysRebuild() || 3983 PointeeType != TL.getPointeeLoc().getType()) { 3984 Result = getDerived().RebuildBlockPointerType(PointeeType, 3985 TL.getSigilLoc()); 3986 if (Result.isNull()) 3987 return QualType(); 3988 } 3989 3990 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); 3991 NewT.setSigilLoc(TL.getSigilLoc()); 3992 return Result; 3993 } 3994 3995 /// Transforms a reference type. Note that somewhat paradoxically we 3996 /// don't care whether the type itself is an l-value type or an r-value 3997 /// type; we only care if the type was *written* as an l-value type 3998 /// or an r-value type. 3999 template<typename Derived> 4000 QualType 4001 TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 4002 ReferenceTypeLoc TL) { 4003 const ReferenceType *T = TL.getTypePtr(); 4004 4005 // Note that this works with the pointee-as-written. 4006 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 4007 if (PointeeType.isNull()) 4008 return QualType(); 4009 4010 QualType Result = TL.getType(); 4011 if (getDerived().AlwaysRebuild() || 4012 PointeeType != T->getPointeeTypeAsWritten()) { 4013 Result = getDerived().RebuildReferenceType(PointeeType, 4014 T->isSpelledAsLValue(), 4015 TL.getSigilLoc()); 4016 if (Result.isNull()) 4017 return QualType(); 4018 } 4019 4020 // Objective-C ARC can add lifetime qualifiers to the type that we're 4021 // referring to. 4022 TLB.TypeWasModifiedSafely( 4023 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten()); 4024 4025 // r-value references can be rebuilt as l-value references. 4026 ReferenceTypeLoc NewTL; 4027 if (isa<LValueReferenceType>(Result)) 4028 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 4029 else 4030 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 4031 NewTL.setSigilLoc(TL.getSigilLoc()); 4032 4033 return Result; 4034 } 4035 4036 template<typename Derived> 4037 QualType 4038 TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 4039 LValueReferenceTypeLoc TL) { 4040 return TransformReferenceType(TLB, TL); 4041 } 4042 4043 template<typename Derived> 4044 QualType 4045 TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 4046 RValueReferenceTypeLoc TL) { 4047 return TransformReferenceType(TLB, TL); 4048 } 4049 4050 template<typename Derived> 4051 QualType 4052 TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 4053 MemberPointerTypeLoc TL) { 4054 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 4055 if (PointeeType.isNull()) 4056 return QualType(); 4057 4058 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo(); 4059 TypeSourceInfo *NewClsTInfo = nullptr; 4060 if (OldClsTInfo) { 4061 NewClsTInfo = getDerived().TransformType(OldClsTInfo); 4062 if (!NewClsTInfo) 4063 return QualType(); 4064 } 4065 4066 const MemberPointerType *T = TL.getTypePtr(); 4067 QualType OldClsType = QualType(T->getClass(), 0); 4068 QualType NewClsType; 4069 if (NewClsTInfo) 4070 NewClsType = NewClsTInfo->getType(); 4071 else { 4072 NewClsType = getDerived().TransformType(OldClsType); 4073 if (NewClsType.isNull()) 4074 return QualType(); 4075 } 4076 4077 QualType Result = TL.getType(); 4078 if (getDerived().AlwaysRebuild() || 4079 PointeeType != T->getPointeeType() || 4080 NewClsType != OldClsType) { 4081 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType, 4082 TL.getStarLoc()); 4083 if (Result.isNull()) 4084 return QualType(); 4085 } 4086 4087 // If we had to adjust the pointee type when building a member pointer, make 4088 // sure to push TypeLoc info for it. 4089 const MemberPointerType *MPT = Result->getAs<MemberPointerType>(); 4090 if (MPT && PointeeType != MPT->getPointeeType()) { 4091 assert(isa<AdjustedType>(MPT->getPointeeType())); 4092 TLB.push<AdjustedTypeLoc>(MPT->getPointeeType()); 4093 } 4094 4095 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 4096 NewTL.setSigilLoc(TL.getSigilLoc()); 4097 NewTL.setClassTInfo(NewClsTInfo); 4098 4099 return Result; 4100 } 4101 4102 template<typename Derived> 4103 QualType 4104 TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 4105 ConstantArrayTypeLoc TL) { 4106 const ConstantArrayType *T = TL.getTypePtr(); 4107 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 4108 if (ElementType.isNull()) 4109 return QualType(); 4110 4111 QualType Result = TL.getType(); 4112 if (getDerived().AlwaysRebuild() || 4113 ElementType != T->getElementType()) { 4114 Result = getDerived().RebuildConstantArrayType(ElementType, 4115 T->getSizeModifier(), 4116 T->getSize(), 4117 T->getIndexTypeCVRQualifiers(), 4118 TL.getBracketsRange()); 4119 if (Result.isNull()) 4120 return QualType(); 4121 } 4122 4123 // We might have either a ConstantArrayType or a VariableArrayType now: 4124 // a ConstantArrayType is allowed to have an element type which is a 4125 // VariableArrayType if the type is dependent. Fortunately, all array 4126 // types have the same location layout. 4127 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 4128 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4129 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4130 4131 Expr *Size = TL.getSizeExpr(); 4132 if (Size) { 4133 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4134 Sema::ConstantEvaluated); 4135 Size = getDerived().TransformExpr(Size).template getAs<Expr>(); 4136 Size = SemaRef.ActOnConstantExpression(Size).get(); 4137 } 4138 NewTL.setSizeExpr(Size); 4139 4140 return Result; 4141 } 4142 4143 template<typename Derived> 4144 QualType TreeTransform<Derived>::TransformIncompleteArrayType( 4145 TypeLocBuilder &TLB, 4146 IncompleteArrayTypeLoc TL) { 4147 const IncompleteArrayType *T = TL.getTypePtr(); 4148 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 4149 if (ElementType.isNull()) 4150 return QualType(); 4151 4152 QualType Result = TL.getType(); 4153 if (getDerived().AlwaysRebuild() || 4154 ElementType != T->getElementType()) { 4155 Result = getDerived().RebuildIncompleteArrayType(ElementType, 4156 T->getSizeModifier(), 4157 T->getIndexTypeCVRQualifiers(), 4158 TL.getBracketsRange()); 4159 if (Result.isNull()) 4160 return QualType(); 4161 } 4162 4163 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 4164 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4165 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4166 NewTL.setSizeExpr(nullptr); 4167 4168 return Result; 4169 } 4170 4171 template<typename Derived> 4172 QualType 4173 TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 4174 VariableArrayTypeLoc TL) { 4175 const VariableArrayType *T = TL.getTypePtr(); 4176 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 4177 if (ElementType.isNull()) 4178 return QualType(); 4179 4180 ExprResult SizeResult 4181 = getDerived().TransformExpr(T->getSizeExpr()); 4182 if (SizeResult.isInvalid()) 4183 return QualType(); 4184 4185 Expr *Size = SizeResult.get(); 4186 4187 QualType Result = TL.getType(); 4188 if (getDerived().AlwaysRebuild() || 4189 ElementType != T->getElementType() || 4190 Size != T->getSizeExpr()) { 4191 Result = getDerived().RebuildVariableArrayType(ElementType, 4192 T->getSizeModifier(), 4193 Size, 4194 T->getIndexTypeCVRQualifiers(), 4195 TL.getBracketsRange()); 4196 if (Result.isNull()) 4197 return QualType(); 4198 } 4199 4200 // We might have constant size array now, but fortunately it has the same 4201 // location layout. 4202 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 4203 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4204 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4205 NewTL.setSizeExpr(Size); 4206 4207 return Result; 4208 } 4209 4210 template<typename Derived> 4211 QualType 4212 TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 4213 DependentSizedArrayTypeLoc TL) { 4214 const DependentSizedArrayType *T = TL.getTypePtr(); 4215 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 4216 if (ElementType.isNull()) 4217 return QualType(); 4218 4219 // Array bounds are constant expressions. 4220 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4221 Sema::ConstantEvaluated); 4222 4223 // Prefer the expression from the TypeLoc; the other may have been uniqued. 4224 Expr *origSize = TL.getSizeExpr(); 4225 if (!origSize) origSize = T->getSizeExpr(); 4226 4227 ExprResult sizeResult 4228 = getDerived().TransformExpr(origSize); 4229 sizeResult = SemaRef.ActOnConstantExpression(sizeResult); 4230 if (sizeResult.isInvalid()) 4231 return QualType(); 4232 4233 Expr *size = sizeResult.get(); 4234 4235 QualType Result = TL.getType(); 4236 if (getDerived().AlwaysRebuild() || 4237 ElementType != T->getElementType() || 4238 size != origSize) { 4239 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 4240 T->getSizeModifier(), 4241 size, 4242 T->getIndexTypeCVRQualifiers(), 4243 TL.getBracketsRange()); 4244 if (Result.isNull()) 4245 return QualType(); 4246 } 4247 4248 // We might have any sort of array type now, but fortunately they 4249 // all have the same location layout. 4250 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 4251 NewTL.setLBracketLoc(TL.getLBracketLoc()); 4252 NewTL.setRBracketLoc(TL.getRBracketLoc()); 4253 NewTL.setSizeExpr(size); 4254 4255 return Result; 4256 } 4257 4258 template<typename Derived> 4259 QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 4260 TypeLocBuilder &TLB, 4261 DependentSizedExtVectorTypeLoc TL) { 4262 const DependentSizedExtVectorType *T = TL.getTypePtr(); 4263 4264 // FIXME: ext vector locs should be nested 4265 QualType ElementType = getDerived().TransformType(T->getElementType()); 4266 if (ElementType.isNull()) 4267 return QualType(); 4268 4269 // Vector sizes are constant expressions. 4270 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4271 Sema::ConstantEvaluated); 4272 4273 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 4274 Size = SemaRef.ActOnConstantExpression(Size); 4275 if (Size.isInvalid()) 4276 return QualType(); 4277 4278 QualType Result = TL.getType(); 4279 if (getDerived().AlwaysRebuild() || 4280 ElementType != T->getElementType() || 4281 Size.get() != T->getSizeExpr()) { 4282 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 4283 Size.get(), 4284 T->getAttributeLoc()); 4285 if (Result.isNull()) 4286 return QualType(); 4287 } 4288 4289 // Result might be dependent or not. 4290 if (isa<DependentSizedExtVectorType>(Result)) { 4291 DependentSizedExtVectorTypeLoc NewTL 4292 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 4293 NewTL.setNameLoc(TL.getNameLoc()); 4294 } else { 4295 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 4296 NewTL.setNameLoc(TL.getNameLoc()); 4297 } 4298 4299 return Result; 4300 } 4301 4302 template<typename Derived> 4303 QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 4304 VectorTypeLoc TL) { 4305 const VectorType *T = TL.getTypePtr(); 4306 QualType ElementType = getDerived().TransformType(T->getElementType()); 4307 if (ElementType.isNull()) 4308 return QualType(); 4309 4310 QualType Result = TL.getType(); 4311 if (getDerived().AlwaysRebuild() || 4312 ElementType != T->getElementType()) { 4313 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 4314 T->getVectorKind()); 4315 if (Result.isNull()) 4316 return QualType(); 4317 } 4318 4319 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 4320 NewTL.setNameLoc(TL.getNameLoc()); 4321 4322 return Result; 4323 } 4324 4325 template<typename Derived> 4326 QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 4327 ExtVectorTypeLoc TL) { 4328 const VectorType *T = TL.getTypePtr(); 4329 QualType ElementType = getDerived().TransformType(T->getElementType()); 4330 if (ElementType.isNull()) 4331 return QualType(); 4332 4333 QualType Result = TL.getType(); 4334 if (getDerived().AlwaysRebuild() || 4335 ElementType != T->getElementType()) { 4336 Result = getDerived().RebuildExtVectorType(ElementType, 4337 T->getNumElements(), 4338 /*FIXME*/ SourceLocation()); 4339 if (Result.isNull()) 4340 return QualType(); 4341 } 4342 4343 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 4344 NewTL.setNameLoc(TL.getNameLoc()); 4345 4346 return Result; 4347 } 4348 4349 template <typename Derived> 4350 ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( 4351 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, 4352 bool ExpectParameterPack) { 4353 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 4354 TypeSourceInfo *NewDI = nullptr; 4355 4356 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { 4357 // If we're substituting into a pack expansion type and we know the 4358 // length we want to expand to, just substitute for the pattern. 4359 TypeLoc OldTL = OldDI->getTypeLoc(); 4360 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>(); 4361 4362 TypeLocBuilder TLB; 4363 TypeLoc NewTL = OldDI->getTypeLoc(); 4364 TLB.reserve(NewTL.getFullDataSize()); 4365 4366 QualType Result = getDerived().TransformType(TLB, 4367 OldExpansionTL.getPatternLoc()); 4368 if (Result.isNull()) 4369 return nullptr; 4370 4371 Result = RebuildPackExpansionType(Result, 4372 OldExpansionTL.getPatternLoc().getSourceRange(), 4373 OldExpansionTL.getEllipsisLoc(), 4374 NumExpansions); 4375 if (Result.isNull()) 4376 return nullptr; 4377 4378 PackExpansionTypeLoc NewExpansionTL 4379 = TLB.push<PackExpansionTypeLoc>(Result); 4380 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); 4381 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result); 4382 } else 4383 NewDI = getDerived().TransformType(OldDI); 4384 if (!NewDI) 4385 return nullptr; 4386 4387 if (NewDI == OldDI && indexAdjustment == 0) 4388 return OldParm; 4389 4390 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context, 4391 OldParm->getDeclContext(), 4392 OldParm->getInnerLocStart(), 4393 OldParm->getLocation(), 4394 OldParm->getIdentifier(), 4395 NewDI->getType(), 4396 NewDI, 4397 OldParm->getStorageClass(), 4398 /* DefArg */ nullptr); 4399 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 4400 OldParm->getFunctionScopeIndex() + indexAdjustment); 4401 return newParm; 4402 } 4403 4404 template<typename Derived> 4405 bool TreeTransform<Derived>:: 4406 TransformFunctionTypeParams(SourceLocation Loc, 4407 ParmVarDecl **Params, unsigned NumParams, 4408 const QualType *ParamTypes, 4409 SmallVectorImpl<QualType> &OutParamTypes, 4410 SmallVectorImpl<ParmVarDecl*> *PVars) { 4411 int indexAdjustment = 0; 4412 4413 for (unsigned i = 0; i != NumParams; ++i) { 4414 if (ParmVarDecl *OldParm = Params[i]) { 4415 assert(OldParm->getFunctionScopeIndex() == i); 4416 4417 Optional<unsigned> NumExpansions; 4418 ParmVarDecl *NewParm = nullptr; 4419 if (OldParm->isParameterPack()) { 4420 // We have a function parameter pack that may need to be expanded. 4421 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4422 4423 // Find the parameter packs that could be expanded. 4424 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); 4425 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); 4426 TypeLoc Pattern = ExpansionTL.getPatternLoc(); 4427 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 4428 assert(Unexpanded.size() > 0 && "Could not find parameter packs!"); 4429 4430 // Determine whether we should expand the parameter packs. 4431 bool ShouldExpand = false; 4432 bool RetainExpansion = false; 4433 Optional<unsigned> OrigNumExpansions = 4434 ExpansionTL.getTypePtr()->getNumExpansions(); 4435 NumExpansions = OrigNumExpansions; 4436 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 4437 Pattern.getSourceRange(), 4438 Unexpanded, 4439 ShouldExpand, 4440 RetainExpansion, 4441 NumExpansions)) { 4442 return true; 4443 } 4444 4445 if (ShouldExpand) { 4446 // Expand the function parameter pack into multiple, separate 4447 // parameters. 4448 getDerived().ExpandingFunctionParameterPack(OldParm); 4449 for (unsigned I = 0; I != *NumExpansions; ++I) { 4450 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4451 ParmVarDecl *NewParm 4452 = getDerived().TransformFunctionTypeParam(OldParm, 4453 indexAdjustment++, 4454 OrigNumExpansions, 4455 /*ExpectParameterPack=*/false); 4456 if (!NewParm) 4457 return true; 4458 4459 OutParamTypes.push_back(NewParm->getType()); 4460 if (PVars) 4461 PVars->push_back(NewParm); 4462 } 4463 4464 // If we're supposed to retain a pack expansion, do so by temporarily 4465 // forgetting the partially-substituted parameter pack. 4466 if (RetainExpansion) { 4467 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4468 ParmVarDecl *NewParm 4469 = getDerived().TransformFunctionTypeParam(OldParm, 4470 indexAdjustment++, 4471 OrigNumExpansions, 4472 /*ExpectParameterPack=*/false); 4473 if (!NewParm) 4474 return true; 4475 4476 OutParamTypes.push_back(NewParm->getType()); 4477 if (PVars) 4478 PVars->push_back(NewParm); 4479 } 4480 4481 // The next parameter should have the same adjustment as the 4482 // last thing we pushed, but we post-incremented indexAdjustment 4483 // on every push. Also, if we push nothing, the adjustment should 4484 // go down by one. 4485 indexAdjustment--; 4486 4487 // We're done with the pack expansion. 4488 continue; 4489 } 4490 4491 // We'll substitute the parameter now without expanding the pack 4492 // expansion. 4493 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4494 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 4495 indexAdjustment, 4496 NumExpansions, 4497 /*ExpectParameterPack=*/true); 4498 } else { 4499 NewParm = getDerived().TransformFunctionTypeParam( 4500 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); 4501 } 4502 4503 if (!NewParm) 4504 return true; 4505 4506 OutParamTypes.push_back(NewParm->getType()); 4507 if (PVars) 4508 PVars->push_back(NewParm); 4509 continue; 4510 } 4511 4512 // Deal with the possibility that we don't have a parameter 4513 // declaration for this parameter. 4514 QualType OldType = ParamTypes[i]; 4515 bool IsPackExpansion = false; 4516 Optional<unsigned> NumExpansions; 4517 QualType NewType; 4518 if (const PackExpansionType *Expansion 4519 = dyn_cast<PackExpansionType>(OldType)) { 4520 // We have a function parameter pack that may need to be expanded. 4521 QualType Pattern = Expansion->getPattern(); 4522 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4523 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 4524 4525 // Determine whether we should expand the parameter packs. 4526 bool ShouldExpand = false; 4527 bool RetainExpansion = false; 4528 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(), 4529 Unexpanded, 4530 ShouldExpand, 4531 RetainExpansion, 4532 NumExpansions)) { 4533 return true; 4534 } 4535 4536 if (ShouldExpand) { 4537 // Expand the function parameter pack into multiple, separate 4538 // parameters. 4539 for (unsigned I = 0; I != *NumExpansions; ++I) { 4540 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4541 QualType NewType = getDerived().TransformType(Pattern); 4542 if (NewType.isNull()) 4543 return true; 4544 4545 OutParamTypes.push_back(NewType); 4546 if (PVars) 4547 PVars->push_back(nullptr); 4548 } 4549 4550 // We're done with the pack expansion. 4551 continue; 4552 } 4553 4554 // If we're supposed to retain a pack expansion, do so by temporarily 4555 // forgetting the partially-substituted parameter pack. 4556 if (RetainExpansion) { 4557 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4558 QualType NewType = getDerived().TransformType(Pattern); 4559 if (NewType.isNull()) 4560 return true; 4561 4562 OutParamTypes.push_back(NewType); 4563 if (PVars) 4564 PVars->push_back(nullptr); 4565 } 4566 4567 // We'll substitute the parameter now without expanding the pack 4568 // expansion. 4569 OldType = Expansion->getPattern(); 4570 IsPackExpansion = true; 4571 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4572 NewType = getDerived().TransformType(OldType); 4573 } else { 4574 NewType = getDerived().TransformType(OldType); 4575 } 4576 4577 if (NewType.isNull()) 4578 return true; 4579 4580 if (IsPackExpansion) 4581 NewType = getSema().Context.getPackExpansionType(NewType, 4582 NumExpansions); 4583 4584 OutParamTypes.push_back(NewType); 4585 if (PVars) 4586 PVars->push_back(nullptr); 4587 } 4588 4589 #ifndef NDEBUG 4590 if (PVars) { 4591 for (unsigned i = 0, e = PVars->size(); i != e; ++i) 4592 if (ParmVarDecl *parm = (*PVars)[i]) 4593 assert(parm->getFunctionScopeIndex() == i); 4594 } 4595 #endif 4596 4597 return false; 4598 } 4599 4600 template<typename Derived> 4601 QualType 4602 TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4603 FunctionProtoTypeLoc TL) { 4604 SmallVector<QualType, 4> ExceptionStorage; 4605 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135. 4606 return getDerived().TransformFunctionProtoType( 4607 TLB, TL, nullptr, 0, 4608 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { 4609 return This->TransformExceptionSpec(TL.getBeginLoc(), ESI, 4610 ExceptionStorage, Changed); 4611 }); 4612 } 4613 4614 template<typename Derived> template<typename Fn> 4615 QualType TreeTransform<Derived>::TransformFunctionProtoType( 4616 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext, 4617 unsigned ThisTypeQuals, Fn TransformExceptionSpec) { 4618 // Transform the parameters and return type. 4619 // 4620 // We are required to instantiate the params and return type in source order. 4621 // When the function has a trailing return type, we instantiate the 4622 // parameters before the return type, since the return type can then refer 4623 // to the parameters themselves (via decltype, sizeof, etc.). 4624 // 4625 SmallVector<QualType, 4> ParamTypes; 4626 SmallVector<ParmVarDecl*, 4> ParamDecls; 4627 const FunctionProtoType *T = TL.getTypePtr(); 4628 4629 QualType ResultType; 4630 4631 if (T->hasTrailingReturn()) { 4632 if (getDerived().TransformFunctionTypeParams( 4633 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), 4634 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) 4635 return QualType(); 4636 4637 { 4638 // C++11 [expr.prim.general]p3: 4639 // If a declaration declares a member function or member function 4640 // template of a class X, the expression this is a prvalue of type 4641 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 4642 // and the end of the function-definition, member-declarator, or 4643 // declarator. 4644 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals); 4645 4646 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4647 if (ResultType.isNull()) 4648 return QualType(); 4649 } 4650 } 4651 else { 4652 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4653 if (ResultType.isNull()) 4654 return QualType(); 4655 4656 if (getDerived().TransformFunctionTypeParams( 4657 TL.getBeginLoc(), TL.getParmArray(), TL.getNumParams(), 4658 TL.getTypePtr()->param_type_begin(), ParamTypes, &ParamDecls)) 4659 return QualType(); 4660 } 4661 4662 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo(); 4663 4664 bool EPIChanged = false; 4665 if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged)) 4666 return QualType(); 4667 4668 // FIXME: Need to transform ConsumedParameters for variadic template 4669 // expansion. 4670 4671 QualType Result = TL.getType(); 4672 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() || 4673 T->getNumParams() != ParamTypes.size() || 4674 !std::equal(T->param_type_begin(), T->param_type_end(), 4675 ParamTypes.begin()) || EPIChanged) { 4676 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI); 4677 if (Result.isNull()) 4678 return QualType(); 4679 } 4680 4681 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 4682 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4683 NewTL.setLParenLoc(TL.getLParenLoc()); 4684 NewTL.setRParenLoc(TL.getRParenLoc()); 4685 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4686 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i) 4687 NewTL.setParam(i, ParamDecls[i]); 4688 4689 return Result; 4690 } 4691 4692 template<typename Derived> 4693 bool TreeTransform<Derived>::TransformExceptionSpec( 4694 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI, 4695 SmallVectorImpl<QualType> &Exceptions, bool &Changed) { 4696 assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated); 4697 4698 // Instantiate a dynamic noexcept expression, if any. 4699 if (ESI.Type == EST_ComputedNoexcept) { 4700 EnterExpressionEvaluationContext Unevaluated(getSema(), 4701 Sema::ConstantEvaluated); 4702 ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr); 4703 if (NoexceptExpr.isInvalid()) 4704 return true; 4705 4706 NoexceptExpr = getSema().CheckBooleanCondition( 4707 NoexceptExpr.get(), NoexceptExpr.get()->getLocStart()); 4708 if (NoexceptExpr.isInvalid()) 4709 return true; 4710 4711 if (!NoexceptExpr.get()->isValueDependent()) { 4712 NoexceptExpr = getSema().VerifyIntegerConstantExpression( 4713 NoexceptExpr.get(), nullptr, 4714 diag::err_noexcept_needs_constant_expression, 4715 /*AllowFold*/false); 4716 if (NoexceptExpr.isInvalid()) 4717 return true; 4718 } 4719 4720 if (ESI.NoexceptExpr != NoexceptExpr.get()) 4721 Changed = true; 4722 ESI.NoexceptExpr = NoexceptExpr.get(); 4723 } 4724 4725 if (ESI.Type != EST_Dynamic) 4726 return false; 4727 4728 // Instantiate a dynamic exception specification's type. 4729 for (QualType T : ESI.Exceptions) { 4730 if (const PackExpansionType *PackExpansion = 4731 T->getAs<PackExpansionType>()) { 4732 Changed = true; 4733 4734 // We have a pack expansion. Instantiate it. 4735 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4736 SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(), 4737 Unexpanded); 4738 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 4739 4740 // Determine whether the set of unexpanded parameter packs can and 4741 // should 4742 // be expanded. 4743 bool Expand = false; 4744 bool RetainExpansion = false; 4745 Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); 4746 // FIXME: Track the location of the ellipsis (and track source location 4747 // information for the types in the exception specification in general). 4748 if (getDerived().TryExpandParameterPacks( 4749 Loc, SourceRange(), Unexpanded, Expand, 4750 RetainExpansion, NumExpansions)) 4751 return true; 4752 4753 if (!Expand) { 4754 // We can't expand this pack expansion into separate arguments yet; 4755 // just substitute into the pattern and create a new pack expansion 4756 // type. 4757 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4758 QualType U = getDerived().TransformType(PackExpansion->getPattern()); 4759 if (U.isNull()) 4760 return true; 4761 4762 U = SemaRef.Context.getPackExpansionType(U, NumExpansions); 4763 Exceptions.push_back(U); 4764 continue; 4765 } 4766 4767 // Substitute into the pack expansion pattern for each slice of the 4768 // pack. 4769 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) { 4770 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx); 4771 4772 QualType U = getDerived().TransformType(PackExpansion->getPattern()); 4773 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc)) 4774 return true; 4775 4776 Exceptions.push_back(U); 4777 } 4778 } else { 4779 QualType U = getDerived().TransformType(T); 4780 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(U, Loc)) 4781 return true; 4782 if (T != U) 4783 Changed = true; 4784 4785 Exceptions.push_back(U); 4786 } 4787 } 4788 4789 ESI.Exceptions = Exceptions; 4790 return false; 4791 } 4792 4793 template<typename Derived> 4794 QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 4795 TypeLocBuilder &TLB, 4796 FunctionNoProtoTypeLoc TL) { 4797 const FunctionNoProtoType *T = TL.getTypePtr(); 4798 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc()); 4799 if (ResultType.isNull()) 4800 return QualType(); 4801 4802 QualType Result = TL.getType(); 4803 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType()) 4804 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 4805 4806 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 4807 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4808 NewTL.setLParenLoc(TL.getLParenLoc()); 4809 NewTL.setRParenLoc(TL.getRParenLoc()); 4810 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4811 4812 return Result; 4813 } 4814 4815 template<typename Derived> QualType 4816 TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 4817 UnresolvedUsingTypeLoc TL) { 4818 const UnresolvedUsingType *T = TL.getTypePtr(); 4819 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 4820 if (!D) 4821 return QualType(); 4822 4823 QualType Result = TL.getType(); 4824 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 4825 Result = getDerived().RebuildUnresolvedUsingType(D); 4826 if (Result.isNull()) 4827 return QualType(); 4828 } 4829 4830 // We might get an arbitrary type spec type back. We should at 4831 // least always get a type spec type, though. 4832 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 4833 NewTL.setNameLoc(TL.getNameLoc()); 4834 4835 return Result; 4836 } 4837 4838 template<typename Derived> 4839 QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 4840 TypedefTypeLoc TL) { 4841 const TypedefType *T = TL.getTypePtr(); 4842 TypedefNameDecl *Typedef 4843 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4844 T->getDecl())); 4845 if (!Typedef) 4846 return QualType(); 4847 4848 QualType Result = TL.getType(); 4849 if (getDerived().AlwaysRebuild() || 4850 Typedef != T->getDecl()) { 4851 Result = getDerived().RebuildTypedefType(Typedef); 4852 if (Result.isNull()) 4853 return QualType(); 4854 } 4855 4856 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 4857 NewTL.setNameLoc(TL.getNameLoc()); 4858 4859 return Result; 4860 } 4861 4862 template<typename Derived> 4863 QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 4864 TypeOfExprTypeLoc TL) { 4865 // typeof expressions are not potentially evaluated contexts 4866 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4867 Sema::ReuseLambdaContextDecl); 4868 4869 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 4870 if (E.isInvalid()) 4871 return QualType(); 4872 4873 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get()); 4874 if (E.isInvalid()) 4875 return QualType(); 4876 4877 QualType Result = TL.getType(); 4878 if (getDerived().AlwaysRebuild() || 4879 E.get() != TL.getUnderlyingExpr()) { 4880 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 4881 if (Result.isNull()) 4882 return QualType(); 4883 } 4884 else E.get(); 4885 4886 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 4887 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4888 NewTL.setLParenLoc(TL.getLParenLoc()); 4889 NewTL.setRParenLoc(TL.getRParenLoc()); 4890 4891 return Result; 4892 } 4893 4894 template<typename Derived> 4895 QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 4896 TypeOfTypeLoc TL) { 4897 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 4898 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 4899 if (!New_Under_TI) 4900 return QualType(); 4901 4902 QualType Result = TL.getType(); 4903 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 4904 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 4905 if (Result.isNull()) 4906 return QualType(); 4907 } 4908 4909 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 4910 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4911 NewTL.setLParenLoc(TL.getLParenLoc()); 4912 NewTL.setRParenLoc(TL.getRParenLoc()); 4913 NewTL.setUnderlyingTInfo(New_Under_TI); 4914 4915 return Result; 4916 } 4917 4918 template<typename Derived> 4919 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 4920 DecltypeTypeLoc TL) { 4921 const DecltypeType *T = TL.getTypePtr(); 4922 4923 // decltype expressions are not potentially evaluated contexts 4924 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4925 nullptr, /*IsDecltype=*/ true); 4926 4927 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 4928 if (E.isInvalid()) 4929 return QualType(); 4930 4931 E = getSema().ActOnDecltypeExpression(E.get()); 4932 if (E.isInvalid()) 4933 return QualType(); 4934 4935 QualType Result = TL.getType(); 4936 if (getDerived().AlwaysRebuild() || 4937 E.get() != T->getUnderlyingExpr()) { 4938 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 4939 if (Result.isNull()) 4940 return QualType(); 4941 } 4942 else E.get(); 4943 4944 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 4945 NewTL.setNameLoc(TL.getNameLoc()); 4946 4947 return Result; 4948 } 4949 4950 template<typename Derived> 4951 QualType TreeTransform<Derived>::TransformUnaryTransformType( 4952 TypeLocBuilder &TLB, 4953 UnaryTransformTypeLoc TL) { 4954 QualType Result = TL.getType(); 4955 if (Result->isDependentType()) { 4956 const UnaryTransformType *T = TL.getTypePtr(); 4957 QualType NewBase = 4958 getDerived().TransformType(TL.getUnderlyingTInfo())->getType(); 4959 Result = getDerived().RebuildUnaryTransformType(NewBase, 4960 T->getUTTKind(), 4961 TL.getKWLoc()); 4962 if (Result.isNull()) 4963 return QualType(); 4964 } 4965 4966 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result); 4967 NewTL.setKWLoc(TL.getKWLoc()); 4968 NewTL.setParensRange(TL.getParensRange()); 4969 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo()); 4970 return Result; 4971 } 4972 4973 template<typename Derived> 4974 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, 4975 AutoTypeLoc TL) { 4976 const AutoType *T = TL.getTypePtr(); 4977 QualType OldDeduced = T->getDeducedType(); 4978 QualType NewDeduced; 4979 if (!OldDeduced.isNull()) { 4980 NewDeduced = getDerived().TransformType(OldDeduced); 4981 if (NewDeduced.isNull()) 4982 return QualType(); 4983 } 4984 4985 QualType Result = TL.getType(); 4986 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced || 4987 T->isDependentType()) { 4988 Result = getDerived().RebuildAutoType(NewDeduced, T->isDecltypeAuto()); 4989 if (Result.isNull()) 4990 return QualType(); 4991 } 4992 4993 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 4994 NewTL.setNameLoc(TL.getNameLoc()); 4995 4996 return Result; 4997 } 4998 4999 template<typename Derived> 5000 QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 5001 RecordTypeLoc TL) { 5002 const RecordType *T = TL.getTypePtr(); 5003 RecordDecl *Record 5004 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 5005 T->getDecl())); 5006 if (!Record) 5007 return QualType(); 5008 5009 QualType Result = TL.getType(); 5010 if (getDerived().AlwaysRebuild() || 5011 Record != T->getDecl()) { 5012 Result = getDerived().RebuildRecordType(Record); 5013 if (Result.isNull()) 5014 return QualType(); 5015 } 5016 5017 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 5018 NewTL.setNameLoc(TL.getNameLoc()); 5019 5020 return Result; 5021 } 5022 5023 template<typename Derived> 5024 QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 5025 EnumTypeLoc TL) { 5026 const EnumType *T = TL.getTypePtr(); 5027 EnumDecl *Enum 5028 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 5029 T->getDecl())); 5030 if (!Enum) 5031 return QualType(); 5032 5033 QualType Result = TL.getType(); 5034 if (getDerived().AlwaysRebuild() || 5035 Enum != T->getDecl()) { 5036 Result = getDerived().RebuildEnumType(Enum); 5037 if (Result.isNull()) 5038 return QualType(); 5039 } 5040 5041 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 5042 NewTL.setNameLoc(TL.getNameLoc()); 5043 5044 return Result; 5045 } 5046 5047 template<typename Derived> 5048 QualType TreeTransform<Derived>::TransformInjectedClassNameType( 5049 TypeLocBuilder &TLB, 5050 InjectedClassNameTypeLoc TL) { 5051 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 5052 TL.getTypePtr()->getDecl()); 5053 if (!D) return QualType(); 5054 5055 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 5056 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 5057 return T; 5058 } 5059 5060 template<typename Derived> 5061 QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 5062 TypeLocBuilder &TLB, 5063 TemplateTypeParmTypeLoc TL) { 5064 return TransformTypeSpecType(TLB, TL); 5065 } 5066 5067 template<typename Derived> 5068 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 5069 TypeLocBuilder &TLB, 5070 SubstTemplateTypeParmTypeLoc TL) { 5071 const SubstTemplateTypeParmType *T = TL.getTypePtr(); 5072 5073 // Substitute into the replacement type, which itself might involve something 5074 // that needs to be transformed. This only tends to occur with default 5075 // template arguments of template template parameters. 5076 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName()); 5077 QualType Replacement = getDerived().TransformType(T->getReplacementType()); 5078 if (Replacement.isNull()) 5079 return QualType(); 5080 5081 // Always canonicalize the replacement type. 5082 Replacement = SemaRef.Context.getCanonicalType(Replacement); 5083 QualType Result 5084 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), 5085 Replacement); 5086 5087 // Propagate type-source information. 5088 SubstTemplateTypeParmTypeLoc NewTL 5089 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 5090 NewTL.setNameLoc(TL.getNameLoc()); 5091 return Result; 5092 5093 } 5094 5095 template<typename Derived> 5096 QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( 5097 TypeLocBuilder &TLB, 5098 SubstTemplateTypeParmPackTypeLoc TL) { 5099 return TransformTypeSpecType(TLB, TL); 5100 } 5101 5102 template<typename Derived> 5103 QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 5104 TypeLocBuilder &TLB, 5105 TemplateSpecializationTypeLoc TL) { 5106 const TemplateSpecializationType *T = TL.getTypePtr(); 5107 5108 // The nested-name-specifier never matters in a TemplateSpecializationType, 5109 // because we can't have a dependent nested-name-specifier anyway. 5110 CXXScopeSpec SS; 5111 TemplateName Template 5112 = getDerived().TransformTemplateName(SS, T->getTemplateName(), 5113 TL.getTemplateNameLoc()); 5114 if (Template.isNull()) 5115 return QualType(); 5116 5117 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 5118 } 5119 5120 template<typename Derived> 5121 QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB, 5122 AtomicTypeLoc TL) { 5123 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); 5124 if (ValueType.isNull()) 5125 return QualType(); 5126 5127 QualType Result = TL.getType(); 5128 if (getDerived().AlwaysRebuild() || 5129 ValueType != TL.getValueLoc().getType()) { 5130 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc()); 5131 if (Result.isNull()) 5132 return QualType(); 5133 } 5134 5135 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result); 5136 NewTL.setKWLoc(TL.getKWLoc()); 5137 NewTL.setLParenLoc(TL.getLParenLoc()); 5138 NewTL.setRParenLoc(TL.getRParenLoc()); 5139 5140 return Result; 5141 } 5142 5143 /// \brief Simple iterator that traverses the template arguments in a 5144 /// container that provides a \c getArgLoc() member function. 5145 /// 5146 /// This iterator is intended to be used with the iterator form of 5147 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 5148 template<typename ArgLocContainer> 5149 class TemplateArgumentLocContainerIterator { 5150 ArgLocContainer *Container; 5151 unsigned Index; 5152 5153 public: 5154 typedef TemplateArgumentLoc value_type; 5155 typedef TemplateArgumentLoc reference; 5156 typedef int difference_type; 5157 typedef std::input_iterator_tag iterator_category; 5158 5159 class pointer { 5160 TemplateArgumentLoc Arg; 5161 5162 public: 5163 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 5164 5165 const TemplateArgumentLoc *operator->() const { 5166 return &Arg; 5167 } 5168 }; 5169 5170 5171 TemplateArgumentLocContainerIterator() {} 5172 5173 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 5174 unsigned Index) 5175 : Container(&Container), Index(Index) { } 5176 5177 TemplateArgumentLocContainerIterator &operator++() { 5178 ++Index; 5179 return *this; 5180 } 5181 5182 TemplateArgumentLocContainerIterator operator++(int) { 5183 TemplateArgumentLocContainerIterator Old(*this); 5184 ++(*this); 5185 return Old; 5186 } 5187 5188 TemplateArgumentLoc operator*() const { 5189 return Container->getArgLoc(Index); 5190 } 5191 5192 pointer operator->() const { 5193 return pointer(Container->getArgLoc(Index)); 5194 } 5195 5196 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 5197 const TemplateArgumentLocContainerIterator &Y) { 5198 return X.Container == Y.Container && X.Index == Y.Index; 5199 } 5200 5201 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 5202 const TemplateArgumentLocContainerIterator &Y) { 5203 return !(X == Y); 5204 } 5205 }; 5206 5207 5208 template <typename Derived> 5209 QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 5210 TypeLocBuilder &TLB, 5211 TemplateSpecializationTypeLoc TL, 5212 TemplateName Template) { 5213 TemplateArgumentListInfo NewTemplateArgs; 5214 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 5215 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 5216 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 5217 ArgIterator; 5218 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 5219 ArgIterator(TL, TL.getNumArgs()), 5220 NewTemplateArgs)) 5221 return QualType(); 5222 5223 // FIXME: maybe don't rebuild if all the template arguments are the same. 5224 5225 QualType Result = 5226 getDerived().RebuildTemplateSpecializationType(Template, 5227 TL.getTemplateNameLoc(), 5228 NewTemplateArgs); 5229 5230 if (!Result.isNull()) { 5231 // Specializations of template template parameters are represented as 5232 // TemplateSpecializationTypes, and substitution of type alias templates 5233 // within a dependent context can transform them into 5234 // DependentTemplateSpecializationTypes. 5235 if (isa<DependentTemplateSpecializationType>(Result)) { 5236 DependentTemplateSpecializationTypeLoc NewTL 5237 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5238 NewTL.setElaboratedKeywordLoc(SourceLocation()); 5239 NewTL.setQualifierLoc(NestedNameSpecifierLoc()); 5240 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5241 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5242 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5243 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5244 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5245 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5246 return Result; 5247 } 5248 5249 TemplateSpecializationTypeLoc NewTL 5250 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5251 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5252 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5253 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5254 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5255 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5256 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5257 } 5258 5259 return Result; 5260 } 5261 5262 template <typename Derived> 5263 QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( 5264 TypeLocBuilder &TLB, 5265 DependentTemplateSpecializationTypeLoc TL, 5266 TemplateName Template, 5267 CXXScopeSpec &SS) { 5268 TemplateArgumentListInfo NewTemplateArgs; 5269 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 5270 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 5271 typedef TemplateArgumentLocContainerIterator< 5272 DependentTemplateSpecializationTypeLoc> ArgIterator; 5273 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 5274 ArgIterator(TL, TL.getNumArgs()), 5275 NewTemplateArgs)) 5276 return QualType(); 5277 5278 // FIXME: maybe don't rebuild if all the template arguments are the same. 5279 5280 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 5281 QualType Result 5282 = getSema().Context.getDependentTemplateSpecializationType( 5283 TL.getTypePtr()->getKeyword(), 5284 DTN->getQualifier(), 5285 DTN->getIdentifier(), 5286 NewTemplateArgs); 5287 5288 DependentTemplateSpecializationTypeLoc NewTL 5289 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5290 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5291 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context)); 5292 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5293 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5294 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5295 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5296 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5297 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5298 return Result; 5299 } 5300 5301 QualType Result 5302 = getDerived().RebuildTemplateSpecializationType(Template, 5303 TL.getTemplateNameLoc(), 5304 NewTemplateArgs); 5305 5306 if (!Result.isNull()) { 5307 /// FIXME: Wrap this in an elaborated-type-specifier? 5308 TemplateSpecializationTypeLoc NewTL 5309 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5310 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5311 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5312 NewTL.setLAngleLoc(TL.getLAngleLoc()); 5313 NewTL.setRAngleLoc(TL.getRAngleLoc()); 5314 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 5315 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 5316 } 5317 5318 return Result; 5319 } 5320 5321 template<typename Derived> 5322 QualType 5323 TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 5324 ElaboratedTypeLoc TL) { 5325 const ElaboratedType *T = TL.getTypePtr(); 5326 5327 NestedNameSpecifierLoc QualifierLoc; 5328 // NOTE: the qualifier in an ElaboratedType is optional. 5329 if (TL.getQualifierLoc()) { 5330 QualifierLoc 5331 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5332 if (!QualifierLoc) 5333 return QualType(); 5334 } 5335 5336 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 5337 if (NamedT.isNull()) 5338 return QualType(); 5339 5340 // C++0x [dcl.type.elab]p2: 5341 // If the identifier resolves to a typedef-name or the simple-template-id 5342 // resolves to an alias template specialization, the 5343 // elaborated-type-specifier is ill-formed. 5344 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) { 5345 if (const TemplateSpecializationType *TST = 5346 NamedT->getAs<TemplateSpecializationType>()) { 5347 TemplateName Template = TST->getTemplateName(); 5348 if (TypeAliasTemplateDecl *TAT = dyn_cast_or_null<TypeAliasTemplateDecl>( 5349 Template.getAsTemplateDecl())) { 5350 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(), 5351 diag::err_tag_reference_non_tag) << 4; 5352 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at); 5353 } 5354 } 5355 } 5356 5357 QualType Result = TL.getType(); 5358 if (getDerived().AlwaysRebuild() || 5359 QualifierLoc != TL.getQualifierLoc() || 5360 NamedT != T->getNamedType()) { 5361 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(), 5362 T->getKeyword(), 5363 QualifierLoc, NamedT); 5364 if (Result.isNull()) 5365 return QualType(); 5366 } 5367 5368 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5369 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5370 NewTL.setQualifierLoc(QualifierLoc); 5371 return Result; 5372 } 5373 5374 template<typename Derived> 5375 QualType TreeTransform<Derived>::TransformAttributedType( 5376 TypeLocBuilder &TLB, 5377 AttributedTypeLoc TL) { 5378 const AttributedType *oldType = TL.getTypePtr(); 5379 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); 5380 if (modifiedType.isNull()) 5381 return QualType(); 5382 5383 QualType result = TL.getType(); 5384 5385 // FIXME: dependent operand expressions? 5386 if (getDerived().AlwaysRebuild() || 5387 modifiedType != oldType->getModifiedType()) { 5388 // TODO: this is really lame; we should really be rebuilding the 5389 // equivalent type from first principles. 5390 QualType equivalentType 5391 = getDerived().TransformType(oldType->getEquivalentType()); 5392 if (equivalentType.isNull()) 5393 return QualType(); 5394 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), 5395 modifiedType, 5396 equivalentType); 5397 } 5398 5399 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); 5400 newTL.setAttrNameLoc(TL.getAttrNameLoc()); 5401 if (TL.hasAttrOperand()) 5402 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); 5403 if (TL.hasAttrExprOperand()) 5404 newTL.setAttrExprOperand(TL.getAttrExprOperand()); 5405 else if (TL.hasAttrEnumOperand()) 5406 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc()); 5407 5408 return result; 5409 } 5410 5411 template<typename Derived> 5412 QualType 5413 TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 5414 ParenTypeLoc TL) { 5415 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 5416 if (Inner.isNull()) 5417 return QualType(); 5418 5419 QualType Result = TL.getType(); 5420 if (getDerived().AlwaysRebuild() || 5421 Inner != TL.getInnerLoc().getType()) { 5422 Result = getDerived().RebuildParenType(Inner); 5423 if (Result.isNull()) 5424 return QualType(); 5425 } 5426 5427 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 5428 NewTL.setLParenLoc(TL.getLParenLoc()); 5429 NewTL.setRParenLoc(TL.getRParenLoc()); 5430 return Result; 5431 } 5432 5433 template<typename Derived> 5434 QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 5435 DependentNameTypeLoc TL) { 5436 const DependentNameType *T = TL.getTypePtr(); 5437 5438 NestedNameSpecifierLoc QualifierLoc 5439 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5440 if (!QualifierLoc) 5441 return QualType(); 5442 5443 QualType Result 5444 = getDerived().RebuildDependentNameType(T->getKeyword(), 5445 TL.getElaboratedKeywordLoc(), 5446 QualifierLoc, 5447 T->getIdentifier(), 5448 TL.getNameLoc()); 5449 if (Result.isNull()) 5450 return QualType(); 5451 5452 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 5453 QualType NamedT = ElabT->getNamedType(); 5454 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 5455 5456 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5457 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5458 NewTL.setQualifierLoc(QualifierLoc); 5459 } else { 5460 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 5461 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5462 NewTL.setQualifierLoc(QualifierLoc); 5463 NewTL.setNameLoc(TL.getNameLoc()); 5464 } 5465 return Result; 5466 } 5467 5468 template<typename Derived> 5469 QualType TreeTransform<Derived>:: 5470 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5471 DependentTemplateSpecializationTypeLoc TL) { 5472 NestedNameSpecifierLoc QualifierLoc; 5473 if (TL.getQualifierLoc()) { 5474 QualifierLoc 5475 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5476 if (!QualifierLoc) 5477 return QualType(); 5478 } 5479 5480 return getDerived() 5481 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc); 5482 } 5483 5484 template<typename Derived> 5485 QualType TreeTransform<Derived>:: 5486 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5487 DependentTemplateSpecializationTypeLoc TL, 5488 NestedNameSpecifierLoc QualifierLoc) { 5489 const DependentTemplateSpecializationType *T = TL.getTypePtr(); 5490 5491 TemplateArgumentListInfo NewTemplateArgs; 5492 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 5493 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 5494 5495 typedef TemplateArgumentLocContainerIterator< 5496 DependentTemplateSpecializationTypeLoc> ArgIterator; 5497 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 5498 ArgIterator(TL, TL.getNumArgs()), 5499 NewTemplateArgs)) 5500 return QualType(); 5501 5502 QualType Result 5503 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 5504 QualifierLoc, 5505 T->getIdentifier(), 5506 TL.getTemplateNameLoc(), 5507 NewTemplateArgs); 5508 if (Result.isNull()) 5509 return QualType(); 5510 5511 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 5512 QualType NamedT = ElabT->getNamedType(); 5513 5514 // Copy information relevant to the template specialization. 5515 TemplateSpecializationTypeLoc NamedTL 5516 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 5517 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5518 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5519 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 5520 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 5521 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5522 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5523 5524 // Copy information relevant to the elaborated type. 5525 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5526 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5527 NewTL.setQualifierLoc(QualifierLoc); 5528 } else if (isa<DependentTemplateSpecializationType>(Result)) { 5529 DependentTemplateSpecializationTypeLoc SpecTL 5530 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5531 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5532 SpecTL.setQualifierLoc(QualifierLoc); 5533 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5534 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5535 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5536 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5537 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5538 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5539 } else { 5540 TemplateSpecializationTypeLoc SpecTL 5541 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5542 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5543 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5544 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5545 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5546 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5547 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5548 } 5549 return Result; 5550 } 5551 5552 template<typename Derived> 5553 QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 5554 PackExpansionTypeLoc TL) { 5555 QualType Pattern 5556 = getDerived().TransformType(TLB, TL.getPatternLoc()); 5557 if (Pattern.isNull()) 5558 return QualType(); 5559 5560 QualType Result = TL.getType(); 5561 if (getDerived().AlwaysRebuild() || 5562 Pattern != TL.getPatternLoc().getType()) { 5563 Result = getDerived().RebuildPackExpansionType(Pattern, 5564 TL.getPatternLoc().getSourceRange(), 5565 TL.getEllipsisLoc(), 5566 TL.getTypePtr()->getNumExpansions()); 5567 if (Result.isNull()) 5568 return QualType(); 5569 } 5570 5571 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); 5572 NewT.setEllipsisLoc(TL.getEllipsisLoc()); 5573 return Result; 5574 } 5575 5576 template<typename Derived> 5577 QualType 5578 TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 5579 ObjCInterfaceTypeLoc TL) { 5580 // ObjCInterfaceType is never dependent. 5581 TLB.pushFullCopy(TL); 5582 return TL.getType(); 5583 } 5584 5585 template<typename Derived> 5586 QualType 5587 TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 5588 ObjCObjectTypeLoc TL) { 5589 // ObjCObjectType is never dependent. 5590 TLB.pushFullCopy(TL); 5591 return TL.getType(); 5592 } 5593 5594 template<typename Derived> 5595 QualType 5596 TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 5597 ObjCObjectPointerTypeLoc TL) { 5598 // ObjCObjectPointerType is never dependent. 5599 TLB.pushFullCopy(TL); 5600 return TL.getType(); 5601 } 5602 5603 //===----------------------------------------------------------------------===// 5604 // Statement transformation 5605 //===----------------------------------------------------------------------===// 5606 template<typename Derived> 5607 StmtResult 5608 TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 5609 return S; 5610 } 5611 5612 template<typename Derived> 5613 StmtResult 5614 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 5615 return getDerived().TransformCompoundStmt(S, false); 5616 } 5617 5618 template<typename Derived> 5619 StmtResult 5620 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 5621 bool IsStmtExpr) { 5622 Sema::CompoundScopeRAII CompoundScope(getSema()); 5623 5624 bool SubStmtInvalid = false; 5625 bool SubStmtChanged = false; 5626 SmallVector<Stmt*, 8> Statements; 5627 for (auto *B : S->body()) { 5628 StmtResult Result = getDerived().TransformStmt(B); 5629 if (Result.isInvalid()) { 5630 // Immediately fail if this was a DeclStmt, since it's very 5631 // likely that this will cause problems for future statements. 5632 if (isa<DeclStmt>(B)) 5633 return StmtError(); 5634 5635 // Otherwise, just keep processing substatements and fail later. 5636 SubStmtInvalid = true; 5637 continue; 5638 } 5639 5640 SubStmtChanged = SubStmtChanged || Result.get() != B; 5641 Statements.push_back(Result.getAs<Stmt>()); 5642 } 5643 5644 if (SubStmtInvalid) 5645 return StmtError(); 5646 5647 if (!getDerived().AlwaysRebuild() && 5648 !SubStmtChanged) 5649 return S; 5650 5651 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 5652 Statements, 5653 S->getRBracLoc(), 5654 IsStmtExpr); 5655 } 5656 5657 template<typename Derived> 5658 StmtResult 5659 TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 5660 ExprResult LHS, RHS; 5661 { 5662 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5663 Sema::ConstantEvaluated); 5664 5665 // Transform the left-hand case value. 5666 LHS = getDerived().TransformExpr(S->getLHS()); 5667 LHS = SemaRef.ActOnConstantExpression(LHS); 5668 if (LHS.isInvalid()) 5669 return StmtError(); 5670 5671 // Transform the right-hand case value (for the GNU case-range extension). 5672 RHS = getDerived().TransformExpr(S->getRHS()); 5673 RHS = SemaRef.ActOnConstantExpression(RHS); 5674 if (RHS.isInvalid()) 5675 return StmtError(); 5676 } 5677 5678 // Build the case statement. 5679 // Case statements are always rebuilt so that they will attached to their 5680 // transformed switch statement. 5681 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 5682 LHS.get(), 5683 S->getEllipsisLoc(), 5684 RHS.get(), 5685 S->getColonLoc()); 5686 if (Case.isInvalid()) 5687 return StmtError(); 5688 5689 // Transform the statement following the case 5690 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5691 if (SubStmt.isInvalid()) 5692 return StmtError(); 5693 5694 // Attach the body to the case statement 5695 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 5696 } 5697 5698 template<typename Derived> 5699 StmtResult 5700 TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 5701 // Transform the statement following the default case 5702 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5703 if (SubStmt.isInvalid()) 5704 return StmtError(); 5705 5706 // Default statements are always rebuilt 5707 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 5708 SubStmt.get()); 5709 } 5710 5711 template<typename Derived> 5712 StmtResult 5713 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 5714 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5715 if (SubStmt.isInvalid()) 5716 return StmtError(); 5717 5718 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), 5719 S->getDecl()); 5720 if (!LD) 5721 return StmtError(); 5722 5723 5724 // FIXME: Pass the real colon location in. 5725 return getDerived().RebuildLabelStmt(S->getIdentLoc(), 5726 cast<LabelDecl>(LD), SourceLocation(), 5727 SubStmt.get()); 5728 } 5729 5730 template <typename Derived> 5731 const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) { 5732 if (!R) 5733 return R; 5734 5735 switch (R->getKind()) { 5736 // Transform attributes with a pragma spelling by calling TransformXXXAttr. 5737 #define ATTR(X) 5738 #define PRAGMA_SPELLING_ATTR(X) \ 5739 case attr::X: \ 5740 return getDerived().Transform##X##Attr(cast<X##Attr>(R)); 5741 #include "clang/Basic/AttrList.inc" 5742 default: 5743 return R; 5744 } 5745 } 5746 5747 template <typename Derived> 5748 StmtResult TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) { 5749 bool AttrsChanged = false; 5750 SmallVector<const Attr *, 1> Attrs; 5751 5752 // Visit attributes and keep track if any are transformed. 5753 for (const auto *I : S->getAttrs()) { 5754 const Attr *R = getDerived().TransformAttr(I); 5755 AttrsChanged |= (I != R); 5756 Attrs.push_back(R); 5757 } 5758 5759 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5760 if (SubStmt.isInvalid()) 5761 return StmtError(); 5762 5763 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged) 5764 return S; 5765 5766 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs, 5767 SubStmt.get()); 5768 } 5769 5770 template<typename Derived> 5771 StmtResult 5772 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 5773 // Transform the condition 5774 ExprResult Cond; 5775 VarDecl *ConditionVar = nullptr; 5776 if (S->getConditionVariable()) { 5777 ConditionVar 5778 = cast_or_null<VarDecl>( 5779 getDerived().TransformDefinition( 5780 S->getConditionVariable()->getLocation(), 5781 S->getConditionVariable())); 5782 if (!ConditionVar) 5783 return StmtError(); 5784 } else { 5785 Cond = getDerived().TransformExpr(S->getCond()); 5786 5787 if (Cond.isInvalid()) 5788 return StmtError(); 5789 5790 // Convert the condition to a boolean value. 5791 if (S->getCond()) { 5792 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, S->getIfLoc(), 5793 Cond.get()); 5794 if (CondE.isInvalid()) 5795 return StmtError(); 5796 5797 Cond = CondE.get(); 5798 } 5799 } 5800 5801 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); 5802 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5803 return StmtError(); 5804 5805 // Transform the "then" branch. 5806 StmtResult Then = getDerived().TransformStmt(S->getThen()); 5807 if (Then.isInvalid()) 5808 return StmtError(); 5809 5810 // Transform the "else" branch. 5811 StmtResult Else = getDerived().TransformStmt(S->getElse()); 5812 if (Else.isInvalid()) 5813 return StmtError(); 5814 5815 if (!getDerived().AlwaysRebuild() && 5816 FullCond.get() == S->getCond() && 5817 ConditionVar == S->getConditionVariable() && 5818 Then.get() == S->getThen() && 5819 Else.get() == S->getElse()) 5820 return S; 5821 5822 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 5823 Then.get(), 5824 S->getElseLoc(), Else.get()); 5825 } 5826 5827 template<typename Derived> 5828 StmtResult 5829 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 5830 // Transform the condition. 5831 ExprResult Cond; 5832 VarDecl *ConditionVar = nullptr; 5833 if (S->getConditionVariable()) { 5834 ConditionVar 5835 = cast_or_null<VarDecl>( 5836 getDerived().TransformDefinition( 5837 S->getConditionVariable()->getLocation(), 5838 S->getConditionVariable())); 5839 if (!ConditionVar) 5840 return StmtError(); 5841 } else { 5842 Cond = getDerived().TransformExpr(S->getCond()); 5843 5844 if (Cond.isInvalid()) 5845 return StmtError(); 5846 } 5847 5848 // Rebuild the switch statement. 5849 StmtResult Switch 5850 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 5851 ConditionVar); 5852 if (Switch.isInvalid()) 5853 return StmtError(); 5854 5855 // Transform the body of the switch statement. 5856 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5857 if (Body.isInvalid()) 5858 return StmtError(); 5859 5860 // Complete the switch statement. 5861 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 5862 Body.get()); 5863 } 5864 5865 template<typename Derived> 5866 StmtResult 5867 TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 5868 // Transform the condition 5869 ExprResult Cond; 5870 VarDecl *ConditionVar = nullptr; 5871 if (S->getConditionVariable()) { 5872 ConditionVar 5873 = cast_or_null<VarDecl>( 5874 getDerived().TransformDefinition( 5875 S->getConditionVariable()->getLocation(), 5876 S->getConditionVariable())); 5877 if (!ConditionVar) 5878 return StmtError(); 5879 } else { 5880 Cond = getDerived().TransformExpr(S->getCond()); 5881 5882 if (Cond.isInvalid()) 5883 return StmtError(); 5884 5885 if (S->getCond()) { 5886 // Convert the condition to a boolean value. 5887 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, 5888 S->getWhileLoc(), 5889 Cond.get()); 5890 if (CondE.isInvalid()) 5891 return StmtError(); 5892 Cond = CondE; 5893 } 5894 } 5895 5896 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); 5897 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5898 return StmtError(); 5899 5900 // Transform the body 5901 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5902 if (Body.isInvalid()) 5903 return StmtError(); 5904 5905 if (!getDerived().AlwaysRebuild() && 5906 FullCond.get() == S->getCond() && 5907 ConditionVar == S->getConditionVariable() && 5908 Body.get() == S->getBody()) 5909 return Owned(S); 5910 5911 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 5912 ConditionVar, Body.get()); 5913 } 5914 5915 template<typename Derived> 5916 StmtResult 5917 TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 5918 // Transform the body 5919 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5920 if (Body.isInvalid()) 5921 return StmtError(); 5922 5923 // Transform the condition 5924 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5925 if (Cond.isInvalid()) 5926 return StmtError(); 5927 5928 if (!getDerived().AlwaysRebuild() && 5929 Cond.get() == S->getCond() && 5930 Body.get() == S->getBody()) 5931 return S; 5932 5933 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 5934 /*FIXME:*/S->getWhileLoc(), Cond.get(), 5935 S->getRParenLoc()); 5936 } 5937 5938 template<typename Derived> 5939 StmtResult 5940 TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 5941 // Transform the initialization statement 5942 StmtResult Init = getDerived().TransformStmt(S->getInit()); 5943 if (Init.isInvalid()) 5944 return StmtError(); 5945 5946 // Transform the condition 5947 ExprResult Cond; 5948 VarDecl *ConditionVar = nullptr; 5949 if (S->getConditionVariable()) { 5950 ConditionVar 5951 = cast_or_null<VarDecl>( 5952 getDerived().TransformDefinition( 5953 S->getConditionVariable()->getLocation(), 5954 S->getConditionVariable())); 5955 if (!ConditionVar) 5956 return StmtError(); 5957 } else { 5958 Cond = getDerived().TransformExpr(S->getCond()); 5959 5960 if (Cond.isInvalid()) 5961 return StmtError(); 5962 5963 if (S->getCond()) { 5964 // Convert the condition to a boolean value. 5965 ExprResult CondE = getSema().ActOnBooleanCondition(nullptr, 5966 S->getForLoc(), 5967 Cond.get()); 5968 if (CondE.isInvalid()) 5969 return StmtError(); 5970 5971 Cond = CondE.get(); 5972 } 5973 } 5974 5975 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.get())); 5976 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5977 return StmtError(); 5978 5979 // Transform the increment 5980 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5981 if (Inc.isInvalid()) 5982 return StmtError(); 5983 5984 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get())); 5985 if (S->getInc() && !FullInc.get()) 5986 return StmtError(); 5987 5988 // Transform the body 5989 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5990 if (Body.isInvalid()) 5991 return StmtError(); 5992 5993 if (!getDerived().AlwaysRebuild() && 5994 Init.get() == S->getInit() && 5995 FullCond.get() == S->getCond() && 5996 Inc.get() == S->getInc() && 5997 Body.get() == S->getBody()) 5998 return S; 5999 6000 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 6001 Init.get(), FullCond, ConditionVar, 6002 FullInc, S->getRParenLoc(), Body.get()); 6003 } 6004 6005 template<typename Derived> 6006 StmtResult 6007 TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 6008 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), 6009 S->getLabel()); 6010 if (!LD) 6011 return StmtError(); 6012 6013 // Goto statements must always be rebuilt, to resolve the label. 6014 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 6015 cast<LabelDecl>(LD)); 6016 } 6017 6018 template<typename Derived> 6019 StmtResult 6020 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 6021 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 6022 if (Target.isInvalid()) 6023 return StmtError(); 6024 Target = SemaRef.MaybeCreateExprWithCleanups(Target.get()); 6025 6026 if (!getDerived().AlwaysRebuild() && 6027 Target.get() == S->getTarget()) 6028 return S; 6029 6030 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 6031 Target.get()); 6032 } 6033 6034 template<typename Derived> 6035 StmtResult 6036 TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 6037 return S; 6038 } 6039 6040 template<typename Derived> 6041 StmtResult 6042 TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 6043 return S; 6044 } 6045 6046 template<typename Derived> 6047 StmtResult 6048 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 6049 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(), 6050 /*NotCopyInit*/false); 6051 if (Result.isInvalid()) 6052 return StmtError(); 6053 6054 // FIXME: We always rebuild the return statement because there is no way 6055 // to tell whether the return type of the function has changed. 6056 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 6057 } 6058 6059 template<typename Derived> 6060 StmtResult 6061 TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 6062 bool DeclChanged = false; 6063 SmallVector<Decl *, 4> Decls; 6064 for (auto *D : S->decls()) { 6065 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D); 6066 if (!Transformed) 6067 return StmtError(); 6068 6069 if (Transformed != D) 6070 DeclChanged = true; 6071 6072 Decls.push_back(Transformed); 6073 } 6074 6075 if (!getDerived().AlwaysRebuild() && !DeclChanged) 6076 return S; 6077 6078 return getDerived().RebuildDeclStmt(Decls, S->getStartLoc(), S->getEndLoc()); 6079 } 6080 6081 template<typename Derived> 6082 StmtResult 6083 TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { 6084 6085 SmallVector<Expr*, 8> Constraints; 6086 SmallVector<Expr*, 8> Exprs; 6087 SmallVector<IdentifierInfo *, 4> Names; 6088 6089 ExprResult AsmString; 6090 SmallVector<Expr*, 8> Clobbers; 6091 6092 bool ExprsChanged = false; 6093 6094 // Go through the outputs. 6095 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 6096 Names.push_back(S->getOutputIdentifier(I)); 6097 6098 // No need to transform the constraint literal. 6099 Constraints.push_back(S->getOutputConstraintLiteral(I)); 6100 6101 // Transform the output expr. 6102 Expr *OutputExpr = S->getOutputExpr(I); 6103 ExprResult Result = getDerived().TransformExpr(OutputExpr); 6104 if (Result.isInvalid()) 6105 return StmtError(); 6106 6107 ExprsChanged |= Result.get() != OutputExpr; 6108 6109 Exprs.push_back(Result.get()); 6110 } 6111 6112 // Go through the inputs. 6113 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 6114 Names.push_back(S->getInputIdentifier(I)); 6115 6116 // No need to transform the constraint literal. 6117 Constraints.push_back(S->getInputConstraintLiteral(I)); 6118 6119 // Transform the input expr. 6120 Expr *InputExpr = S->getInputExpr(I); 6121 ExprResult Result = getDerived().TransformExpr(InputExpr); 6122 if (Result.isInvalid()) 6123 return StmtError(); 6124 6125 ExprsChanged |= Result.get() != InputExpr; 6126 6127 Exprs.push_back(Result.get()); 6128 } 6129 6130 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 6131 return S; 6132 6133 // Go through the clobbers. 6134 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 6135 Clobbers.push_back(S->getClobberStringLiteral(I)); 6136 6137 // No need to transform the asm string literal. 6138 AsmString = S->getAsmString(); 6139 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), 6140 S->isVolatile(), S->getNumOutputs(), 6141 S->getNumInputs(), Names.data(), 6142 Constraints, Exprs, AsmString.get(), 6143 Clobbers, S->getRParenLoc()); 6144 } 6145 6146 template<typename Derived> 6147 StmtResult 6148 TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { 6149 ArrayRef<Token> AsmToks = 6150 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); 6151 6152 bool HadError = false, HadChange = false; 6153 6154 ArrayRef<Expr*> SrcExprs = S->getAllExprs(); 6155 SmallVector<Expr*, 8> TransformedExprs; 6156 TransformedExprs.reserve(SrcExprs.size()); 6157 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) { 6158 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]); 6159 if (!Result.isUsable()) { 6160 HadError = true; 6161 } else { 6162 HadChange |= (Result.get() != SrcExprs[i]); 6163 TransformedExprs.push_back(Result.get()); 6164 } 6165 } 6166 6167 if (HadError) return StmtError(); 6168 if (!HadChange && !getDerived().AlwaysRebuild()) 6169 return Owned(S); 6170 6171 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(), 6172 AsmToks, S->getAsmString(), 6173 S->getNumOutputs(), S->getNumInputs(), 6174 S->getAllConstraints(), S->getClobbers(), 6175 TransformedExprs, S->getEndLoc()); 6176 } 6177 6178 template<typename Derived> 6179 StmtResult 6180 TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 6181 // Transform the body of the @try. 6182 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 6183 if (TryBody.isInvalid()) 6184 return StmtError(); 6185 6186 // Transform the @catch statements (if present). 6187 bool AnyCatchChanged = false; 6188 SmallVector<Stmt*, 8> CatchStmts; 6189 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 6190 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 6191 if (Catch.isInvalid()) 6192 return StmtError(); 6193 if (Catch.get() != S->getCatchStmt(I)) 6194 AnyCatchChanged = true; 6195 CatchStmts.push_back(Catch.get()); 6196 } 6197 6198 // Transform the @finally statement (if present). 6199 StmtResult Finally; 6200 if (S->getFinallyStmt()) { 6201 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 6202 if (Finally.isInvalid()) 6203 return StmtError(); 6204 } 6205 6206 // If nothing changed, just retain this statement. 6207 if (!getDerived().AlwaysRebuild() && 6208 TryBody.get() == S->getTryBody() && 6209 !AnyCatchChanged && 6210 Finally.get() == S->getFinallyStmt()) 6211 return S; 6212 6213 // Build a new statement. 6214 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 6215 CatchStmts, Finally.get()); 6216 } 6217 6218 template<typename Derived> 6219 StmtResult 6220 TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 6221 // Transform the @catch parameter, if there is one. 6222 VarDecl *Var = nullptr; 6223 if (VarDecl *FromVar = S->getCatchParamDecl()) { 6224 TypeSourceInfo *TSInfo = nullptr; 6225 if (FromVar->getTypeSourceInfo()) { 6226 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 6227 if (!TSInfo) 6228 return StmtError(); 6229 } 6230 6231 QualType T; 6232 if (TSInfo) 6233 T = TSInfo->getType(); 6234 else { 6235 T = getDerived().TransformType(FromVar->getType()); 6236 if (T.isNull()) 6237 return StmtError(); 6238 } 6239 6240 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 6241 if (!Var) 6242 return StmtError(); 6243 } 6244 6245 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 6246 if (Body.isInvalid()) 6247 return StmtError(); 6248 6249 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 6250 S->getRParenLoc(), 6251 Var, Body.get()); 6252 } 6253 6254 template<typename Derived> 6255 StmtResult 6256 TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 6257 // Transform the body. 6258 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 6259 if (Body.isInvalid()) 6260 return StmtError(); 6261 6262 // If nothing changed, just retain this statement. 6263 if (!getDerived().AlwaysRebuild() && 6264 Body.get() == S->getFinallyBody()) 6265 return S; 6266 6267 // Build a new statement. 6268 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 6269 Body.get()); 6270 } 6271 6272 template<typename Derived> 6273 StmtResult 6274 TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 6275 ExprResult Operand; 6276 if (S->getThrowExpr()) { 6277 Operand = getDerived().TransformExpr(S->getThrowExpr()); 6278 if (Operand.isInvalid()) 6279 return StmtError(); 6280 } 6281 6282 if (!getDerived().AlwaysRebuild() && 6283 Operand.get() == S->getThrowExpr()) 6284 return S; 6285 6286 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 6287 } 6288 6289 template<typename Derived> 6290 StmtResult 6291 TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 6292 ObjCAtSynchronizedStmt *S) { 6293 // Transform the object we are locking. 6294 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 6295 if (Object.isInvalid()) 6296 return StmtError(); 6297 Object = 6298 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(), 6299 Object.get()); 6300 if (Object.isInvalid()) 6301 return StmtError(); 6302 6303 // Transform the body. 6304 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 6305 if (Body.isInvalid()) 6306 return StmtError(); 6307 6308 // If nothing change, just retain the current statement. 6309 if (!getDerived().AlwaysRebuild() && 6310 Object.get() == S->getSynchExpr() && 6311 Body.get() == S->getSynchBody()) 6312 return S; 6313 6314 // Build a new statement. 6315 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 6316 Object.get(), Body.get()); 6317 } 6318 6319 template<typename Derived> 6320 StmtResult 6321 TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( 6322 ObjCAutoreleasePoolStmt *S) { 6323 // Transform the body. 6324 StmtResult Body = getDerived().TransformStmt(S->getSubStmt()); 6325 if (Body.isInvalid()) 6326 return StmtError(); 6327 6328 // If nothing changed, just retain this statement. 6329 if (!getDerived().AlwaysRebuild() && 6330 Body.get() == S->getSubStmt()) 6331 return S; 6332 6333 // Build a new statement. 6334 return getDerived().RebuildObjCAutoreleasePoolStmt( 6335 S->getAtLoc(), Body.get()); 6336 } 6337 6338 template<typename Derived> 6339 StmtResult 6340 TreeTransform<Derived>::TransformObjCForCollectionStmt( 6341 ObjCForCollectionStmt *S) { 6342 // Transform the element statement. 6343 StmtResult Element = getDerived().TransformStmt(S->getElement()); 6344 if (Element.isInvalid()) 6345 return StmtError(); 6346 6347 // Transform the collection expression. 6348 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 6349 if (Collection.isInvalid()) 6350 return StmtError(); 6351 6352 // Transform the body. 6353 StmtResult Body = getDerived().TransformStmt(S->getBody()); 6354 if (Body.isInvalid()) 6355 return StmtError(); 6356 6357 // If nothing changed, just retain this statement. 6358 if (!getDerived().AlwaysRebuild() && 6359 Element.get() == S->getElement() && 6360 Collection.get() == S->getCollection() && 6361 Body.get() == S->getBody()) 6362 return S; 6363 6364 // Build a new statement. 6365 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 6366 Element.get(), 6367 Collection.get(), 6368 S->getRParenLoc(), 6369 Body.get()); 6370 } 6371 6372 template <typename Derived> 6373 StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 6374 // Transform the exception declaration, if any. 6375 VarDecl *Var = nullptr; 6376 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) { 6377 TypeSourceInfo *T = 6378 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo()); 6379 if (!T) 6380 return StmtError(); 6381 6382 Var = getDerived().RebuildExceptionDecl( 6383 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(), 6384 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier()); 6385 if (!Var || Var->isInvalidDecl()) 6386 return StmtError(); 6387 } 6388 6389 // Transform the actual exception handler. 6390 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 6391 if (Handler.isInvalid()) 6392 return StmtError(); 6393 6394 if (!getDerived().AlwaysRebuild() && !Var && 6395 Handler.get() == S->getHandlerBlock()) 6396 return S; 6397 6398 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get()); 6399 } 6400 6401 template <typename Derived> 6402 StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 6403 // Transform the try block itself. 6404 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); 6405 if (TryBlock.isInvalid()) 6406 return StmtError(); 6407 6408 // Transform the handlers. 6409 bool HandlerChanged = false; 6410 SmallVector<Stmt *, 8> Handlers; 6411 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 6412 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 6413 if (Handler.isInvalid()) 6414 return StmtError(); 6415 6416 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 6417 Handlers.push_back(Handler.getAs<Stmt>()); 6418 } 6419 6420 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && 6421 !HandlerChanged) 6422 return S; 6423 6424 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 6425 Handlers); 6426 } 6427 6428 template<typename Derived> 6429 StmtResult 6430 TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { 6431 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt()); 6432 if (Range.isInvalid()) 6433 return StmtError(); 6434 6435 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt()); 6436 if (BeginEnd.isInvalid()) 6437 return StmtError(); 6438 6439 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 6440 if (Cond.isInvalid()) 6441 return StmtError(); 6442 if (Cond.get()) 6443 Cond = SemaRef.CheckBooleanCondition(Cond.get(), S->getColonLoc()); 6444 if (Cond.isInvalid()) 6445 return StmtError(); 6446 if (Cond.get()) 6447 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.get()); 6448 6449 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 6450 if (Inc.isInvalid()) 6451 return StmtError(); 6452 if (Inc.get()) 6453 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.get()); 6454 6455 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); 6456 if (LoopVar.isInvalid()) 6457 return StmtError(); 6458 6459 StmtResult NewStmt = S; 6460 if (getDerived().AlwaysRebuild() || 6461 Range.get() != S->getRangeStmt() || 6462 BeginEnd.get() != S->getBeginEndStmt() || 6463 Cond.get() != S->getCond() || 6464 Inc.get() != S->getInc() || 6465 LoopVar.get() != S->getLoopVarStmt()) { 6466 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 6467 S->getColonLoc(), Range.get(), 6468 BeginEnd.get(), Cond.get(), 6469 Inc.get(), LoopVar.get(), 6470 S->getRParenLoc()); 6471 if (NewStmt.isInvalid()) 6472 return StmtError(); 6473 } 6474 6475 StmtResult Body = getDerived().TransformStmt(S->getBody()); 6476 if (Body.isInvalid()) 6477 return StmtError(); 6478 6479 // Body has changed but we didn't rebuild the for-range statement. Rebuild 6480 // it now so we have a new statement to attach the body to. 6481 if (Body.get() != S->getBody() && NewStmt.get() == S) { 6482 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 6483 S->getColonLoc(), Range.get(), 6484 BeginEnd.get(), Cond.get(), 6485 Inc.get(), LoopVar.get(), 6486 S->getRParenLoc()); 6487 if (NewStmt.isInvalid()) 6488 return StmtError(); 6489 } 6490 6491 if (NewStmt.get() == S) 6492 return S; 6493 6494 return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); 6495 } 6496 6497 template<typename Derived> 6498 StmtResult 6499 TreeTransform<Derived>::TransformMSDependentExistsStmt( 6500 MSDependentExistsStmt *S) { 6501 // Transform the nested-name-specifier, if any. 6502 NestedNameSpecifierLoc QualifierLoc; 6503 if (S->getQualifierLoc()) { 6504 QualifierLoc 6505 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc()); 6506 if (!QualifierLoc) 6507 return StmtError(); 6508 } 6509 6510 // Transform the declaration name. 6511 DeclarationNameInfo NameInfo = S->getNameInfo(); 6512 if (NameInfo.getName()) { 6513 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6514 if (!NameInfo.getName()) 6515 return StmtError(); 6516 } 6517 6518 // Check whether anything changed. 6519 if (!getDerived().AlwaysRebuild() && 6520 QualifierLoc == S->getQualifierLoc() && 6521 NameInfo.getName() == S->getNameInfo().getName()) 6522 return S; 6523 6524 // Determine whether this name exists, if we can. 6525 CXXScopeSpec SS; 6526 SS.Adopt(QualifierLoc); 6527 bool Dependent = false; 6528 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) { 6529 case Sema::IER_Exists: 6530 if (S->isIfExists()) 6531 break; 6532 6533 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6534 6535 case Sema::IER_DoesNotExist: 6536 if (S->isIfNotExists()) 6537 break; 6538 6539 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6540 6541 case Sema::IER_Dependent: 6542 Dependent = true; 6543 break; 6544 6545 case Sema::IER_Error: 6546 return StmtError(); 6547 } 6548 6549 // We need to continue with the instantiation, so do so now. 6550 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt()); 6551 if (SubStmt.isInvalid()) 6552 return StmtError(); 6553 6554 // If we have resolved the name, just transform to the substatement. 6555 if (!Dependent) 6556 return SubStmt; 6557 6558 // The name is still dependent, so build a dependent expression again. 6559 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(), 6560 S->isIfExists(), 6561 QualifierLoc, 6562 NameInfo, 6563 SubStmt.get()); 6564 } 6565 6566 template<typename Derived> 6567 ExprResult 6568 TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) { 6569 NestedNameSpecifierLoc QualifierLoc; 6570 if (E->getQualifierLoc()) { 6571 QualifierLoc 6572 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6573 if (!QualifierLoc) 6574 return ExprError(); 6575 } 6576 6577 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>( 6578 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl())); 6579 if (!PD) 6580 return ExprError(); 6581 6582 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 6583 if (Base.isInvalid()) 6584 return ExprError(); 6585 6586 return new (SemaRef.getASTContext()) 6587 MSPropertyRefExpr(Base.get(), PD, E->isArrow(), 6588 SemaRef.getASTContext().PseudoObjectTy, VK_LValue, 6589 QualifierLoc, E->getMemberLoc()); 6590 } 6591 6592 template <typename Derived> 6593 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { 6594 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock()); 6595 if (TryBlock.isInvalid()) 6596 return StmtError(); 6597 6598 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler()); 6599 if (Handler.isInvalid()) 6600 return StmtError(); 6601 6602 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() && 6603 Handler.get() == S->getHandler()) 6604 return S; 6605 6606 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(), 6607 TryBlock.get(), Handler.get()); 6608 } 6609 6610 template <typename Derived> 6611 StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { 6612 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); 6613 if (Block.isInvalid()) 6614 return StmtError(); 6615 6616 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get()); 6617 } 6618 6619 template <typename Derived> 6620 StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { 6621 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr()); 6622 if (FilterExpr.isInvalid()) 6623 return StmtError(); 6624 6625 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock()); 6626 if (Block.isInvalid()) 6627 return StmtError(); 6628 6629 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(), 6630 Block.get()); 6631 } 6632 6633 template <typename Derived> 6634 StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { 6635 if (isa<SEHFinallyStmt>(Handler)) 6636 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler)); 6637 else 6638 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler)); 6639 } 6640 6641 template<typename Derived> 6642 StmtResult 6643 TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) { 6644 return S; 6645 } 6646 6647 //===----------------------------------------------------------------------===// 6648 // OpenMP directive transformation 6649 //===----------------------------------------------------------------------===// 6650 template <typename Derived> 6651 StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective( 6652 OMPExecutableDirective *D) { 6653 6654 // Transform the clauses 6655 llvm::SmallVector<OMPClause *, 16> TClauses; 6656 ArrayRef<OMPClause *> Clauses = D->clauses(); 6657 TClauses.reserve(Clauses.size()); 6658 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); 6659 I != E; ++I) { 6660 if (*I) { 6661 OMPClause *Clause = getDerived().TransformOMPClause(*I); 6662 if (Clause) 6663 TClauses.push_back(Clause); 6664 } else { 6665 TClauses.push_back(nullptr); 6666 } 6667 } 6668 StmtResult AssociatedStmt; 6669 if (D->hasAssociatedStmt()) { 6670 if (!D->getAssociatedStmt()) { 6671 return StmtError(); 6672 } 6673 getDerived().getSema().ActOnOpenMPRegionStart(D->getDirectiveKind(), 6674 /*CurScope=*/nullptr); 6675 StmtResult Body; 6676 { 6677 Sema::CompoundScopeRAII CompoundScope(getSema()); 6678 Body = getDerived().TransformStmt( 6679 cast<CapturedStmt>(D->getAssociatedStmt())->getCapturedStmt()); 6680 } 6681 AssociatedStmt = 6682 getDerived().getSema().ActOnOpenMPRegionEnd(Body, TClauses); 6683 if (AssociatedStmt.isInvalid()) { 6684 return StmtError(); 6685 } 6686 } 6687 if (TClauses.size() != Clauses.size()) { 6688 return StmtError(); 6689 } 6690 6691 // Transform directive name for 'omp critical' directive. 6692 DeclarationNameInfo DirName; 6693 if (D->getDirectiveKind() == OMPD_critical) { 6694 DirName = cast<OMPCriticalDirective>(D)->getDirectiveName(); 6695 DirName = getDerived().TransformDeclarationNameInfo(DirName); 6696 } 6697 6698 return getDerived().RebuildOMPExecutableDirective( 6699 D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.get(), 6700 D->getLocStart(), D->getLocEnd()); 6701 } 6702 6703 template <typename Derived> 6704 StmtResult 6705 TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) { 6706 DeclarationNameInfo DirName; 6707 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, nullptr, 6708 D->getLocStart()); 6709 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6710 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6711 return Res; 6712 } 6713 6714 template <typename Derived> 6715 StmtResult 6716 TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) { 6717 DeclarationNameInfo DirName; 6718 getDerived().getSema().StartOpenMPDSABlock(OMPD_simd, DirName, nullptr, 6719 D->getLocStart()); 6720 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6721 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6722 return Res; 6723 } 6724 6725 template <typename Derived> 6726 StmtResult 6727 TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) { 6728 DeclarationNameInfo DirName; 6729 getDerived().getSema().StartOpenMPDSABlock(OMPD_for, DirName, nullptr, 6730 D->getLocStart()); 6731 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6732 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6733 return Res; 6734 } 6735 6736 template <typename Derived> 6737 StmtResult 6738 TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) { 6739 DeclarationNameInfo DirName; 6740 getDerived().getSema().StartOpenMPDSABlock(OMPD_for_simd, DirName, nullptr, 6741 D->getLocStart()); 6742 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6743 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6744 return Res; 6745 } 6746 6747 template <typename Derived> 6748 StmtResult 6749 TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) { 6750 DeclarationNameInfo DirName; 6751 getDerived().getSema().StartOpenMPDSABlock(OMPD_sections, DirName, nullptr, 6752 D->getLocStart()); 6753 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6754 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6755 return Res; 6756 } 6757 6758 template <typename Derived> 6759 StmtResult 6760 TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) { 6761 DeclarationNameInfo DirName; 6762 getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr, 6763 D->getLocStart()); 6764 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6765 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6766 return Res; 6767 } 6768 6769 template <typename Derived> 6770 StmtResult 6771 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) { 6772 DeclarationNameInfo DirName; 6773 getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr, 6774 D->getLocStart()); 6775 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6776 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6777 return Res; 6778 } 6779 6780 template <typename Derived> 6781 StmtResult 6782 TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) { 6783 DeclarationNameInfo DirName; 6784 getDerived().getSema().StartOpenMPDSABlock(OMPD_master, DirName, nullptr, 6785 D->getLocStart()); 6786 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6787 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6788 return Res; 6789 } 6790 6791 template <typename Derived> 6792 StmtResult 6793 TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) { 6794 getDerived().getSema().StartOpenMPDSABlock( 6795 OMPD_critical, D->getDirectiveName(), nullptr, D->getLocStart()); 6796 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6797 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6798 return Res; 6799 } 6800 6801 template <typename Derived> 6802 StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective( 6803 OMPParallelForDirective *D) { 6804 DeclarationNameInfo DirName; 6805 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for, DirName, 6806 nullptr, D->getLocStart()); 6807 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6808 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6809 return Res; 6810 } 6811 6812 template <typename Derived> 6813 StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective( 6814 OMPParallelForSimdDirective *D) { 6815 DeclarationNameInfo DirName; 6816 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_for_simd, DirName, 6817 nullptr, D->getLocStart()); 6818 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6819 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6820 return Res; 6821 } 6822 6823 template <typename Derived> 6824 StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective( 6825 OMPParallelSectionsDirective *D) { 6826 DeclarationNameInfo DirName; 6827 getDerived().getSema().StartOpenMPDSABlock(OMPD_parallel_sections, DirName, 6828 nullptr, D->getLocStart()); 6829 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6830 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6831 return Res; 6832 } 6833 6834 template <typename Derived> 6835 StmtResult 6836 TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) { 6837 DeclarationNameInfo DirName; 6838 getDerived().getSema().StartOpenMPDSABlock(OMPD_task, DirName, nullptr, 6839 D->getLocStart()); 6840 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6841 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6842 return Res; 6843 } 6844 6845 template <typename Derived> 6846 StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective( 6847 OMPTaskyieldDirective *D) { 6848 DeclarationNameInfo DirName; 6849 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskyield, DirName, nullptr, 6850 D->getLocStart()); 6851 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6852 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6853 return Res; 6854 } 6855 6856 template <typename Derived> 6857 StmtResult 6858 TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) { 6859 DeclarationNameInfo DirName; 6860 getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr, 6861 D->getLocStart()); 6862 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6863 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6864 return Res; 6865 } 6866 6867 template <typename Derived> 6868 StmtResult 6869 TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) { 6870 DeclarationNameInfo DirName; 6871 getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr, 6872 D->getLocStart()); 6873 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6874 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6875 return Res; 6876 } 6877 6878 template <typename Derived> 6879 StmtResult 6880 TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) { 6881 DeclarationNameInfo DirName; 6882 getDerived().getSema().StartOpenMPDSABlock(OMPD_flush, DirName, nullptr, 6883 D->getLocStart()); 6884 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6885 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6886 return Res; 6887 } 6888 6889 template <typename Derived> 6890 StmtResult 6891 TreeTransform<Derived>::TransformOMPOrderedDirective(OMPOrderedDirective *D) { 6892 DeclarationNameInfo DirName; 6893 getDerived().getSema().StartOpenMPDSABlock(OMPD_ordered, DirName, nullptr, 6894 D->getLocStart()); 6895 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6896 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6897 return Res; 6898 } 6899 6900 template <typename Derived> 6901 StmtResult 6902 TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) { 6903 DeclarationNameInfo DirName; 6904 getDerived().getSema().StartOpenMPDSABlock(OMPD_atomic, DirName, nullptr, 6905 D->getLocStart()); 6906 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6907 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6908 return Res; 6909 } 6910 6911 template <typename Derived> 6912 StmtResult 6913 TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) { 6914 DeclarationNameInfo DirName; 6915 getDerived().getSema().StartOpenMPDSABlock(OMPD_target, DirName, nullptr, 6916 D->getLocStart()); 6917 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6918 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6919 return Res; 6920 } 6921 6922 template <typename Derived> 6923 StmtResult 6924 TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) { 6925 DeclarationNameInfo DirName; 6926 getDerived().getSema().StartOpenMPDSABlock(OMPD_teams, DirName, nullptr, 6927 D->getLocStart()); 6928 StmtResult Res = getDerived().TransformOMPExecutableDirective(D); 6929 getDerived().getSema().EndOpenMPDSABlock(Res.get()); 6930 return Res; 6931 } 6932 6933 //===----------------------------------------------------------------------===// 6934 // OpenMP clause transformation 6935 //===----------------------------------------------------------------------===// 6936 template <typename Derived> 6937 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) { 6938 ExprResult Cond = getDerived().TransformExpr(C->getCondition()); 6939 if (Cond.isInvalid()) 6940 return nullptr; 6941 return getDerived().RebuildOMPIfClause(Cond.get(), C->getLocStart(), 6942 C->getLParenLoc(), C->getLocEnd()); 6943 } 6944 6945 template <typename Derived> 6946 OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) { 6947 ExprResult Cond = getDerived().TransformExpr(C->getCondition()); 6948 if (Cond.isInvalid()) 6949 return nullptr; 6950 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getLocStart(), 6951 C->getLParenLoc(), C->getLocEnd()); 6952 } 6953 6954 template <typename Derived> 6955 OMPClause * 6956 TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) { 6957 ExprResult NumThreads = getDerived().TransformExpr(C->getNumThreads()); 6958 if (NumThreads.isInvalid()) 6959 return nullptr; 6960 return getDerived().RebuildOMPNumThreadsClause( 6961 NumThreads.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 6962 } 6963 6964 template <typename Derived> 6965 OMPClause * 6966 TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) { 6967 ExprResult E = getDerived().TransformExpr(C->getSafelen()); 6968 if (E.isInvalid()) 6969 return nullptr; 6970 return getDerived().RebuildOMPSafelenClause( 6971 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 6972 } 6973 6974 template <typename Derived> 6975 OMPClause * 6976 TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) { 6977 ExprResult E = getDerived().TransformExpr(C->getNumForLoops()); 6978 if (E.isInvalid()) 6979 return 0; 6980 return getDerived().RebuildOMPCollapseClause( 6981 E.get(), C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 6982 } 6983 6984 template <typename Derived> 6985 OMPClause * 6986 TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) { 6987 return getDerived().RebuildOMPDefaultClause( 6988 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getLocStart(), 6989 C->getLParenLoc(), C->getLocEnd()); 6990 } 6991 6992 template <typename Derived> 6993 OMPClause * 6994 TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) { 6995 return getDerived().RebuildOMPProcBindClause( 6996 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getLocStart(), 6997 C->getLParenLoc(), C->getLocEnd()); 6998 } 6999 7000 template <typename Derived> 7001 OMPClause * 7002 TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) { 7003 ExprResult E = getDerived().TransformExpr(C->getChunkSize()); 7004 if (E.isInvalid()) 7005 return nullptr; 7006 return getDerived().RebuildOMPScheduleClause( 7007 C->getScheduleKind(), E.get(), C->getLocStart(), C->getLParenLoc(), 7008 C->getScheduleKindLoc(), C->getCommaLoc(), C->getLocEnd()); 7009 } 7010 7011 template <typename Derived> 7012 OMPClause * 7013 TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) { 7014 // No need to rebuild this clause, no template-dependent parameters. 7015 return C; 7016 } 7017 7018 template <typename Derived> 7019 OMPClause * 7020 TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) { 7021 // No need to rebuild this clause, no template-dependent parameters. 7022 return C; 7023 } 7024 7025 template <typename Derived> 7026 OMPClause * 7027 TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) { 7028 // No need to rebuild this clause, no template-dependent parameters. 7029 return C; 7030 } 7031 7032 template <typename Derived> 7033 OMPClause * 7034 TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) { 7035 // No need to rebuild this clause, no template-dependent parameters. 7036 return C; 7037 } 7038 7039 template <typename Derived> 7040 OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) { 7041 // No need to rebuild this clause, no template-dependent parameters. 7042 return C; 7043 } 7044 7045 template <typename Derived> 7046 OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) { 7047 // No need to rebuild this clause, no template-dependent parameters. 7048 return C; 7049 } 7050 7051 template <typename Derived> 7052 OMPClause * 7053 TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) { 7054 // No need to rebuild this clause, no template-dependent parameters. 7055 return C; 7056 } 7057 7058 template <typename Derived> 7059 OMPClause * 7060 TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) { 7061 // No need to rebuild this clause, no template-dependent parameters. 7062 return C; 7063 } 7064 7065 template <typename Derived> 7066 OMPClause * 7067 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) { 7068 // No need to rebuild this clause, no template-dependent parameters. 7069 return C; 7070 } 7071 7072 template <typename Derived> 7073 OMPClause * 7074 TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) { 7075 llvm::SmallVector<Expr *, 16> Vars; 7076 Vars.reserve(C->varlist_size()); 7077 for (auto *VE : C->varlists()) { 7078 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7079 if (EVar.isInvalid()) 7080 return nullptr; 7081 Vars.push_back(EVar.get()); 7082 } 7083 return getDerived().RebuildOMPPrivateClause( 7084 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 7085 } 7086 7087 template <typename Derived> 7088 OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause( 7089 OMPFirstprivateClause *C) { 7090 llvm::SmallVector<Expr *, 16> Vars; 7091 Vars.reserve(C->varlist_size()); 7092 for (auto *VE : C->varlists()) { 7093 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7094 if (EVar.isInvalid()) 7095 return nullptr; 7096 Vars.push_back(EVar.get()); 7097 } 7098 return getDerived().RebuildOMPFirstprivateClause( 7099 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 7100 } 7101 7102 template <typename Derived> 7103 OMPClause * 7104 TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) { 7105 llvm::SmallVector<Expr *, 16> Vars; 7106 Vars.reserve(C->varlist_size()); 7107 for (auto *VE : C->varlists()) { 7108 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7109 if (EVar.isInvalid()) 7110 return nullptr; 7111 Vars.push_back(EVar.get()); 7112 } 7113 return getDerived().RebuildOMPLastprivateClause( 7114 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 7115 } 7116 7117 template <typename Derived> 7118 OMPClause * 7119 TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) { 7120 llvm::SmallVector<Expr *, 16> Vars; 7121 Vars.reserve(C->varlist_size()); 7122 for (auto *VE : C->varlists()) { 7123 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7124 if (EVar.isInvalid()) 7125 return nullptr; 7126 Vars.push_back(EVar.get()); 7127 } 7128 return getDerived().RebuildOMPSharedClause(Vars, C->getLocStart(), 7129 C->getLParenLoc(), C->getLocEnd()); 7130 } 7131 7132 template <typename Derived> 7133 OMPClause * 7134 TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) { 7135 llvm::SmallVector<Expr *, 16> Vars; 7136 Vars.reserve(C->varlist_size()); 7137 for (auto *VE : C->varlists()) { 7138 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7139 if (EVar.isInvalid()) 7140 return nullptr; 7141 Vars.push_back(EVar.get()); 7142 } 7143 CXXScopeSpec ReductionIdScopeSpec; 7144 ReductionIdScopeSpec.Adopt(C->getQualifierLoc()); 7145 7146 DeclarationNameInfo NameInfo = C->getNameInfo(); 7147 if (NameInfo.getName()) { 7148 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 7149 if (!NameInfo.getName()) 7150 return nullptr; 7151 } 7152 return getDerived().RebuildOMPReductionClause( 7153 Vars, C->getLocStart(), C->getLParenLoc(), C->getColonLoc(), 7154 C->getLocEnd(), ReductionIdScopeSpec, NameInfo); 7155 } 7156 7157 template <typename Derived> 7158 OMPClause * 7159 TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) { 7160 llvm::SmallVector<Expr *, 16> Vars; 7161 Vars.reserve(C->varlist_size()); 7162 for (auto *VE : C->varlists()) { 7163 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7164 if (EVar.isInvalid()) 7165 return nullptr; 7166 Vars.push_back(EVar.get()); 7167 } 7168 ExprResult Step = getDerived().TransformExpr(C->getStep()); 7169 if (Step.isInvalid()) 7170 return nullptr; 7171 return getDerived().RebuildOMPLinearClause(Vars, Step.get(), C->getLocStart(), 7172 C->getLParenLoc(), 7173 C->getColonLoc(), C->getLocEnd()); 7174 } 7175 7176 template <typename Derived> 7177 OMPClause * 7178 TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *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 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment()); 7188 if (Alignment.isInvalid()) 7189 return nullptr; 7190 return getDerived().RebuildOMPAlignedClause( 7191 Vars, Alignment.get(), C->getLocStart(), C->getLParenLoc(), 7192 C->getColonLoc(), C->getLocEnd()); 7193 } 7194 7195 template <typename Derived> 7196 OMPClause * 7197 TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) { 7198 llvm::SmallVector<Expr *, 16> Vars; 7199 Vars.reserve(C->varlist_size()); 7200 for (auto *VE : C->varlists()) { 7201 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7202 if (EVar.isInvalid()) 7203 return nullptr; 7204 Vars.push_back(EVar.get()); 7205 } 7206 return getDerived().RebuildOMPCopyinClause(Vars, C->getLocStart(), 7207 C->getLParenLoc(), C->getLocEnd()); 7208 } 7209 7210 template <typename Derived> 7211 OMPClause * 7212 TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) { 7213 llvm::SmallVector<Expr *, 16> Vars; 7214 Vars.reserve(C->varlist_size()); 7215 for (auto *VE : C->varlists()) { 7216 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7217 if (EVar.isInvalid()) 7218 return nullptr; 7219 Vars.push_back(EVar.get()); 7220 } 7221 return getDerived().RebuildOMPCopyprivateClause( 7222 Vars, C->getLocStart(), C->getLParenLoc(), C->getLocEnd()); 7223 } 7224 7225 template <typename Derived> 7226 OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) { 7227 llvm::SmallVector<Expr *, 16> Vars; 7228 Vars.reserve(C->varlist_size()); 7229 for (auto *VE : C->varlists()) { 7230 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(VE)); 7231 if (EVar.isInvalid()) 7232 return nullptr; 7233 Vars.push_back(EVar.get()); 7234 } 7235 return getDerived().RebuildOMPFlushClause(Vars, C->getLocStart(), 7236 C->getLParenLoc(), C->getLocEnd()); 7237 } 7238 7239 //===----------------------------------------------------------------------===// 7240 // Expression transformation 7241 //===----------------------------------------------------------------------===// 7242 template<typename Derived> 7243 ExprResult 7244 TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 7245 if (!E->isTypeDependent()) 7246 return E; 7247 7248 return getDerived().RebuildPredefinedExpr(E->getLocation(), 7249 E->getIdentType()); 7250 } 7251 7252 template<typename Derived> 7253 ExprResult 7254 TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 7255 NestedNameSpecifierLoc QualifierLoc; 7256 if (E->getQualifierLoc()) { 7257 QualifierLoc 7258 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 7259 if (!QualifierLoc) 7260 return ExprError(); 7261 } 7262 7263 ValueDecl *ND 7264 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 7265 E->getDecl())); 7266 if (!ND) 7267 return ExprError(); 7268 7269 DeclarationNameInfo NameInfo = E->getNameInfo(); 7270 if (NameInfo.getName()) { 7271 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 7272 if (!NameInfo.getName()) 7273 return ExprError(); 7274 } 7275 7276 if (!getDerived().AlwaysRebuild() && 7277 QualifierLoc == E->getQualifierLoc() && 7278 ND == E->getDecl() && 7279 NameInfo.getName() == E->getDecl()->getDeclName() && 7280 !E->hasExplicitTemplateArgs()) { 7281 7282 // Mark it referenced in the new context regardless. 7283 // FIXME: this is a bit instantiation-specific. 7284 SemaRef.MarkDeclRefReferenced(E); 7285 7286 return E; 7287 } 7288 7289 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr; 7290 if (E->hasExplicitTemplateArgs()) { 7291 TemplateArgs = &TransArgs; 7292 TransArgs.setLAngleLoc(E->getLAngleLoc()); 7293 TransArgs.setRAngleLoc(E->getRAngleLoc()); 7294 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 7295 E->getNumTemplateArgs(), 7296 TransArgs)) 7297 return ExprError(); 7298 } 7299 7300 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, 7301 TemplateArgs); 7302 } 7303 7304 template<typename Derived> 7305 ExprResult 7306 TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 7307 return E; 7308 } 7309 7310 template<typename Derived> 7311 ExprResult 7312 TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 7313 return E; 7314 } 7315 7316 template<typename Derived> 7317 ExprResult 7318 TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 7319 return E; 7320 } 7321 7322 template<typename Derived> 7323 ExprResult 7324 TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 7325 return E; 7326 } 7327 7328 template<typename Derived> 7329 ExprResult 7330 TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 7331 return E; 7332 } 7333 7334 template<typename Derived> 7335 ExprResult 7336 TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { 7337 if (FunctionDecl *FD = E->getDirectCallee()) 7338 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD); 7339 return SemaRef.MaybeBindToTemporary(E); 7340 } 7341 7342 template<typename Derived> 7343 ExprResult 7344 TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { 7345 ExprResult ControllingExpr = 7346 getDerived().TransformExpr(E->getControllingExpr()); 7347 if (ControllingExpr.isInvalid()) 7348 return ExprError(); 7349 7350 SmallVector<Expr *, 4> AssocExprs; 7351 SmallVector<TypeSourceInfo *, 4> AssocTypes; 7352 for (unsigned i = 0; i != E->getNumAssocs(); ++i) { 7353 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i); 7354 if (TS) { 7355 TypeSourceInfo *AssocType = getDerived().TransformType(TS); 7356 if (!AssocType) 7357 return ExprError(); 7358 AssocTypes.push_back(AssocType); 7359 } else { 7360 AssocTypes.push_back(nullptr); 7361 } 7362 7363 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); 7364 if (AssocExpr.isInvalid()) 7365 return ExprError(); 7366 AssocExprs.push_back(AssocExpr.get()); 7367 } 7368 7369 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), 7370 E->getDefaultLoc(), 7371 E->getRParenLoc(), 7372 ControllingExpr.get(), 7373 AssocTypes, 7374 AssocExprs); 7375 } 7376 7377 template<typename Derived> 7378 ExprResult 7379 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 7380 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 7381 if (SubExpr.isInvalid()) 7382 return ExprError(); 7383 7384 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 7385 return E; 7386 7387 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 7388 E->getRParen()); 7389 } 7390 7391 /// \brief The operand of a unary address-of operator has special rules: it's 7392 /// allowed to refer to a non-static member of a class even if there's no 'this' 7393 /// object available. 7394 template<typename Derived> 7395 ExprResult 7396 TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { 7397 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) 7398 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true, nullptr); 7399 else 7400 return getDerived().TransformExpr(E); 7401 } 7402 7403 template<typename Derived> 7404 ExprResult 7405 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 7406 ExprResult SubExpr; 7407 if (E->getOpcode() == UO_AddrOf) 7408 SubExpr = TransformAddressOfOperand(E->getSubExpr()); 7409 else 7410 SubExpr = TransformExpr(E->getSubExpr()); 7411 if (SubExpr.isInvalid()) 7412 return ExprError(); 7413 7414 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 7415 return E; 7416 7417 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 7418 E->getOpcode(), 7419 SubExpr.get()); 7420 } 7421 7422 template<typename Derived> 7423 ExprResult 7424 TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 7425 // Transform the type. 7426 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 7427 if (!Type) 7428 return ExprError(); 7429 7430 // Transform all of the components into components similar to what the 7431 // parser uses. 7432 // FIXME: It would be slightly more efficient in the non-dependent case to 7433 // just map FieldDecls, rather than requiring the rebuilder to look for 7434 // the fields again. However, __builtin_offsetof is rare enough in 7435 // template code that we don't care. 7436 bool ExprChanged = false; 7437 typedef Sema::OffsetOfComponent Component; 7438 typedef OffsetOfExpr::OffsetOfNode Node; 7439 SmallVector<Component, 4> Components; 7440 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 7441 const Node &ON = E->getComponent(I); 7442 Component Comp; 7443 Comp.isBrackets = true; 7444 Comp.LocStart = ON.getSourceRange().getBegin(); 7445 Comp.LocEnd = ON.getSourceRange().getEnd(); 7446 switch (ON.getKind()) { 7447 case Node::Array: { 7448 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 7449 ExprResult Index = getDerived().TransformExpr(FromIndex); 7450 if (Index.isInvalid()) 7451 return ExprError(); 7452 7453 ExprChanged = ExprChanged || Index.get() != FromIndex; 7454 Comp.isBrackets = true; 7455 Comp.U.E = Index.get(); 7456 break; 7457 } 7458 7459 case Node::Field: 7460 case Node::Identifier: 7461 Comp.isBrackets = false; 7462 Comp.U.IdentInfo = ON.getFieldName(); 7463 if (!Comp.U.IdentInfo) 7464 continue; 7465 7466 break; 7467 7468 case Node::Base: 7469 // Will be recomputed during the rebuild. 7470 continue; 7471 } 7472 7473 Components.push_back(Comp); 7474 } 7475 7476 // If nothing changed, retain the existing expression. 7477 if (!getDerived().AlwaysRebuild() && 7478 Type == E->getTypeSourceInfo() && 7479 !ExprChanged) 7480 return E; 7481 7482 // Build a new offsetof expression. 7483 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 7484 Components.data(), Components.size(), 7485 E->getRParenLoc()); 7486 } 7487 7488 template<typename Derived> 7489 ExprResult 7490 TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 7491 assert(getDerived().AlreadyTransformed(E->getType()) && 7492 "opaque value expression requires transformation"); 7493 return E; 7494 } 7495 7496 template<typename Derived> 7497 ExprResult 7498 TreeTransform<Derived>::TransformTypoExpr(TypoExpr *E) { 7499 return E; 7500 } 7501 7502 template<typename Derived> 7503 ExprResult 7504 TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { 7505 // Rebuild the syntactic form. The original syntactic form has 7506 // opaque-value expressions in it, so strip those away and rebuild 7507 // the result. This is a really awful way of doing this, but the 7508 // better solution (rebuilding the semantic expressions and 7509 // rebinding OVEs as necessary) doesn't work; we'd need 7510 // TreeTransform to not strip away implicit conversions. 7511 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E); 7512 ExprResult result = getDerived().TransformExpr(newSyntacticForm); 7513 if (result.isInvalid()) return ExprError(); 7514 7515 // If that gives us a pseudo-object result back, the pseudo-object 7516 // expression must have been an lvalue-to-rvalue conversion which we 7517 // should reapply. 7518 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) 7519 result = SemaRef.checkPseudoObjectRValue(result.get()); 7520 7521 return result; 7522 } 7523 7524 template<typename Derived> 7525 ExprResult 7526 TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( 7527 UnaryExprOrTypeTraitExpr *E) { 7528 if (E->isArgumentType()) { 7529 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 7530 7531 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 7532 if (!NewT) 7533 return ExprError(); 7534 7535 if (!getDerived().AlwaysRebuild() && OldT == NewT) 7536 return E; 7537 7538 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), 7539 E->getKind(), 7540 E->getSourceRange()); 7541 } 7542 7543 // C++0x [expr.sizeof]p1: 7544 // The operand is either an expression, which is an unevaluated operand 7545 // [...] 7546 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 7547 Sema::ReuseLambdaContextDecl); 7548 7549 // Try to recover if we have something like sizeof(T::X) where X is a type. 7550 // Notably, there must be *exactly* one set of parens if X is a type. 7551 TypeSourceInfo *RecoveryTSI = nullptr; 7552 ExprResult SubExpr; 7553 auto *PE = dyn_cast<ParenExpr>(E->getArgumentExpr()); 7554 if (auto *DRE = 7555 PE ? dyn_cast<DependentScopeDeclRefExpr>(PE->getSubExpr()) : nullptr) 7556 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr( 7557 PE, DRE, false, &RecoveryTSI); 7558 else 7559 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 7560 7561 if (RecoveryTSI) { 7562 return getDerived().RebuildUnaryExprOrTypeTrait( 7563 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange()); 7564 } else if (SubExpr.isInvalid()) 7565 return ExprError(); 7566 7567 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 7568 return E; 7569 7570 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), 7571 E->getOperatorLoc(), 7572 E->getKind(), 7573 E->getSourceRange()); 7574 } 7575 7576 template<typename Derived> 7577 ExprResult 7578 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 7579 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 7580 if (LHS.isInvalid()) 7581 return ExprError(); 7582 7583 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 7584 if (RHS.isInvalid()) 7585 return ExprError(); 7586 7587 7588 if (!getDerived().AlwaysRebuild() && 7589 LHS.get() == E->getLHS() && 7590 RHS.get() == E->getRHS()) 7591 return E; 7592 7593 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 7594 /*FIXME:*/E->getLHS()->getLocStart(), 7595 RHS.get(), 7596 E->getRBracketLoc()); 7597 } 7598 7599 template<typename Derived> 7600 ExprResult 7601 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 7602 // Transform the callee. 7603 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 7604 if (Callee.isInvalid()) 7605 return ExprError(); 7606 7607 // Transform arguments. 7608 bool ArgChanged = false; 7609 SmallVector<Expr*, 8> Args; 7610 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7611 &ArgChanged)) 7612 return ExprError(); 7613 7614 if (!getDerived().AlwaysRebuild() && 7615 Callee.get() == E->getCallee() && 7616 !ArgChanged) 7617 return SemaRef.MaybeBindToTemporary(E); 7618 7619 // FIXME: Wrong source location information for the '('. 7620 SourceLocation FakeLParenLoc 7621 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 7622 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 7623 Args, 7624 E->getRParenLoc()); 7625 } 7626 7627 template<typename Derived> 7628 ExprResult 7629 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 7630 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7631 if (Base.isInvalid()) 7632 return ExprError(); 7633 7634 NestedNameSpecifierLoc QualifierLoc; 7635 if (E->hasQualifier()) { 7636 QualifierLoc 7637 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 7638 7639 if (!QualifierLoc) 7640 return ExprError(); 7641 } 7642 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 7643 7644 ValueDecl *Member 7645 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 7646 E->getMemberDecl())); 7647 if (!Member) 7648 return ExprError(); 7649 7650 NamedDecl *FoundDecl = E->getFoundDecl(); 7651 if (FoundDecl == E->getMemberDecl()) { 7652 FoundDecl = Member; 7653 } else { 7654 FoundDecl = cast_or_null<NamedDecl>( 7655 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 7656 if (!FoundDecl) 7657 return ExprError(); 7658 } 7659 7660 if (!getDerived().AlwaysRebuild() && 7661 Base.get() == E->getBase() && 7662 QualifierLoc == E->getQualifierLoc() && 7663 Member == E->getMemberDecl() && 7664 FoundDecl == E->getFoundDecl() && 7665 !E->hasExplicitTemplateArgs()) { 7666 7667 // Mark it referenced in the new context regardless. 7668 // FIXME: this is a bit instantiation-specific. 7669 SemaRef.MarkMemberReferenced(E); 7670 7671 return E; 7672 } 7673 7674 TemplateArgumentListInfo TransArgs; 7675 if (E->hasExplicitTemplateArgs()) { 7676 TransArgs.setLAngleLoc(E->getLAngleLoc()); 7677 TransArgs.setRAngleLoc(E->getRAngleLoc()); 7678 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 7679 E->getNumTemplateArgs(), 7680 TransArgs)) 7681 return ExprError(); 7682 } 7683 7684 // FIXME: Bogus source location for the operator 7685 SourceLocation FakeOperatorLoc = 7686 SemaRef.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 7687 7688 // FIXME: to do this check properly, we will need to preserve the 7689 // first-qualifier-in-scope here, just in case we had a dependent 7690 // base (and therefore couldn't do the check) and a 7691 // nested-name-qualifier (and therefore could do the lookup). 7692 NamedDecl *FirstQualifierInScope = nullptr; 7693 7694 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 7695 E->isArrow(), 7696 QualifierLoc, 7697 TemplateKWLoc, 7698 E->getMemberNameInfo(), 7699 Member, 7700 FoundDecl, 7701 (E->hasExplicitTemplateArgs() 7702 ? &TransArgs : nullptr), 7703 FirstQualifierInScope); 7704 } 7705 7706 template<typename Derived> 7707 ExprResult 7708 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 7709 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 7710 if (LHS.isInvalid()) 7711 return ExprError(); 7712 7713 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 7714 if (RHS.isInvalid()) 7715 return ExprError(); 7716 7717 if (!getDerived().AlwaysRebuild() && 7718 LHS.get() == E->getLHS() && 7719 RHS.get() == E->getRHS()) 7720 return E; 7721 7722 Sema::FPContractStateRAII FPContractState(getSema()); 7723 getSema().FPFeatures.fp_contract = E->isFPContractable(); 7724 7725 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 7726 LHS.get(), RHS.get()); 7727 } 7728 7729 template<typename Derived> 7730 ExprResult 7731 TreeTransform<Derived>::TransformCompoundAssignOperator( 7732 CompoundAssignOperator *E) { 7733 return getDerived().TransformBinaryOperator(E); 7734 } 7735 7736 template<typename Derived> 7737 ExprResult TreeTransform<Derived>:: 7738 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { 7739 // Just rebuild the common and RHS expressions and see whether we 7740 // get any changes. 7741 7742 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); 7743 if (commonExpr.isInvalid()) 7744 return ExprError(); 7745 7746 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); 7747 if (rhs.isInvalid()) 7748 return ExprError(); 7749 7750 if (!getDerived().AlwaysRebuild() && 7751 commonExpr.get() == e->getCommon() && 7752 rhs.get() == e->getFalseExpr()) 7753 return e; 7754 7755 return getDerived().RebuildConditionalOperator(commonExpr.get(), 7756 e->getQuestionLoc(), 7757 nullptr, 7758 e->getColonLoc(), 7759 rhs.get()); 7760 } 7761 7762 template<typename Derived> 7763 ExprResult 7764 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 7765 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 7766 if (Cond.isInvalid()) 7767 return ExprError(); 7768 7769 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 7770 if (LHS.isInvalid()) 7771 return ExprError(); 7772 7773 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 7774 if (RHS.isInvalid()) 7775 return ExprError(); 7776 7777 if (!getDerived().AlwaysRebuild() && 7778 Cond.get() == E->getCond() && 7779 LHS.get() == E->getLHS() && 7780 RHS.get() == E->getRHS()) 7781 return E; 7782 7783 return getDerived().RebuildConditionalOperator(Cond.get(), 7784 E->getQuestionLoc(), 7785 LHS.get(), 7786 E->getColonLoc(), 7787 RHS.get()); 7788 } 7789 7790 template<typename Derived> 7791 ExprResult 7792 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 7793 // Implicit casts are eliminated during transformation, since they 7794 // will be recomputed by semantic analysis after transformation. 7795 return getDerived().TransformExpr(E->getSubExprAsWritten()); 7796 } 7797 7798 template<typename Derived> 7799 ExprResult 7800 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 7801 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7802 if (!Type) 7803 return ExprError(); 7804 7805 ExprResult SubExpr 7806 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7807 if (SubExpr.isInvalid()) 7808 return ExprError(); 7809 7810 if (!getDerived().AlwaysRebuild() && 7811 Type == E->getTypeInfoAsWritten() && 7812 SubExpr.get() == E->getSubExpr()) 7813 return E; 7814 7815 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 7816 Type, 7817 E->getRParenLoc(), 7818 SubExpr.get()); 7819 } 7820 7821 template<typename Derived> 7822 ExprResult 7823 TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 7824 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 7825 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 7826 if (!NewT) 7827 return ExprError(); 7828 7829 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 7830 if (Init.isInvalid()) 7831 return ExprError(); 7832 7833 if (!getDerived().AlwaysRebuild() && 7834 OldT == NewT && 7835 Init.get() == E->getInitializer()) 7836 return SemaRef.MaybeBindToTemporary(E); 7837 7838 // Note: the expression type doesn't necessarily match the 7839 // type-as-written, but that's okay, because it should always be 7840 // derivable from the initializer. 7841 7842 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 7843 /*FIXME:*/E->getInitializer()->getLocEnd(), 7844 Init.get()); 7845 } 7846 7847 template<typename Derived> 7848 ExprResult 7849 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 7850 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7851 if (Base.isInvalid()) 7852 return ExprError(); 7853 7854 if (!getDerived().AlwaysRebuild() && 7855 Base.get() == E->getBase()) 7856 return E; 7857 7858 // FIXME: Bad source location 7859 SourceLocation FakeOperatorLoc = 7860 SemaRef.getLocForEndOfToken(E->getBase()->getLocEnd()); 7861 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 7862 E->getAccessorLoc(), 7863 E->getAccessor()); 7864 } 7865 7866 template<typename Derived> 7867 ExprResult 7868 TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 7869 if (InitListExpr *Syntactic = E->getSyntacticForm()) 7870 E = Syntactic; 7871 7872 bool InitChanged = false; 7873 7874 SmallVector<Expr*, 4> Inits; 7875 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 7876 Inits, &InitChanged)) 7877 return ExprError(); 7878 7879 if (!getDerived().AlwaysRebuild() && !InitChanged) { 7880 // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr 7881 // in some cases. We can't reuse it in general, because the syntactic and 7882 // semantic forms are linked, and we can't know that semantic form will 7883 // match even if the syntactic form does. 7884 } 7885 7886 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, 7887 E->getRBraceLoc(), E->getType()); 7888 } 7889 7890 template<typename Derived> 7891 ExprResult 7892 TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 7893 Designation Desig; 7894 7895 // transform the initializer value 7896 ExprResult Init = getDerived().TransformExpr(E->getInit()); 7897 if (Init.isInvalid()) 7898 return ExprError(); 7899 7900 // transform the designators. 7901 SmallVector<Expr*, 4> ArrayExprs; 7902 bool ExprChanged = false; 7903 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 7904 DEnd = E->designators_end(); 7905 D != DEnd; ++D) { 7906 if (D->isFieldDesignator()) { 7907 Desig.AddDesignator(Designator::getField(D->getFieldName(), 7908 D->getDotLoc(), 7909 D->getFieldLoc())); 7910 continue; 7911 } 7912 7913 if (D->isArrayDesignator()) { 7914 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 7915 if (Index.isInvalid()) 7916 return ExprError(); 7917 7918 Desig.AddDesignator(Designator::getArray(Index.get(), 7919 D->getLBracketLoc())); 7920 7921 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 7922 ArrayExprs.push_back(Index.get()); 7923 continue; 7924 } 7925 7926 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 7927 ExprResult Start 7928 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 7929 if (Start.isInvalid()) 7930 return ExprError(); 7931 7932 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 7933 if (End.isInvalid()) 7934 return ExprError(); 7935 7936 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 7937 End.get(), 7938 D->getLBracketLoc(), 7939 D->getEllipsisLoc())); 7940 7941 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 7942 End.get() != E->getArrayRangeEnd(*D); 7943 7944 ArrayExprs.push_back(Start.get()); 7945 ArrayExprs.push_back(End.get()); 7946 } 7947 7948 if (!getDerived().AlwaysRebuild() && 7949 Init.get() == E->getInit() && 7950 !ExprChanged) 7951 return E; 7952 7953 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, 7954 E->getEqualOrColonLoc(), 7955 E->usesGNUSyntax(), Init.get()); 7956 } 7957 7958 template<typename Derived> 7959 ExprResult 7960 TreeTransform<Derived>::TransformImplicitValueInitExpr( 7961 ImplicitValueInitExpr *E) { 7962 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 7963 7964 // FIXME: Will we ever have proper type location here? Will we actually 7965 // need to transform the type? 7966 QualType T = getDerived().TransformType(E->getType()); 7967 if (T.isNull()) 7968 return ExprError(); 7969 7970 if (!getDerived().AlwaysRebuild() && 7971 T == E->getType()) 7972 return E; 7973 7974 return getDerived().RebuildImplicitValueInitExpr(T); 7975 } 7976 7977 template<typename Derived> 7978 ExprResult 7979 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 7980 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 7981 if (!TInfo) 7982 return ExprError(); 7983 7984 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 7985 if (SubExpr.isInvalid()) 7986 return ExprError(); 7987 7988 if (!getDerived().AlwaysRebuild() && 7989 TInfo == E->getWrittenTypeInfo() && 7990 SubExpr.get() == E->getSubExpr()) 7991 return E; 7992 7993 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 7994 TInfo, E->getRParenLoc()); 7995 } 7996 7997 template<typename Derived> 7998 ExprResult 7999 TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 8000 bool ArgumentChanged = false; 8001 SmallVector<Expr*, 4> Inits; 8002 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 8003 &ArgumentChanged)) 8004 return ExprError(); 8005 8006 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 8007 Inits, 8008 E->getRParenLoc()); 8009 } 8010 8011 /// \brief Transform an address-of-label expression. 8012 /// 8013 /// By default, the transformation of an address-of-label expression always 8014 /// rebuilds the expression, so that the label identifier can be resolved to 8015 /// the corresponding label statement by semantic analysis. 8016 template<typename Derived> 8017 ExprResult 8018 TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 8019 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), 8020 E->getLabel()); 8021 if (!LD) 8022 return ExprError(); 8023 8024 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 8025 cast<LabelDecl>(LD)); 8026 } 8027 8028 template<typename Derived> 8029 ExprResult 8030 TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 8031 SemaRef.ActOnStartStmtExpr(); 8032 StmtResult SubStmt 8033 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 8034 if (SubStmt.isInvalid()) { 8035 SemaRef.ActOnStmtExprError(); 8036 return ExprError(); 8037 } 8038 8039 if (!getDerived().AlwaysRebuild() && 8040 SubStmt.get() == E->getSubStmt()) { 8041 // Calling this an 'error' is unintuitive, but it does the right thing. 8042 SemaRef.ActOnStmtExprError(); 8043 return SemaRef.MaybeBindToTemporary(E); 8044 } 8045 8046 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 8047 SubStmt.get(), 8048 E->getRParenLoc()); 8049 } 8050 8051 template<typename Derived> 8052 ExprResult 8053 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 8054 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 8055 if (Cond.isInvalid()) 8056 return ExprError(); 8057 8058 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 8059 if (LHS.isInvalid()) 8060 return ExprError(); 8061 8062 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 8063 if (RHS.isInvalid()) 8064 return ExprError(); 8065 8066 if (!getDerived().AlwaysRebuild() && 8067 Cond.get() == E->getCond() && 8068 LHS.get() == E->getLHS() && 8069 RHS.get() == E->getRHS()) 8070 return E; 8071 8072 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 8073 Cond.get(), LHS.get(), RHS.get(), 8074 E->getRParenLoc()); 8075 } 8076 8077 template<typename Derived> 8078 ExprResult 8079 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 8080 return E; 8081 } 8082 8083 template<typename Derived> 8084 ExprResult 8085 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 8086 switch (E->getOperator()) { 8087 case OO_New: 8088 case OO_Delete: 8089 case OO_Array_New: 8090 case OO_Array_Delete: 8091 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 8092 8093 case OO_Call: { 8094 // This is a call to an object's operator(). 8095 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 8096 8097 // Transform the object itself. 8098 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 8099 if (Object.isInvalid()) 8100 return ExprError(); 8101 8102 // FIXME: Poor location information 8103 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken( 8104 static_cast<Expr *>(Object.get())->getLocEnd()); 8105 8106 // Transform the call arguments. 8107 SmallVector<Expr*, 8> Args; 8108 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 8109 Args)) 8110 return ExprError(); 8111 8112 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 8113 Args, 8114 E->getLocEnd()); 8115 } 8116 8117 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 8118 case OO_##Name: 8119 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 8120 #include "clang/Basic/OperatorKinds.def" 8121 case OO_Subscript: 8122 // Handled below. 8123 break; 8124 8125 case OO_Conditional: 8126 llvm_unreachable("conditional operator is not actually overloadable"); 8127 8128 case OO_None: 8129 case NUM_OVERLOADED_OPERATORS: 8130 llvm_unreachable("not an overloaded operator?"); 8131 } 8132 8133 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 8134 if (Callee.isInvalid()) 8135 return ExprError(); 8136 8137 ExprResult First; 8138 if (E->getOperator() == OO_Amp) 8139 First = getDerived().TransformAddressOfOperand(E->getArg(0)); 8140 else 8141 First = getDerived().TransformExpr(E->getArg(0)); 8142 if (First.isInvalid()) 8143 return ExprError(); 8144 8145 ExprResult Second; 8146 if (E->getNumArgs() == 2) { 8147 Second = getDerived().TransformExpr(E->getArg(1)); 8148 if (Second.isInvalid()) 8149 return ExprError(); 8150 } 8151 8152 if (!getDerived().AlwaysRebuild() && 8153 Callee.get() == E->getCallee() && 8154 First.get() == E->getArg(0) && 8155 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 8156 return SemaRef.MaybeBindToTemporary(E); 8157 8158 Sema::FPContractStateRAII FPContractState(getSema()); 8159 getSema().FPFeatures.fp_contract = E->isFPContractable(); 8160 8161 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 8162 E->getOperatorLoc(), 8163 Callee.get(), 8164 First.get(), 8165 Second.get()); 8166 } 8167 8168 template<typename Derived> 8169 ExprResult 8170 TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 8171 return getDerived().TransformCallExpr(E); 8172 } 8173 8174 template<typename Derived> 8175 ExprResult 8176 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 8177 // Transform the callee. 8178 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 8179 if (Callee.isInvalid()) 8180 return ExprError(); 8181 8182 // Transform exec config. 8183 ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); 8184 if (EC.isInvalid()) 8185 return ExprError(); 8186 8187 // Transform arguments. 8188 bool ArgChanged = false; 8189 SmallVector<Expr*, 8> Args; 8190 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 8191 &ArgChanged)) 8192 return ExprError(); 8193 8194 if (!getDerived().AlwaysRebuild() && 8195 Callee.get() == E->getCallee() && 8196 !ArgChanged) 8197 return SemaRef.MaybeBindToTemporary(E); 8198 8199 // FIXME: Wrong source location information for the '('. 8200 SourceLocation FakeLParenLoc 8201 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 8202 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 8203 Args, 8204 E->getRParenLoc(), EC.get()); 8205 } 8206 8207 template<typename Derived> 8208 ExprResult 8209 TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 8210 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 8211 if (!Type) 8212 return ExprError(); 8213 8214 ExprResult SubExpr 8215 = getDerived().TransformExpr(E->getSubExprAsWritten()); 8216 if (SubExpr.isInvalid()) 8217 return ExprError(); 8218 8219 if (!getDerived().AlwaysRebuild() && 8220 Type == E->getTypeInfoAsWritten() && 8221 SubExpr.get() == E->getSubExpr()) 8222 return E; 8223 return getDerived().RebuildCXXNamedCastExpr( 8224 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(), 8225 Type, E->getAngleBrackets().getEnd(), 8226 // FIXME. this should be '(' location 8227 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc()); 8228 } 8229 8230 template<typename Derived> 8231 ExprResult 8232 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 8233 return getDerived().TransformCXXNamedCastExpr(E); 8234 } 8235 8236 template<typename Derived> 8237 ExprResult 8238 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 8239 return getDerived().TransformCXXNamedCastExpr(E); 8240 } 8241 8242 template<typename Derived> 8243 ExprResult 8244 TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 8245 CXXReinterpretCastExpr *E) { 8246 return getDerived().TransformCXXNamedCastExpr(E); 8247 } 8248 8249 template<typename Derived> 8250 ExprResult 8251 TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 8252 return getDerived().TransformCXXNamedCastExpr(E); 8253 } 8254 8255 template<typename Derived> 8256 ExprResult 8257 TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 8258 CXXFunctionalCastExpr *E) { 8259 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 8260 if (!Type) 8261 return ExprError(); 8262 8263 ExprResult SubExpr 8264 = getDerived().TransformExpr(E->getSubExprAsWritten()); 8265 if (SubExpr.isInvalid()) 8266 return ExprError(); 8267 8268 if (!getDerived().AlwaysRebuild() && 8269 Type == E->getTypeInfoAsWritten() && 8270 SubExpr.get() == E->getSubExpr()) 8271 return E; 8272 8273 return getDerived().RebuildCXXFunctionalCastExpr(Type, 8274 E->getLParenLoc(), 8275 SubExpr.get(), 8276 E->getRParenLoc()); 8277 } 8278 8279 template<typename Derived> 8280 ExprResult 8281 TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 8282 if (E->isTypeOperand()) { 8283 TypeSourceInfo *TInfo 8284 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 8285 if (!TInfo) 8286 return ExprError(); 8287 8288 if (!getDerived().AlwaysRebuild() && 8289 TInfo == E->getTypeOperandSourceInfo()) 8290 return E; 8291 8292 return getDerived().RebuildCXXTypeidExpr(E->getType(), 8293 E->getLocStart(), 8294 TInfo, 8295 E->getLocEnd()); 8296 } 8297 8298 // We don't know whether the subexpression is potentially evaluated until 8299 // after we perform semantic analysis. We speculatively assume it is 8300 // unevaluated; it will get fixed later if the subexpression is in fact 8301 // potentially evaluated. 8302 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 8303 Sema::ReuseLambdaContextDecl); 8304 8305 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 8306 if (SubExpr.isInvalid()) 8307 return ExprError(); 8308 8309 if (!getDerived().AlwaysRebuild() && 8310 SubExpr.get() == E->getExprOperand()) 8311 return E; 8312 8313 return getDerived().RebuildCXXTypeidExpr(E->getType(), 8314 E->getLocStart(), 8315 SubExpr.get(), 8316 E->getLocEnd()); 8317 } 8318 8319 template<typename Derived> 8320 ExprResult 8321 TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 8322 if (E->isTypeOperand()) { 8323 TypeSourceInfo *TInfo 8324 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 8325 if (!TInfo) 8326 return ExprError(); 8327 8328 if (!getDerived().AlwaysRebuild() && 8329 TInfo == E->getTypeOperandSourceInfo()) 8330 return E; 8331 8332 return getDerived().RebuildCXXUuidofExpr(E->getType(), 8333 E->getLocStart(), 8334 TInfo, 8335 E->getLocEnd()); 8336 } 8337 8338 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8339 8340 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 8341 if (SubExpr.isInvalid()) 8342 return ExprError(); 8343 8344 if (!getDerived().AlwaysRebuild() && 8345 SubExpr.get() == E->getExprOperand()) 8346 return E; 8347 8348 return getDerived().RebuildCXXUuidofExpr(E->getType(), 8349 E->getLocStart(), 8350 SubExpr.get(), 8351 E->getLocEnd()); 8352 } 8353 8354 template<typename Derived> 8355 ExprResult 8356 TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 8357 return E; 8358 } 8359 8360 template<typename Derived> 8361 ExprResult 8362 TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 8363 CXXNullPtrLiteralExpr *E) { 8364 return E; 8365 } 8366 8367 template<typename Derived> 8368 ExprResult 8369 TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 8370 QualType T = getSema().getCurrentThisType(); 8371 8372 if (!getDerived().AlwaysRebuild() && T == E->getType()) { 8373 // Make sure that we capture 'this'. 8374 getSema().CheckCXXThisCapture(E->getLocStart()); 8375 return E; 8376 } 8377 8378 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 8379 } 8380 8381 template<typename Derived> 8382 ExprResult 8383 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 8384 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 8385 if (SubExpr.isInvalid()) 8386 return ExprError(); 8387 8388 if (!getDerived().AlwaysRebuild() && 8389 SubExpr.get() == E->getSubExpr()) 8390 return E; 8391 8392 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(), 8393 E->isThrownVariableInScope()); 8394 } 8395 8396 template<typename Derived> 8397 ExprResult 8398 TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 8399 ParmVarDecl *Param 8400 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 8401 E->getParam())); 8402 if (!Param) 8403 return ExprError(); 8404 8405 if (!getDerived().AlwaysRebuild() && 8406 Param == E->getParam()) 8407 return E; 8408 8409 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 8410 } 8411 8412 template<typename Derived> 8413 ExprResult 8414 TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 8415 FieldDecl *Field 8416 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(), 8417 E->getField())); 8418 if (!Field) 8419 return ExprError(); 8420 8421 if (!getDerived().AlwaysRebuild() && Field == E->getField()) 8422 return E; 8423 8424 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field); 8425 } 8426 8427 template<typename Derived> 8428 ExprResult 8429 TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 8430 CXXScalarValueInitExpr *E) { 8431 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8432 if (!T) 8433 return ExprError(); 8434 8435 if (!getDerived().AlwaysRebuild() && 8436 T == E->getTypeSourceInfo()) 8437 return E; 8438 8439 return getDerived().RebuildCXXScalarValueInitExpr(T, 8440 /*FIXME:*/T->getTypeLoc().getEndLoc(), 8441 E->getRParenLoc()); 8442 } 8443 8444 template<typename Derived> 8445 ExprResult 8446 TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 8447 // Transform the type that we're allocating 8448 TypeSourceInfo *AllocTypeInfo 8449 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 8450 if (!AllocTypeInfo) 8451 return ExprError(); 8452 8453 // Transform the size of the array we're allocating (if any). 8454 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 8455 if (ArraySize.isInvalid()) 8456 return ExprError(); 8457 8458 // Transform the placement arguments (if any). 8459 bool ArgumentChanged = false; 8460 SmallVector<Expr*, 8> PlacementArgs; 8461 if (getDerived().TransformExprs(E->getPlacementArgs(), 8462 E->getNumPlacementArgs(), true, 8463 PlacementArgs, &ArgumentChanged)) 8464 return ExprError(); 8465 8466 // Transform the initializer (if any). 8467 Expr *OldInit = E->getInitializer(); 8468 ExprResult NewInit; 8469 if (OldInit) 8470 NewInit = getDerived().TransformInitializer(OldInit, true); 8471 if (NewInit.isInvalid()) 8472 return ExprError(); 8473 8474 // Transform new operator and delete operator. 8475 FunctionDecl *OperatorNew = nullptr; 8476 if (E->getOperatorNew()) { 8477 OperatorNew = cast_or_null<FunctionDecl>( 8478 getDerived().TransformDecl(E->getLocStart(), 8479 E->getOperatorNew())); 8480 if (!OperatorNew) 8481 return ExprError(); 8482 } 8483 8484 FunctionDecl *OperatorDelete = nullptr; 8485 if (E->getOperatorDelete()) { 8486 OperatorDelete = cast_or_null<FunctionDecl>( 8487 getDerived().TransformDecl(E->getLocStart(), 8488 E->getOperatorDelete())); 8489 if (!OperatorDelete) 8490 return ExprError(); 8491 } 8492 8493 if (!getDerived().AlwaysRebuild() && 8494 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 8495 ArraySize.get() == E->getArraySize() && 8496 NewInit.get() == OldInit && 8497 OperatorNew == E->getOperatorNew() && 8498 OperatorDelete == E->getOperatorDelete() && 8499 !ArgumentChanged) { 8500 // Mark any declarations we need as referenced. 8501 // FIXME: instantiation-specific. 8502 if (OperatorNew) 8503 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew); 8504 if (OperatorDelete) 8505 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 8506 8507 if (E->isArray() && !E->getAllocatedType()->isDependentType()) { 8508 QualType ElementType 8509 = SemaRef.Context.getBaseElementType(E->getAllocatedType()); 8510 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) { 8511 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl()); 8512 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) { 8513 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor); 8514 } 8515 } 8516 } 8517 8518 return E; 8519 } 8520 8521 QualType AllocType = AllocTypeInfo->getType(); 8522 if (!ArraySize.get()) { 8523 // If no array size was specified, but the new expression was 8524 // instantiated with an array type (e.g., "new T" where T is 8525 // instantiated with "int[4]"), extract the outer bound from the 8526 // array type as our array size. We do this with constant and 8527 // dependently-sized array types. 8528 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 8529 if (!ArrayT) { 8530 // Do nothing 8531 } else if (const ConstantArrayType *ConsArrayT 8532 = dyn_cast<ConstantArrayType>(ArrayT)) { 8533 ArraySize = IntegerLiteral::Create(SemaRef.Context, ConsArrayT->getSize(), 8534 SemaRef.Context.getSizeType(), 8535 /*FIXME:*/ E->getLocStart()); 8536 AllocType = ConsArrayT->getElementType(); 8537 } else if (const DependentSizedArrayType *DepArrayT 8538 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 8539 if (DepArrayT->getSizeExpr()) { 8540 ArraySize = DepArrayT->getSizeExpr(); 8541 AllocType = DepArrayT->getElementType(); 8542 } 8543 } 8544 } 8545 8546 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 8547 E->isGlobalNew(), 8548 /*FIXME:*/E->getLocStart(), 8549 PlacementArgs, 8550 /*FIXME:*/E->getLocStart(), 8551 E->getTypeIdParens(), 8552 AllocType, 8553 AllocTypeInfo, 8554 ArraySize.get(), 8555 E->getDirectInitRange(), 8556 NewInit.get()); 8557 } 8558 8559 template<typename Derived> 8560 ExprResult 8561 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 8562 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 8563 if (Operand.isInvalid()) 8564 return ExprError(); 8565 8566 // Transform the delete operator, if known. 8567 FunctionDecl *OperatorDelete = nullptr; 8568 if (E->getOperatorDelete()) { 8569 OperatorDelete = cast_or_null<FunctionDecl>( 8570 getDerived().TransformDecl(E->getLocStart(), 8571 E->getOperatorDelete())); 8572 if (!OperatorDelete) 8573 return ExprError(); 8574 } 8575 8576 if (!getDerived().AlwaysRebuild() && 8577 Operand.get() == E->getArgument() && 8578 OperatorDelete == E->getOperatorDelete()) { 8579 // Mark any declarations we need as referenced. 8580 // FIXME: instantiation-specific. 8581 if (OperatorDelete) 8582 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 8583 8584 if (!E->getArgument()->isTypeDependent()) { 8585 QualType Destroyed = SemaRef.Context.getBaseElementType( 8586 E->getDestroyedType()); 8587 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 8588 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 8589 SemaRef.MarkFunctionReferenced(E->getLocStart(), 8590 SemaRef.LookupDestructor(Record)); 8591 } 8592 } 8593 8594 return E; 8595 } 8596 8597 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 8598 E->isGlobalDelete(), 8599 E->isArrayForm(), 8600 Operand.get()); 8601 } 8602 8603 template<typename Derived> 8604 ExprResult 8605 TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 8606 CXXPseudoDestructorExpr *E) { 8607 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8608 if (Base.isInvalid()) 8609 return ExprError(); 8610 8611 ParsedType ObjectTypePtr; 8612 bool MayBePseudoDestructor = false; 8613 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), 8614 E->getOperatorLoc(), 8615 E->isArrow()? tok::arrow : tok::period, 8616 ObjectTypePtr, 8617 MayBePseudoDestructor); 8618 if (Base.isInvalid()) 8619 return ExprError(); 8620 8621 QualType ObjectType = ObjectTypePtr.get(); 8622 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc(); 8623 if (QualifierLoc) { 8624 QualifierLoc 8625 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType); 8626 if (!QualifierLoc) 8627 return ExprError(); 8628 } 8629 CXXScopeSpec SS; 8630 SS.Adopt(QualifierLoc); 8631 8632 PseudoDestructorTypeStorage Destroyed; 8633 if (E->getDestroyedTypeInfo()) { 8634 TypeSourceInfo *DestroyedTypeInfo 8635 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 8636 ObjectType, nullptr, SS); 8637 if (!DestroyedTypeInfo) 8638 return ExprError(); 8639 Destroyed = DestroyedTypeInfo; 8640 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) { 8641 // We aren't likely to be able to resolve the identifier down to a type 8642 // now anyway, so just retain the identifier. 8643 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 8644 E->getDestroyedTypeLoc()); 8645 } else { 8646 // Look for a destructor known with the given name. 8647 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 8648 *E->getDestroyedTypeIdentifier(), 8649 E->getDestroyedTypeLoc(), 8650 /*Scope=*/nullptr, 8651 SS, ObjectTypePtr, 8652 false); 8653 if (!T) 8654 return ExprError(); 8655 8656 Destroyed 8657 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 8658 E->getDestroyedTypeLoc()); 8659 } 8660 8661 TypeSourceInfo *ScopeTypeInfo = nullptr; 8662 if (E->getScopeTypeInfo()) { 8663 CXXScopeSpec EmptySS; 8664 ScopeTypeInfo = getDerived().TransformTypeInObjectScope( 8665 E->getScopeTypeInfo(), ObjectType, nullptr, EmptySS); 8666 if (!ScopeTypeInfo) 8667 return ExprError(); 8668 } 8669 8670 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 8671 E->getOperatorLoc(), 8672 E->isArrow(), 8673 SS, 8674 ScopeTypeInfo, 8675 E->getColonColonLoc(), 8676 E->getTildeLoc(), 8677 Destroyed); 8678 } 8679 8680 template<typename Derived> 8681 ExprResult 8682 TreeTransform<Derived>::TransformUnresolvedLookupExpr( 8683 UnresolvedLookupExpr *Old) { 8684 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 8685 Sema::LookupOrdinaryName); 8686 8687 // Transform all the decls. 8688 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 8689 E = Old->decls_end(); I != E; ++I) { 8690 NamedDecl *InstD = static_cast<NamedDecl*>( 8691 getDerived().TransformDecl(Old->getNameLoc(), 8692 *I)); 8693 if (!InstD) { 8694 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 8695 // This can happen because of dependent hiding. 8696 if (isa<UsingShadowDecl>(*I)) 8697 continue; 8698 else { 8699 R.clear(); 8700 return ExprError(); 8701 } 8702 } 8703 8704 // Expand using declarations. 8705 if (isa<UsingDecl>(InstD)) { 8706 UsingDecl *UD = cast<UsingDecl>(InstD); 8707 for (auto *I : UD->shadows()) 8708 R.addDecl(I); 8709 continue; 8710 } 8711 8712 R.addDecl(InstD); 8713 } 8714 8715 // Resolve a kind, but don't do any further analysis. If it's 8716 // ambiguous, the callee needs to deal with it. 8717 R.resolveKind(); 8718 8719 // Rebuild the nested-name qualifier, if present. 8720 CXXScopeSpec SS; 8721 if (Old->getQualifierLoc()) { 8722 NestedNameSpecifierLoc QualifierLoc 8723 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 8724 if (!QualifierLoc) 8725 return ExprError(); 8726 8727 SS.Adopt(QualifierLoc); 8728 } 8729 8730 if (Old->getNamingClass()) { 8731 CXXRecordDecl *NamingClass 8732 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 8733 Old->getNameLoc(), 8734 Old->getNamingClass())); 8735 if (!NamingClass) { 8736 R.clear(); 8737 return ExprError(); 8738 } 8739 8740 R.setNamingClass(NamingClass); 8741 } 8742 8743 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 8744 8745 // If we have neither explicit template arguments, nor the template keyword, 8746 // it's a normal declaration name. 8747 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) 8748 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 8749 8750 // If we have template arguments, rebuild them, then rebuild the 8751 // templateid expression. 8752 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 8753 if (Old->hasExplicitTemplateArgs() && 8754 getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 8755 Old->getNumTemplateArgs(), 8756 TransArgs)) { 8757 R.clear(); 8758 return ExprError(); 8759 } 8760 8761 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R, 8762 Old->requiresADL(), &TransArgs); 8763 } 8764 8765 template<typename Derived> 8766 ExprResult 8767 TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { 8768 bool ArgChanged = false; 8769 SmallVector<TypeSourceInfo *, 4> Args; 8770 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 8771 TypeSourceInfo *From = E->getArg(I); 8772 TypeLoc FromTL = From->getTypeLoc(); 8773 if (!FromTL.getAs<PackExpansionTypeLoc>()) { 8774 TypeLocBuilder TLB; 8775 TLB.reserve(FromTL.getFullDataSize()); 8776 QualType To = getDerived().TransformType(TLB, FromTL); 8777 if (To.isNull()) 8778 return ExprError(); 8779 8780 if (To == From->getType()) 8781 Args.push_back(From); 8782 else { 8783 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8784 ArgChanged = true; 8785 } 8786 continue; 8787 } 8788 8789 ArgChanged = true; 8790 8791 // We have a pack expansion. Instantiate it. 8792 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>(); 8793 TypeLoc PatternTL = ExpansionTL.getPatternLoc(); 8794 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 8795 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded); 8796 8797 // Determine whether the set of unexpanded parameter packs can and should 8798 // be expanded. 8799 bool Expand = true; 8800 bool RetainExpansion = false; 8801 Optional<unsigned> OrigNumExpansions = 8802 ExpansionTL.getTypePtr()->getNumExpansions(); 8803 Optional<unsigned> NumExpansions = OrigNumExpansions; 8804 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 8805 PatternTL.getSourceRange(), 8806 Unexpanded, 8807 Expand, RetainExpansion, 8808 NumExpansions)) 8809 return ExprError(); 8810 8811 if (!Expand) { 8812 // The transform has determined that we should perform a simple 8813 // transformation on the pack expansion, producing another pack 8814 // expansion. 8815 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 8816 8817 TypeLocBuilder TLB; 8818 TLB.reserve(From->getTypeLoc().getFullDataSize()); 8819 8820 QualType To = getDerived().TransformType(TLB, PatternTL); 8821 if (To.isNull()) 8822 return ExprError(); 8823 8824 To = getDerived().RebuildPackExpansionType(To, 8825 PatternTL.getSourceRange(), 8826 ExpansionTL.getEllipsisLoc(), 8827 NumExpansions); 8828 if (To.isNull()) 8829 return ExprError(); 8830 8831 PackExpansionTypeLoc ToExpansionTL 8832 = TLB.push<PackExpansionTypeLoc>(To); 8833 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8834 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8835 continue; 8836 } 8837 8838 // Expand the pack expansion by substituting for each argument in the 8839 // pack(s). 8840 for (unsigned I = 0; I != *NumExpansions; ++I) { 8841 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 8842 TypeLocBuilder TLB; 8843 TLB.reserve(PatternTL.getFullDataSize()); 8844 QualType To = getDerived().TransformType(TLB, PatternTL); 8845 if (To.isNull()) 8846 return ExprError(); 8847 8848 if (To->containsUnexpandedParameterPack()) { 8849 To = getDerived().RebuildPackExpansionType(To, 8850 PatternTL.getSourceRange(), 8851 ExpansionTL.getEllipsisLoc(), 8852 NumExpansions); 8853 if (To.isNull()) 8854 return ExprError(); 8855 8856 PackExpansionTypeLoc ToExpansionTL 8857 = TLB.push<PackExpansionTypeLoc>(To); 8858 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8859 } 8860 8861 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8862 } 8863 8864 if (!RetainExpansion) 8865 continue; 8866 8867 // If we're supposed to retain a pack expansion, do so by temporarily 8868 // forgetting the partially-substituted parameter pack. 8869 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 8870 8871 TypeLocBuilder TLB; 8872 TLB.reserve(From->getTypeLoc().getFullDataSize()); 8873 8874 QualType To = getDerived().TransformType(TLB, PatternTL); 8875 if (To.isNull()) 8876 return ExprError(); 8877 8878 To = getDerived().RebuildPackExpansionType(To, 8879 PatternTL.getSourceRange(), 8880 ExpansionTL.getEllipsisLoc(), 8881 NumExpansions); 8882 if (To.isNull()) 8883 return ExprError(); 8884 8885 PackExpansionTypeLoc ToExpansionTL 8886 = TLB.push<PackExpansionTypeLoc>(To); 8887 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 8888 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 8889 } 8890 8891 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8892 return E; 8893 8894 return getDerived().RebuildTypeTrait(E->getTrait(), 8895 E->getLocStart(), 8896 Args, 8897 E->getLocEnd()); 8898 } 8899 8900 template<typename Derived> 8901 ExprResult 8902 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 8903 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 8904 if (!T) 8905 return ExprError(); 8906 8907 if (!getDerived().AlwaysRebuild() && 8908 T == E->getQueriedTypeSourceInfo()) 8909 return E; 8910 8911 ExprResult SubExpr; 8912 { 8913 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8914 SubExpr = getDerived().TransformExpr(E->getDimensionExpression()); 8915 if (SubExpr.isInvalid()) 8916 return ExprError(); 8917 8918 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression()) 8919 return E; 8920 } 8921 8922 return getDerived().RebuildArrayTypeTrait(E->getTrait(), 8923 E->getLocStart(), 8924 T, 8925 SubExpr.get(), 8926 E->getLocEnd()); 8927 } 8928 8929 template<typename Derived> 8930 ExprResult 8931 TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { 8932 ExprResult SubExpr; 8933 { 8934 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8935 SubExpr = getDerived().TransformExpr(E->getQueriedExpression()); 8936 if (SubExpr.isInvalid()) 8937 return ExprError(); 8938 8939 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) 8940 return E; 8941 } 8942 8943 return getDerived().RebuildExpressionTrait( 8944 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd()); 8945 } 8946 8947 template <typename Derived> 8948 ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr( 8949 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken, 8950 TypeSourceInfo **RecoveryTSI) { 8951 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr( 8952 DRE, AddrTaken, RecoveryTSI); 8953 8954 // Propagate both errors and recovered types, which return ExprEmpty. 8955 if (!NewDRE.isUsable()) 8956 return NewDRE; 8957 8958 // We got an expr, wrap it up in parens. 8959 if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE) 8960 return PE; 8961 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(), 8962 PE->getRParen()); 8963 } 8964 8965 template <typename Derived> 8966 ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 8967 DependentScopeDeclRefExpr *E) { 8968 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false, 8969 nullptr); 8970 } 8971 8972 template<typename Derived> 8973 ExprResult 8974 TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 8975 DependentScopeDeclRefExpr *E, 8976 bool IsAddressOfOperand, 8977 TypeSourceInfo **RecoveryTSI) { 8978 assert(E->getQualifierLoc()); 8979 NestedNameSpecifierLoc QualifierLoc 8980 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 8981 if (!QualifierLoc) 8982 return ExprError(); 8983 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 8984 8985 // TODO: If this is a conversion-function-id, verify that the 8986 // destination type name (if present) resolves the same way after 8987 // instantiation as it did in the local scope. 8988 8989 DeclarationNameInfo NameInfo 8990 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 8991 if (!NameInfo.getName()) 8992 return ExprError(); 8993 8994 if (!E->hasExplicitTemplateArgs()) { 8995 if (!getDerived().AlwaysRebuild() && 8996 QualifierLoc == E->getQualifierLoc() && 8997 // Note: it is sufficient to compare the Name component of NameInfo: 8998 // if name has not changed, DNLoc has not changed either. 8999 NameInfo.getName() == E->getDeclName()) 9000 return E; 9001 9002 return getDerived().RebuildDependentScopeDeclRefExpr( 9003 QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr, 9004 IsAddressOfOperand, RecoveryTSI); 9005 } 9006 9007 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 9008 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 9009 E->getNumTemplateArgs(), 9010 TransArgs)) 9011 return ExprError(); 9012 9013 return getDerived().RebuildDependentScopeDeclRefExpr( 9014 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand, 9015 RecoveryTSI); 9016 } 9017 9018 template<typename Derived> 9019 ExprResult 9020 TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 9021 // CXXConstructExprs other than for list-initialization and 9022 // CXXTemporaryObjectExpr are always implicit, so when we have 9023 // a 1-argument construction we just transform that argument. 9024 if ((E->getNumArgs() == 1 || 9025 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) && 9026 (!getDerived().DropCallArgument(E->getArg(0))) && 9027 !E->isListInitialization()) 9028 return getDerived().TransformExpr(E->getArg(0)); 9029 9030 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 9031 9032 QualType T = getDerived().TransformType(E->getType()); 9033 if (T.isNull()) 9034 return ExprError(); 9035 9036 CXXConstructorDecl *Constructor 9037 = cast_or_null<CXXConstructorDecl>( 9038 getDerived().TransformDecl(E->getLocStart(), 9039 E->getConstructor())); 9040 if (!Constructor) 9041 return ExprError(); 9042 9043 bool ArgumentChanged = false; 9044 SmallVector<Expr*, 8> Args; 9045 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 9046 &ArgumentChanged)) 9047 return ExprError(); 9048 9049 if (!getDerived().AlwaysRebuild() && 9050 T == E->getType() && 9051 Constructor == E->getConstructor() && 9052 !ArgumentChanged) { 9053 // Mark the constructor as referenced. 9054 // FIXME: Instantiation-specific 9055 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 9056 return E; 9057 } 9058 9059 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 9060 Constructor, E->isElidable(), 9061 Args, 9062 E->hadMultipleCandidates(), 9063 E->isListInitialization(), 9064 E->isStdInitListInitialization(), 9065 E->requiresZeroInitialization(), 9066 E->getConstructionKind(), 9067 E->getParenOrBraceRange()); 9068 } 9069 9070 /// \brief Transform a C++ temporary-binding expression. 9071 /// 9072 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 9073 /// transform the subexpression and return that. 9074 template<typename Derived> 9075 ExprResult 9076 TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 9077 return getDerived().TransformExpr(E->getSubExpr()); 9078 } 9079 9080 /// \brief Transform a C++ expression that contains cleanups that should 9081 /// be run after the expression is evaluated. 9082 /// 9083 /// Since ExprWithCleanups nodes are implicitly generated, we 9084 /// just transform the subexpression and return that. 9085 template<typename Derived> 9086 ExprResult 9087 TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 9088 return getDerived().TransformExpr(E->getSubExpr()); 9089 } 9090 9091 template<typename Derived> 9092 ExprResult 9093 TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 9094 CXXTemporaryObjectExpr *E) { 9095 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 9096 if (!T) 9097 return ExprError(); 9098 9099 CXXConstructorDecl *Constructor 9100 = cast_or_null<CXXConstructorDecl>( 9101 getDerived().TransformDecl(E->getLocStart(), 9102 E->getConstructor())); 9103 if (!Constructor) 9104 return ExprError(); 9105 9106 bool ArgumentChanged = false; 9107 SmallVector<Expr*, 8> Args; 9108 Args.reserve(E->getNumArgs()); 9109 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 9110 &ArgumentChanged)) 9111 return ExprError(); 9112 9113 if (!getDerived().AlwaysRebuild() && 9114 T == E->getTypeSourceInfo() && 9115 Constructor == E->getConstructor() && 9116 !ArgumentChanged) { 9117 // FIXME: Instantiation-specific 9118 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 9119 return SemaRef.MaybeBindToTemporary(E); 9120 } 9121 9122 // FIXME: Pass in E->isListInitialization(). 9123 return getDerived().RebuildCXXTemporaryObjectExpr(T, 9124 /*FIXME:*/T->getTypeLoc().getEndLoc(), 9125 Args, 9126 E->getLocEnd()); 9127 } 9128 9129 template<typename Derived> 9130 ExprResult 9131 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { 9132 // Transform any init-capture expressions before entering the scope of the 9133 // lambda body, because they are not semantically within that scope. 9134 SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes; 9135 InitCaptureExprsAndTypes.resize(E->explicit_capture_end() - 9136 E->explicit_capture_begin()); 9137 for (LambdaExpr::capture_iterator C = E->capture_begin(), 9138 CEnd = E->capture_end(); 9139 C != CEnd; ++C) { 9140 if (!C->isInitCapture()) 9141 continue; 9142 EnterExpressionEvaluationContext EEEC(getSema(), 9143 Sema::PotentiallyEvaluated); 9144 ExprResult NewExprInitResult = getDerived().TransformInitializer( 9145 C->getCapturedVar()->getInit(), 9146 C->getCapturedVar()->getInitStyle() == VarDecl::CallInit); 9147 9148 if (NewExprInitResult.isInvalid()) 9149 return ExprError(); 9150 Expr *NewExprInit = NewExprInitResult.get(); 9151 9152 VarDecl *OldVD = C->getCapturedVar(); 9153 QualType NewInitCaptureType = 9154 getSema().performLambdaInitCaptureInitialization(C->getLocation(), 9155 OldVD->getType()->isReferenceType(), OldVD->getIdentifier(), 9156 NewExprInit); 9157 NewExprInitResult = NewExprInit; 9158 InitCaptureExprsAndTypes[C - E->capture_begin()] = 9159 std::make_pair(NewExprInitResult, NewInitCaptureType); 9160 } 9161 9162 LambdaScopeInfo *LSI = getSema().PushLambdaScope(); 9163 Sema::FunctionScopeRAII FuncScopeCleanup(getSema()); 9164 9165 // Transform the template parameters, and add them to the current 9166 // instantiation scope. The null case is handled correctly. 9167 LSI->GLTemplateParameterList = getDerived().TransformTemplateParameterList( 9168 E->getTemplateParameterList()); 9169 9170 // Transform the type of the original lambda's call operator. 9171 // The transformation MUST be done in the CurrentInstantiationScope since 9172 // it introduces a mapping of the original to the newly created 9173 // transformed parameters. 9174 TypeSourceInfo *NewCallOpTSI = nullptr; 9175 { 9176 TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo(); 9177 FunctionProtoTypeLoc OldCallOpFPTL = 9178 OldCallOpTSI->getTypeLoc().getAs<FunctionProtoTypeLoc>(); 9179 9180 TypeLocBuilder NewCallOpTLBuilder; 9181 SmallVector<QualType, 4> ExceptionStorage; 9182 TreeTransform *This = this; // Work around gcc.gnu.org/PR56135. 9183 QualType NewCallOpType = TransformFunctionProtoType( 9184 NewCallOpTLBuilder, OldCallOpFPTL, nullptr, 0, 9185 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) { 9186 return This->TransformExceptionSpec(OldCallOpFPTL.getBeginLoc(), ESI, 9187 ExceptionStorage, Changed); 9188 }); 9189 if (NewCallOpType.isNull()) 9190 return ExprError(); 9191 NewCallOpTSI = NewCallOpTLBuilder.getTypeSourceInfo(getSema().Context, 9192 NewCallOpType); 9193 } 9194 9195 // Create the local class that will describe the lambda. 9196 CXXRecordDecl *Class 9197 = getSema().createLambdaClosureType(E->getIntroducerRange(), 9198 NewCallOpTSI, 9199 /*KnownDependent=*/false, 9200 E->getCaptureDefault()); 9201 getDerived().transformedLocalDecl(E->getLambdaClass(), Class); 9202 9203 // Build the call operator. 9204 CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition( 9205 Class, E->getIntroducerRange(), NewCallOpTSI, 9206 E->getCallOperator()->getLocEnd(), 9207 NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams()); 9208 LSI->CallOperator = NewCallOperator; 9209 9210 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator); 9211 9212 // TransformLambdaScope will manage the function scope, so we can disable the 9213 // cleanup. 9214 FuncScopeCleanup.disable(); 9215 9216 return getDerived().TransformLambdaScope(E, NewCallOperator, 9217 InitCaptureExprsAndTypes); 9218 } 9219 9220 template<typename Derived> 9221 ExprResult 9222 TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, 9223 CXXMethodDecl *CallOperator, 9224 ArrayRef<InitCaptureInfoTy> InitCaptureExprsAndTypes) { 9225 bool Invalid = false; 9226 9227 // Introduce the context of the call operator. 9228 Sema::ContextRAII SavedContext(getSema(), CallOperator, 9229 /*NewThisContext*/false); 9230 9231 LambdaScopeInfo *const LSI = getSema().getCurLambda(); 9232 // Enter the scope of the lambda. 9233 getSema().buildLambdaScope(LSI, CallOperator, E->getIntroducerRange(), 9234 E->getCaptureDefault(), 9235 E->getCaptureDefaultLoc(), 9236 E->hasExplicitParameters(), 9237 E->hasExplicitResultType(), 9238 E->isMutable()); 9239 9240 // Transform captures. 9241 bool FinishedExplicitCaptures = false; 9242 for (LambdaExpr::capture_iterator C = E->capture_begin(), 9243 CEnd = E->capture_end(); 9244 C != CEnd; ++C) { 9245 // When we hit the first implicit capture, tell Sema that we've finished 9246 // the list of explicit captures. 9247 if (!FinishedExplicitCaptures && C->isImplicit()) { 9248 getSema().finishLambdaExplicitCaptures(LSI); 9249 FinishedExplicitCaptures = true; 9250 } 9251 9252 // Capturing 'this' is trivial. 9253 if (C->capturesThis()) { 9254 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit()); 9255 continue; 9256 } 9257 // Captured expression will be recaptured during captured variables 9258 // rebuilding. 9259 if (C->capturesVLAType()) 9260 continue; 9261 9262 // Rebuild init-captures, including the implied field declaration. 9263 if (C->isInitCapture()) { 9264 9265 InitCaptureInfoTy InitExprTypePair = 9266 InitCaptureExprsAndTypes[C - E->capture_begin()]; 9267 ExprResult Init = InitExprTypePair.first; 9268 QualType InitQualType = InitExprTypePair.second; 9269 if (Init.isInvalid() || InitQualType.isNull()) { 9270 Invalid = true; 9271 continue; 9272 } 9273 VarDecl *OldVD = C->getCapturedVar(); 9274 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl( 9275 OldVD->getLocation(), InitExprTypePair.second, 9276 OldVD->getIdentifier(), Init.get()); 9277 if (!NewVD) 9278 Invalid = true; 9279 else { 9280 getDerived().transformedLocalDecl(OldVD, NewVD); 9281 } 9282 getSema().buildInitCaptureField(LSI, NewVD); 9283 continue; 9284 } 9285 9286 assert(C->capturesVariable() && "unexpected kind of lambda capture"); 9287 9288 // Determine the capture kind for Sema. 9289 Sema::TryCaptureKind Kind 9290 = C->isImplicit()? Sema::TryCapture_Implicit 9291 : C->getCaptureKind() == LCK_ByCopy 9292 ? Sema::TryCapture_ExplicitByVal 9293 : Sema::TryCapture_ExplicitByRef; 9294 SourceLocation EllipsisLoc; 9295 if (C->isPackExpansion()) { 9296 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); 9297 bool ShouldExpand = false; 9298 bool RetainExpansion = false; 9299 Optional<unsigned> NumExpansions; 9300 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), 9301 C->getLocation(), 9302 Unexpanded, 9303 ShouldExpand, RetainExpansion, 9304 NumExpansions)) { 9305 Invalid = true; 9306 continue; 9307 } 9308 9309 if (ShouldExpand) { 9310 // The transform has determined that we should perform an expansion; 9311 // transform and capture each of the arguments. 9312 // expansion of the pattern. Do so. 9313 VarDecl *Pack = C->getCapturedVar(); 9314 for (unsigned I = 0; I != *NumExpansions; ++I) { 9315 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 9316 VarDecl *CapturedVar 9317 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 9318 Pack)); 9319 if (!CapturedVar) { 9320 Invalid = true; 9321 continue; 9322 } 9323 9324 // Capture the transformed variable. 9325 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 9326 } 9327 9328 // FIXME: Retain a pack expansion if RetainExpansion is true. 9329 9330 continue; 9331 } 9332 9333 EllipsisLoc = C->getEllipsisLoc(); 9334 } 9335 9336 // Transform the captured variable. 9337 VarDecl *CapturedVar 9338 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 9339 C->getCapturedVar())); 9340 if (!CapturedVar || CapturedVar->isInvalidDecl()) { 9341 Invalid = true; 9342 continue; 9343 } 9344 9345 // Capture the transformed variable. 9346 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 9347 } 9348 if (!FinishedExplicitCaptures) 9349 getSema().finishLambdaExplicitCaptures(LSI); 9350 9351 9352 // Enter a new evaluation context to insulate the lambda from any 9353 // cleanups from the enclosing full-expression. 9354 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 9355 9356 if (Invalid) { 9357 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, 9358 /*IsInstantiation=*/true); 9359 return ExprError(); 9360 } 9361 9362 // Instantiate the body of the lambda expression. 9363 StmtResult Body = getDerived().TransformStmt(E->getBody()); 9364 if (Body.isInvalid()) { 9365 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/nullptr, 9366 /*IsInstantiation=*/true); 9367 return ExprError(); 9368 } 9369 9370 return getSema().ActOnLambdaExpr(E->getLocStart(), Body.get(), 9371 /*CurScope=*/nullptr, 9372 /*IsInstantiation=*/true); 9373 } 9374 9375 template<typename Derived> 9376 ExprResult 9377 TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 9378 CXXUnresolvedConstructExpr *E) { 9379 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 9380 if (!T) 9381 return ExprError(); 9382 9383 bool ArgumentChanged = false; 9384 SmallVector<Expr*, 8> Args; 9385 Args.reserve(E->arg_size()); 9386 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 9387 &ArgumentChanged)) 9388 return ExprError(); 9389 9390 if (!getDerived().AlwaysRebuild() && 9391 T == E->getTypeSourceInfo() && 9392 !ArgumentChanged) 9393 return E; 9394 9395 // FIXME: we're faking the locations of the commas 9396 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 9397 E->getLParenLoc(), 9398 Args, 9399 E->getRParenLoc()); 9400 } 9401 9402 template<typename Derived> 9403 ExprResult 9404 TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 9405 CXXDependentScopeMemberExpr *E) { 9406 // Transform the base of the expression. 9407 ExprResult Base((Expr*) nullptr); 9408 Expr *OldBase; 9409 QualType BaseType; 9410 QualType ObjectType; 9411 if (!E->isImplicitAccess()) { 9412 OldBase = E->getBase(); 9413 Base = getDerived().TransformExpr(OldBase); 9414 if (Base.isInvalid()) 9415 return ExprError(); 9416 9417 // Start the member reference and compute the object's type. 9418 ParsedType ObjectTy; 9419 bool MayBePseudoDestructor = false; 9420 Base = SemaRef.ActOnStartCXXMemberReference(nullptr, Base.get(), 9421 E->getOperatorLoc(), 9422 E->isArrow()? tok::arrow : tok::period, 9423 ObjectTy, 9424 MayBePseudoDestructor); 9425 if (Base.isInvalid()) 9426 return ExprError(); 9427 9428 ObjectType = ObjectTy.get(); 9429 BaseType = ((Expr*) Base.get())->getType(); 9430 } else { 9431 OldBase = nullptr; 9432 BaseType = getDerived().TransformType(E->getBaseType()); 9433 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 9434 } 9435 9436 // Transform the first part of the nested-name-specifier that qualifies 9437 // the member name. 9438 NamedDecl *FirstQualifierInScope 9439 = getDerived().TransformFirstQualifierInScope( 9440 E->getFirstQualifierFoundInScope(), 9441 E->getQualifierLoc().getBeginLoc()); 9442 9443 NestedNameSpecifierLoc QualifierLoc; 9444 if (E->getQualifier()) { 9445 QualifierLoc 9446 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 9447 ObjectType, 9448 FirstQualifierInScope); 9449 if (!QualifierLoc) 9450 return ExprError(); 9451 } 9452 9453 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 9454 9455 // TODO: If this is a conversion-function-id, verify that the 9456 // destination type name (if present) resolves the same way after 9457 // instantiation as it did in the local scope. 9458 9459 DeclarationNameInfo NameInfo 9460 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 9461 if (!NameInfo.getName()) 9462 return ExprError(); 9463 9464 if (!E->hasExplicitTemplateArgs()) { 9465 // This is a reference to a member without an explicitly-specified 9466 // template argument list. Optimize for this common case. 9467 if (!getDerived().AlwaysRebuild() && 9468 Base.get() == OldBase && 9469 BaseType == E->getBaseType() && 9470 QualifierLoc == E->getQualifierLoc() && 9471 NameInfo.getName() == E->getMember() && 9472 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 9473 return E; 9474 9475 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 9476 BaseType, 9477 E->isArrow(), 9478 E->getOperatorLoc(), 9479 QualifierLoc, 9480 TemplateKWLoc, 9481 FirstQualifierInScope, 9482 NameInfo, 9483 /*TemplateArgs*/nullptr); 9484 } 9485 9486 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 9487 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 9488 E->getNumTemplateArgs(), 9489 TransArgs)) 9490 return ExprError(); 9491 9492 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 9493 BaseType, 9494 E->isArrow(), 9495 E->getOperatorLoc(), 9496 QualifierLoc, 9497 TemplateKWLoc, 9498 FirstQualifierInScope, 9499 NameInfo, 9500 &TransArgs); 9501 } 9502 9503 template<typename Derived> 9504 ExprResult 9505 TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 9506 // Transform the base of the expression. 9507 ExprResult Base((Expr*) nullptr); 9508 QualType BaseType; 9509 if (!Old->isImplicitAccess()) { 9510 Base = getDerived().TransformExpr(Old->getBase()); 9511 if (Base.isInvalid()) 9512 return ExprError(); 9513 Base = getSema().PerformMemberExprBaseConversion(Base.get(), 9514 Old->isArrow()); 9515 if (Base.isInvalid()) 9516 return ExprError(); 9517 BaseType = Base.get()->getType(); 9518 } else { 9519 BaseType = getDerived().TransformType(Old->getBaseType()); 9520 } 9521 9522 NestedNameSpecifierLoc QualifierLoc; 9523 if (Old->getQualifierLoc()) { 9524 QualifierLoc 9525 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 9526 if (!QualifierLoc) 9527 return ExprError(); 9528 } 9529 9530 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 9531 9532 LookupResult R(SemaRef, Old->getMemberNameInfo(), 9533 Sema::LookupOrdinaryName); 9534 9535 // Transform all the decls. 9536 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 9537 E = Old->decls_end(); I != E; ++I) { 9538 NamedDecl *InstD = static_cast<NamedDecl*>( 9539 getDerived().TransformDecl(Old->getMemberLoc(), 9540 *I)); 9541 if (!InstD) { 9542 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 9543 // This can happen because of dependent hiding. 9544 if (isa<UsingShadowDecl>(*I)) 9545 continue; 9546 else { 9547 R.clear(); 9548 return ExprError(); 9549 } 9550 } 9551 9552 // Expand using declarations. 9553 if (isa<UsingDecl>(InstD)) { 9554 UsingDecl *UD = cast<UsingDecl>(InstD); 9555 for (auto *I : UD->shadows()) 9556 R.addDecl(I); 9557 continue; 9558 } 9559 9560 R.addDecl(InstD); 9561 } 9562 9563 R.resolveKind(); 9564 9565 // Determine the naming class. 9566 if (Old->getNamingClass()) { 9567 CXXRecordDecl *NamingClass 9568 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 9569 Old->getMemberLoc(), 9570 Old->getNamingClass())); 9571 if (!NamingClass) 9572 return ExprError(); 9573 9574 R.setNamingClass(NamingClass); 9575 } 9576 9577 TemplateArgumentListInfo TransArgs; 9578 if (Old->hasExplicitTemplateArgs()) { 9579 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 9580 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 9581 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 9582 Old->getNumTemplateArgs(), 9583 TransArgs)) 9584 return ExprError(); 9585 } 9586 9587 // FIXME: to do this check properly, we will need to preserve the 9588 // first-qualifier-in-scope here, just in case we had a dependent 9589 // base (and therefore couldn't do the check) and a 9590 // nested-name-qualifier (and therefore could do the lookup). 9591 NamedDecl *FirstQualifierInScope = nullptr; 9592 9593 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 9594 BaseType, 9595 Old->getOperatorLoc(), 9596 Old->isArrow(), 9597 QualifierLoc, 9598 TemplateKWLoc, 9599 FirstQualifierInScope, 9600 R, 9601 (Old->hasExplicitTemplateArgs() 9602 ? &TransArgs : nullptr)); 9603 } 9604 9605 template<typename Derived> 9606 ExprResult 9607 TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 9608 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 9609 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 9610 if (SubExpr.isInvalid()) 9611 return ExprError(); 9612 9613 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 9614 return E; 9615 9616 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 9617 } 9618 9619 template<typename Derived> 9620 ExprResult 9621 TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 9622 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 9623 if (Pattern.isInvalid()) 9624 return ExprError(); 9625 9626 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 9627 return E; 9628 9629 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 9630 E->getNumExpansions()); 9631 } 9632 9633 template<typename Derived> 9634 ExprResult 9635 TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 9636 // If E is not value-dependent, then nothing will change when we transform it. 9637 // Note: This is an instantiation-centric view. 9638 if (!E->isValueDependent()) 9639 return E; 9640 9641 // Note: None of the implementations of TryExpandParameterPacks can ever 9642 // produce a diagnostic when given only a single unexpanded parameter pack, 9643 // so 9644 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 9645 bool ShouldExpand = false; 9646 bool RetainExpansion = false; 9647 Optional<unsigned> NumExpansions; 9648 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 9649 Unexpanded, 9650 ShouldExpand, RetainExpansion, 9651 NumExpansions)) 9652 return ExprError(); 9653 9654 if (RetainExpansion) 9655 return E; 9656 9657 NamedDecl *Pack = E->getPack(); 9658 if (!ShouldExpand) { 9659 Pack = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getPackLoc(), 9660 Pack)); 9661 if (!Pack) 9662 return ExprError(); 9663 } 9664 9665 9666 // We now know the length of the parameter pack, so build a new expression 9667 // that stores that length. 9668 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, 9669 E->getPackLoc(), E->getRParenLoc(), 9670 NumExpansions); 9671 } 9672 9673 template<typename Derived> 9674 ExprResult 9675 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 9676 SubstNonTypeTemplateParmPackExpr *E) { 9677 // Default behavior is to do nothing with this transformation. 9678 return E; 9679 } 9680 9681 template<typename Derived> 9682 ExprResult 9683 TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( 9684 SubstNonTypeTemplateParmExpr *E) { 9685 // Default behavior is to do nothing with this transformation. 9686 return E; 9687 } 9688 9689 template<typename Derived> 9690 ExprResult 9691 TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { 9692 // Default behavior is to do nothing with this transformation. 9693 return E; 9694 } 9695 9696 template<typename Derived> 9697 ExprResult 9698 TreeTransform<Derived>::TransformMaterializeTemporaryExpr( 9699 MaterializeTemporaryExpr *E) { 9700 return getDerived().TransformExpr(E->GetTemporaryExpr()); 9701 } 9702 9703 template<typename Derived> 9704 ExprResult 9705 TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) { 9706 Expr *Pattern = E->getPattern(); 9707 9708 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 9709 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 9710 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 9711 9712 // Determine whether the set of unexpanded parameter packs can and should 9713 // be expanded. 9714 bool Expand = true; 9715 bool RetainExpansion = false; 9716 Optional<unsigned> NumExpansions; 9717 if (getDerived().TryExpandParameterPacks(E->getEllipsisLoc(), 9718 Pattern->getSourceRange(), 9719 Unexpanded, 9720 Expand, RetainExpansion, 9721 NumExpansions)) 9722 return true; 9723 9724 if (!Expand) { 9725 // Do not expand any packs here, just transform and rebuild a fold 9726 // expression. 9727 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 9728 9729 ExprResult LHS = 9730 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult(); 9731 if (LHS.isInvalid()) 9732 return true; 9733 9734 ExprResult RHS = 9735 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult(); 9736 if (RHS.isInvalid()) 9737 return true; 9738 9739 if (!getDerived().AlwaysRebuild() && 9740 LHS.get() == E->getLHS() && RHS.get() == E->getRHS()) 9741 return E; 9742 9743 return getDerived().RebuildCXXFoldExpr( 9744 E->getLocStart(), LHS.get(), E->getOperator(), E->getEllipsisLoc(), 9745 RHS.get(), E->getLocEnd()); 9746 } 9747 9748 // The transform has determined that we should perform an elementwise 9749 // expansion of the pattern. Do so. 9750 ExprResult Result = getDerived().TransformExpr(E->getInit()); 9751 if (Result.isInvalid()) 9752 return true; 9753 bool LeftFold = E->isLeftFold(); 9754 9755 // If we're retaining an expansion for a right fold, it is the innermost 9756 // component and takes the init (if any). 9757 if (!LeftFold && RetainExpansion) { 9758 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 9759 9760 ExprResult Out = getDerived().TransformExpr(Pattern); 9761 if (Out.isInvalid()) 9762 return true; 9763 9764 Result = getDerived().RebuildCXXFoldExpr( 9765 E->getLocStart(), Out.get(), E->getOperator(), E->getEllipsisLoc(), 9766 Result.get(), E->getLocEnd()); 9767 if (Result.isInvalid()) 9768 return true; 9769 } 9770 9771 for (unsigned I = 0; I != *NumExpansions; ++I) { 9772 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex( 9773 getSema(), LeftFold ? I : *NumExpansions - I - 1); 9774 ExprResult Out = getDerived().TransformExpr(Pattern); 9775 if (Out.isInvalid()) 9776 return true; 9777 9778 if (Out.get()->containsUnexpandedParameterPack()) { 9779 // We still have a pack; retain a pack expansion for this slice. 9780 Result = getDerived().RebuildCXXFoldExpr( 9781 E->getLocStart(), 9782 LeftFold ? Result.get() : Out.get(), 9783 E->getOperator(), E->getEllipsisLoc(), 9784 LeftFold ? Out.get() : Result.get(), 9785 E->getLocEnd()); 9786 } else if (Result.isUsable()) { 9787 // We've got down to a single element; build a binary operator. 9788 Result = getDerived().RebuildBinaryOperator( 9789 E->getEllipsisLoc(), E->getOperator(), 9790 LeftFold ? Result.get() : Out.get(), 9791 LeftFold ? Out.get() : Result.get()); 9792 } else 9793 Result = Out; 9794 9795 if (Result.isInvalid()) 9796 return true; 9797 } 9798 9799 // If we're retaining an expansion for a left fold, it is the outermost 9800 // component and takes the complete expansion so far as its init (if any). 9801 if (LeftFold && RetainExpansion) { 9802 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 9803 9804 ExprResult Out = getDerived().TransformExpr(Pattern); 9805 if (Out.isInvalid()) 9806 return true; 9807 9808 Result = getDerived().RebuildCXXFoldExpr( 9809 E->getLocStart(), Result.get(), 9810 E->getOperator(), E->getEllipsisLoc(), 9811 Out.get(), E->getLocEnd()); 9812 if (Result.isInvalid()) 9813 return true; 9814 } 9815 9816 // If we had no init and an empty pack, and we're not retaining an expansion, 9817 // then produce a fallback value or error. 9818 if (Result.isUnset()) 9819 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(), 9820 E->getOperator()); 9821 9822 return Result; 9823 } 9824 9825 template<typename Derived> 9826 ExprResult 9827 TreeTransform<Derived>::TransformCXXStdInitializerListExpr( 9828 CXXStdInitializerListExpr *E) { 9829 return getDerived().TransformExpr(E->getSubExpr()); 9830 } 9831 9832 template<typename Derived> 9833 ExprResult 9834 TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 9835 return SemaRef.MaybeBindToTemporary(E); 9836 } 9837 9838 template<typename Derived> 9839 ExprResult 9840 TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 9841 return E; 9842 } 9843 9844 template<typename Derived> 9845 ExprResult 9846 TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { 9847 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 9848 if (SubExpr.isInvalid()) 9849 return ExprError(); 9850 9851 if (!getDerived().AlwaysRebuild() && 9852 SubExpr.get() == E->getSubExpr()) 9853 return E; 9854 9855 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); 9856 } 9857 9858 template<typename Derived> 9859 ExprResult 9860 TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) { 9861 // Transform each of the elements. 9862 SmallVector<Expr *, 8> Elements; 9863 bool ArgChanged = false; 9864 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(), 9865 /*IsCall=*/false, Elements, &ArgChanged)) 9866 return ExprError(); 9867 9868 if (!getDerived().AlwaysRebuild() && !ArgChanged) 9869 return SemaRef.MaybeBindToTemporary(E); 9870 9871 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(), 9872 Elements.data(), 9873 Elements.size()); 9874 } 9875 9876 template<typename Derived> 9877 ExprResult 9878 TreeTransform<Derived>::TransformObjCDictionaryLiteral( 9879 ObjCDictionaryLiteral *E) { 9880 // Transform each of the elements. 9881 SmallVector<ObjCDictionaryElement, 8> Elements; 9882 bool ArgChanged = false; 9883 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 9884 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I); 9885 9886 if (OrigElement.isPackExpansion()) { 9887 // This key/value element is a pack expansion. 9888 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 9889 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded); 9890 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded); 9891 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 9892 9893 // Determine whether the set of unexpanded parameter packs can 9894 // and should be expanded. 9895 bool Expand = true; 9896 bool RetainExpansion = false; 9897 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; 9898 Optional<unsigned> NumExpansions = OrigNumExpansions; 9899 SourceRange PatternRange(OrigElement.Key->getLocStart(), 9900 OrigElement.Value->getLocEnd()); 9901 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, 9902 PatternRange, 9903 Unexpanded, 9904 Expand, RetainExpansion, 9905 NumExpansions)) 9906 return ExprError(); 9907 9908 if (!Expand) { 9909 // The transform has determined that we should perform a simple 9910 // transformation on the pack expansion, producing another pack 9911 // expansion. 9912 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 9913 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9914 if (Key.isInvalid()) 9915 return ExprError(); 9916 9917 if (Key.get() != OrigElement.Key) 9918 ArgChanged = true; 9919 9920 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 9921 if (Value.isInvalid()) 9922 return ExprError(); 9923 9924 if (Value.get() != OrigElement.Value) 9925 ArgChanged = true; 9926 9927 ObjCDictionaryElement Expansion = { 9928 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions 9929 }; 9930 Elements.push_back(Expansion); 9931 continue; 9932 } 9933 9934 // Record right away that the argument was changed. This needs 9935 // to happen even if the array expands to nothing. 9936 ArgChanged = true; 9937 9938 // The transform has determined that we should perform an elementwise 9939 // expansion of the pattern. Do so. 9940 for (unsigned I = 0; I != *NumExpansions; ++I) { 9941 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 9942 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9943 if (Key.isInvalid()) 9944 return ExprError(); 9945 9946 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 9947 if (Value.isInvalid()) 9948 return ExprError(); 9949 9950 ObjCDictionaryElement Element = { 9951 Key.get(), Value.get(), SourceLocation(), NumExpansions 9952 }; 9953 9954 // If any unexpanded parameter packs remain, we still have a 9955 // pack expansion. 9956 // FIXME: Can this really happen? 9957 if (Key.get()->containsUnexpandedParameterPack() || 9958 Value.get()->containsUnexpandedParameterPack()) 9959 Element.EllipsisLoc = OrigElement.EllipsisLoc; 9960 9961 Elements.push_back(Element); 9962 } 9963 9964 // FIXME: Retain a pack expansion if RetainExpansion is true. 9965 9966 // We've finished with this pack expansion. 9967 continue; 9968 } 9969 9970 // Transform and check key. 9971 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 9972 if (Key.isInvalid()) 9973 return ExprError(); 9974 9975 if (Key.get() != OrigElement.Key) 9976 ArgChanged = true; 9977 9978 // Transform and check value. 9979 ExprResult Value 9980 = getDerived().TransformExpr(OrigElement.Value); 9981 if (Value.isInvalid()) 9982 return ExprError(); 9983 9984 if (Value.get() != OrigElement.Value) 9985 ArgChanged = true; 9986 9987 ObjCDictionaryElement Element = { 9988 Key.get(), Value.get(), SourceLocation(), None 9989 }; 9990 Elements.push_back(Element); 9991 } 9992 9993 if (!getDerived().AlwaysRebuild() && !ArgChanged) 9994 return SemaRef.MaybeBindToTemporary(E); 9995 9996 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(), 9997 Elements.data(), 9998 Elements.size()); 9999 } 10000 10001 template<typename Derived> 10002 ExprResult 10003 TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 10004 TypeSourceInfo *EncodedTypeInfo 10005 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 10006 if (!EncodedTypeInfo) 10007 return ExprError(); 10008 10009 if (!getDerived().AlwaysRebuild() && 10010 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 10011 return E; 10012 10013 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 10014 EncodedTypeInfo, 10015 E->getRParenLoc()); 10016 } 10017 10018 template<typename Derived> 10019 ExprResult TreeTransform<Derived>:: 10020 TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 10021 // This is a kind of implicit conversion, and it needs to get dropped 10022 // and recomputed for the same general reasons that ImplicitCastExprs 10023 // do, as well a more specific one: this expression is only valid when 10024 // it appears *immediately* as an argument expression. 10025 return getDerived().TransformExpr(E->getSubExpr()); 10026 } 10027 10028 template<typename Derived> 10029 ExprResult TreeTransform<Derived>:: 10030 TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 10031 TypeSourceInfo *TSInfo 10032 = getDerived().TransformType(E->getTypeInfoAsWritten()); 10033 if (!TSInfo) 10034 return ExprError(); 10035 10036 ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); 10037 if (Result.isInvalid()) 10038 return ExprError(); 10039 10040 if (!getDerived().AlwaysRebuild() && 10041 TSInfo == E->getTypeInfoAsWritten() && 10042 Result.get() == E->getSubExpr()) 10043 return E; 10044 10045 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), 10046 E->getBridgeKeywordLoc(), TSInfo, 10047 Result.get()); 10048 } 10049 10050 template<typename Derived> 10051 ExprResult 10052 TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 10053 // Transform arguments. 10054 bool ArgChanged = false; 10055 SmallVector<Expr*, 8> Args; 10056 Args.reserve(E->getNumArgs()); 10057 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 10058 &ArgChanged)) 10059 return ExprError(); 10060 10061 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 10062 // Class message: transform the receiver type. 10063 TypeSourceInfo *ReceiverTypeInfo 10064 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 10065 if (!ReceiverTypeInfo) 10066 return ExprError(); 10067 10068 // If nothing changed, just retain the existing message send. 10069 if (!getDerived().AlwaysRebuild() && 10070 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 10071 return SemaRef.MaybeBindToTemporary(E); 10072 10073 // Build a new class message send. 10074 SmallVector<SourceLocation, 16> SelLocs; 10075 E->getSelectorLocs(SelLocs); 10076 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 10077 E->getSelector(), 10078 SelLocs, 10079 E->getMethodDecl(), 10080 E->getLeftLoc(), 10081 Args, 10082 E->getRightLoc()); 10083 } 10084 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass || 10085 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) { 10086 // Build a new class message send to 'super'. 10087 SmallVector<SourceLocation, 16> SelLocs; 10088 E->getSelectorLocs(SelLocs); 10089 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(), 10090 E->getSelector(), 10091 SelLocs, 10092 E->getMethodDecl(), 10093 E->getLeftLoc(), 10094 Args, 10095 E->getRightLoc()); 10096 } 10097 10098 // Instance message: transform the receiver 10099 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 10100 "Only class and instance messages may be instantiated"); 10101 ExprResult Receiver 10102 = getDerived().TransformExpr(E->getInstanceReceiver()); 10103 if (Receiver.isInvalid()) 10104 return ExprError(); 10105 10106 // If nothing changed, just retain the existing message send. 10107 if (!getDerived().AlwaysRebuild() && 10108 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 10109 return SemaRef.MaybeBindToTemporary(E); 10110 10111 // Build a new instance message send. 10112 SmallVector<SourceLocation, 16> SelLocs; 10113 E->getSelectorLocs(SelLocs); 10114 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 10115 E->getSelector(), 10116 SelLocs, 10117 E->getMethodDecl(), 10118 E->getLeftLoc(), 10119 Args, 10120 E->getRightLoc()); 10121 } 10122 10123 template<typename Derived> 10124 ExprResult 10125 TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 10126 return E; 10127 } 10128 10129 template<typename Derived> 10130 ExprResult 10131 TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 10132 return E; 10133 } 10134 10135 template<typename Derived> 10136 ExprResult 10137 TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 10138 // Transform the base expression. 10139 ExprResult Base = getDerived().TransformExpr(E->getBase()); 10140 if (Base.isInvalid()) 10141 return ExprError(); 10142 10143 // We don't need to transform the ivar; it will never change. 10144 10145 // If nothing changed, just retain the existing expression. 10146 if (!getDerived().AlwaysRebuild() && 10147 Base.get() == E->getBase()) 10148 return E; 10149 10150 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 10151 E->getLocation(), 10152 E->isArrow(), E->isFreeIvar()); 10153 } 10154 10155 template<typename Derived> 10156 ExprResult 10157 TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 10158 // 'super' and types never change. Property never changes. Just 10159 // retain the existing expression. 10160 if (!E->isObjectReceiver()) 10161 return E; 10162 10163 // Transform the base expression. 10164 ExprResult Base = getDerived().TransformExpr(E->getBase()); 10165 if (Base.isInvalid()) 10166 return ExprError(); 10167 10168 // We don't need to transform the property; it will never change. 10169 10170 // If nothing changed, just retain the existing expression. 10171 if (!getDerived().AlwaysRebuild() && 10172 Base.get() == E->getBase()) 10173 return E; 10174 10175 if (E->isExplicitProperty()) 10176 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 10177 E->getExplicitProperty(), 10178 E->getLocation()); 10179 10180 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 10181 SemaRef.Context.PseudoObjectTy, 10182 E->getImplicitPropertyGetter(), 10183 E->getImplicitPropertySetter(), 10184 E->getLocation()); 10185 } 10186 10187 template<typename Derived> 10188 ExprResult 10189 TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 10190 // Transform the base expression. 10191 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 10192 if (Base.isInvalid()) 10193 return ExprError(); 10194 10195 // Transform the key expression. 10196 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr()); 10197 if (Key.isInvalid()) 10198 return ExprError(); 10199 10200 // If nothing changed, just retain the existing expression. 10201 if (!getDerived().AlwaysRebuild() && 10202 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) 10203 return E; 10204 10205 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), 10206 Base.get(), Key.get(), 10207 E->getAtIndexMethodDecl(), 10208 E->setAtIndexMethodDecl()); 10209 } 10210 10211 template<typename Derived> 10212 ExprResult 10213 TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 10214 // Transform the base expression. 10215 ExprResult Base = getDerived().TransformExpr(E->getBase()); 10216 if (Base.isInvalid()) 10217 return ExprError(); 10218 10219 // If nothing changed, just retain the existing expression. 10220 if (!getDerived().AlwaysRebuild() && 10221 Base.get() == E->getBase()) 10222 return E; 10223 10224 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 10225 E->getOpLoc(), 10226 E->isArrow()); 10227 } 10228 10229 template<typename Derived> 10230 ExprResult 10231 TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 10232 bool ArgumentChanged = false; 10233 SmallVector<Expr*, 8> SubExprs; 10234 SubExprs.reserve(E->getNumSubExprs()); 10235 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 10236 SubExprs, &ArgumentChanged)) 10237 return ExprError(); 10238 10239 if (!getDerived().AlwaysRebuild() && 10240 !ArgumentChanged) 10241 return E; 10242 10243 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 10244 SubExprs, 10245 E->getRParenLoc()); 10246 } 10247 10248 template<typename Derived> 10249 ExprResult 10250 TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) { 10251 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr()); 10252 if (SrcExpr.isInvalid()) 10253 return ExprError(); 10254 10255 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 10256 if (!Type) 10257 return ExprError(); 10258 10259 if (!getDerived().AlwaysRebuild() && 10260 Type == E->getTypeSourceInfo() && 10261 SrcExpr.get() == E->getSrcExpr()) 10262 return E; 10263 10264 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(), 10265 SrcExpr.get(), Type, 10266 E->getRParenLoc()); 10267 } 10268 10269 template<typename Derived> 10270 ExprResult 10271 TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 10272 BlockDecl *oldBlock = E->getBlockDecl(); 10273 10274 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/nullptr); 10275 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 10276 10277 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 10278 blockScope->TheDecl->setBlockMissingReturnType( 10279 oldBlock->blockMissingReturnType()); 10280 10281 SmallVector<ParmVarDecl*, 4> params; 10282 SmallVector<QualType, 4> paramTypes; 10283 10284 // Parameter substitution. 10285 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 10286 oldBlock->param_begin(), 10287 oldBlock->param_size(), 10288 nullptr, paramTypes, ¶ms)) { 10289 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); 10290 return ExprError(); 10291 } 10292 10293 const FunctionProtoType *exprFunctionType = E->getFunctionType(); 10294 QualType exprResultType = 10295 getDerived().TransformType(exprFunctionType->getReturnType()); 10296 10297 QualType functionType = 10298 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, 10299 exprFunctionType->getExtProtoInfo()); 10300 blockScope->FunctionType = functionType; 10301 10302 // Set the parameters on the block decl. 10303 if (!params.empty()) 10304 blockScope->TheDecl->setParams(params); 10305 10306 if (!oldBlock->blockMissingReturnType()) { 10307 blockScope->HasImplicitReturnType = false; 10308 blockScope->ReturnType = exprResultType; 10309 } 10310 10311 // Transform the body 10312 StmtResult body = getDerived().TransformStmt(E->getBody()); 10313 if (body.isInvalid()) { 10314 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr); 10315 return ExprError(); 10316 } 10317 10318 #ifndef NDEBUG 10319 // In builds with assertions, make sure that we captured everything we 10320 // captured before. 10321 if (!SemaRef.getDiagnostics().hasErrorOccurred()) { 10322 for (const auto &I : oldBlock->captures()) { 10323 VarDecl *oldCapture = I.getVariable(); 10324 10325 // Ignore parameter packs. 10326 if (isa<ParmVarDecl>(oldCapture) && 10327 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 10328 continue; 10329 10330 VarDecl *newCapture = 10331 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 10332 oldCapture)); 10333 assert(blockScope->CaptureMap.count(newCapture)); 10334 } 10335 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()); 10336 } 10337 #endif 10338 10339 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 10340 /*Scope=*/nullptr); 10341 } 10342 10343 template<typename Derived> 10344 ExprResult 10345 TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { 10346 llvm_unreachable("Cannot transform asType expressions yet"); 10347 } 10348 10349 template<typename Derived> 10350 ExprResult 10351 TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { 10352 QualType RetTy = getDerived().TransformType(E->getType()); 10353 bool ArgumentChanged = false; 10354 SmallVector<Expr*, 8> SubExprs; 10355 SubExprs.reserve(E->getNumSubExprs()); 10356 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 10357 SubExprs, &ArgumentChanged)) 10358 return ExprError(); 10359 10360 if (!getDerived().AlwaysRebuild() && 10361 !ArgumentChanged) 10362 return E; 10363 10364 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, 10365 RetTy, E->getOp(), E->getRParenLoc()); 10366 } 10367 10368 //===----------------------------------------------------------------------===// 10369 // Type reconstruction 10370 //===----------------------------------------------------------------------===// 10371 10372 template<typename Derived> 10373 QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 10374 SourceLocation Star) { 10375 return SemaRef.BuildPointerType(PointeeType, Star, 10376 getDerived().getBaseEntity()); 10377 } 10378 10379 template<typename Derived> 10380 QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 10381 SourceLocation Star) { 10382 return SemaRef.BuildBlockPointerType(PointeeType, Star, 10383 getDerived().getBaseEntity()); 10384 } 10385 10386 template<typename Derived> 10387 QualType 10388 TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 10389 bool WrittenAsLValue, 10390 SourceLocation Sigil) { 10391 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 10392 Sigil, getDerived().getBaseEntity()); 10393 } 10394 10395 template<typename Derived> 10396 QualType 10397 TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 10398 QualType ClassType, 10399 SourceLocation Sigil) { 10400 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Sigil, 10401 getDerived().getBaseEntity()); 10402 } 10403 10404 template<typename Derived> 10405 QualType 10406 TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 10407 ArrayType::ArraySizeModifier SizeMod, 10408 const llvm::APInt *Size, 10409 Expr *SizeExpr, 10410 unsigned IndexTypeQuals, 10411 SourceRange BracketsRange) { 10412 if (SizeExpr || !Size) 10413 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 10414 IndexTypeQuals, BracketsRange, 10415 getDerived().getBaseEntity()); 10416 10417 QualType Types[] = { 10418 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 10419 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 10420 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 10421 }; 10422 const unsigned NumTypes = llvm::array_lengthof(Types); 10423 QualType SizeType; 10424 for (unsigned I = 0; I != NumTypes; ++I) 10425 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 10426 SizeType = Types[I]; 10427 break; 10428 } 10429 10430 // Note that we can return a VariableArrayType here in the case where 10431 // the element type was a dependent VariableArrayType. 10432 IntegerLiteral *ArraySize 10433 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType, 10434 /*FIXME*/BracketsRange.getBegin()); 10435 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize, 10436 IndexTypeQuals, BracketsRange, 10437 getDerived().getBaseEntity()); 10438 } 10439 10440 template<typename Derived> 10441 QualType 10442 TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 10443 ArrayType::ArraySizeModifier SizeMod, 10444 const llvm::APInt &Size, 10445 unsigned IndexTypeQuals, 10446 SourceRange BracketsRange) { 10447 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, nullptr, 10448 IndexTypeQuals, BracketsRange); 10449 } 10450 10451 template<typename Derived> 10452 QualType 10453 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 10454 ArrayType::ArraySizeModifier SizeMod, 10455 unsigned IndexTypeQuals, 10456 SourceRange BracketsRange) { 10457 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr, 10458 IndexTypeQuals, BracketsRange); 10459 } 10460 10461 template<typename Derived> 10462 QualType 10463 TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 10464 ArrayType::ArraySizeModifier SizeMod, 10465 Expr *SizeExpr, 10466 unsigned IndexTypeQuals, 10467 SourceRange BracketsRange) { 10468 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, 10469 SizeExpr, 10470 IndexTypeQuals, BracketsRange); 10471 } 10472 10473 template<typename Derived> 10474 QualType 10475 TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 10476 ArrayType::ArraySizeModifier SizeMod, 10477 Expr *SizeExpr, 10478 unsigned IndexTypeQuals, 10479 SourceRange BracketsRange) { 10480 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, 10481 SizeExpr, 10482 IndexTypeQuals, BracketsRange); 10483 } 10484 10485 template<typename Derived> 10486 QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 10487 unsigned NumElements, 10488 VectorType::VectorKind VecKind) { 10489 // FIXME: semantic checking! 10490 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 10491 } 10492 10493 template<typename Derived> 10494 QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 10495 unsigned NumElements, 10496 SourceLocation AttributeLoc) { 10497 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 10498 NumElements, true); 10499 IntegerLiteral *VectorSize 10500 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 10501 AttributeLoc); 10502 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 10503 } 10504 10505 template<typename Derived> 10506 QualType 10507 TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 10508 Expr *SizeExpr, 10509 SourceLocation AttributeLoc) { 10510 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 10511 } 10512 10513 template<typename Derived> 10514 QualType TreeTransform<Derived>::RebuildFunctionProtoType( 10515 QualType T, 10516 MutableArrayRef<QualType> ParamTypes, 10517 const FunctionProtoType::ExtProtoInfo &EPI) { 10518 return SemaRef.BuildFunctionType(T, ParamTypes, 10519 getDerived().getBaseLocation(), 10520 getDerived().getBaseEntity(), 10521 EPI); 10522 } 10523 10524 template<typename Derived> 10525 QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 10526 return SemaRef.Context.getFunctionNoProtoType(T); 10527 } 10528 10529 template<typename Derived> 10530 QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 10531 assert(D && "no decl found"); 10532 if (D->isInvalidDecl()) return QualType(); 10533 10534 // FIXME: Doesn't account for ObjCInterfaceDecl! 10535 TypeDecl *Ty; 10536 if (isa<UsingDecl>(D)) { 10537 UsingDecl *Using = cast<UsingDecl>(D); 10538 assert(Using->hasTypename() && 10539 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 10540 10541 // A valid resolved using typename decl points to exactly one type decl. 10542 assert(++Using->shadow_begin() == Using->shadow_end()); 10543 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 10544 10545 } else { 10546 assert(isa<UnresolvedUsingTypenameDecl>(D) && 10547 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 10548 Ty = cast<UnresolvedUsingTypenameDecl>(D); 10549 } 10550 10551 return SemaRef.Context.getTypeDeclType(Ty); 10552 } 10553 10554 template<typename Derived> 10555 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 10556 SourceLocation Loc) { 10557 return SemaRef.BuildTypeofExprType(E, Loc); 10558 } 10559 10560 template<typename Derived> 10561 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 10562 return SemaRef.Context.getTypeOfType(Underlying); 10563 } 10564 10565 template<typename Derived> 10566 QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 10567 SourceLocation Loc) { 10568 return SemaRef.BuildDecltypeType(E, Loc); 10569 } 10570 10571 template<typename Derived> 10572 QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, 10573 UnaryTransformType::UTTKind UKind, 10574 SourceLocation Loc) { 10575 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); 10576 } 10577 10578 template<typename Derived> 10579 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 10580 TemplateName Template, 10581 SourceLocation TemplateNameLoc, 10582 TemplateArgumentListInfo &TemplateArgs) { 10583 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 10584 } 10585 10586 template<typename Derived> 10587 QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType, 10588 SourceLocation KWLoc) { 10589 return SemaRef.BuildAtomicType(ValueType, KWLoc); 10590 } 10591 10592 template<typename Derived> 10593 TemplateName 10594 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 10595 bool TemplateKW, 10596 TemplateDecl *Template) { 10597 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 10598 Template); 10599 } 10600 10601 template<typename Derived> 10602 TemplateName 10603 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 10604 const IdentifierInfo &Name, 10605 SourceLocation NameLoc, 10606 QualType ObjectType, 10607 NamedDecl *FirstQualifierInScope) { 10608 UnqualifiedId TemplateName; 10609 TemplateName.setIdentifier(&Name, NameLoc); 10610 Sema::TemplateTy Template; 10611 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 10612 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, 10613 SS, TemplateKWLoc, TemplateName, 10614 ParsedType::make(ObjectType), 10615 /*EnteringContext=*/false, 10616 Template); 10617 return Template.get(); 10618 } 10619 10620 template<typename Derived> 10621 TemplateName 10622 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 10623 OverloadedOperatorKind Operator, 10624 SourceLocation NameLoc, 10625 QualType ObjectType) { 10626 UnqualifiedId Name; 10627 // FIXME: Bogus location information. 10628 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 10629 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 10630 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 10631 Sema::TemplateTy Template; 10632 getSema().ActOnDependentTemplateName(/*Scope=*/nullptr, 10633 SS, TemplateKWLoc, Name, 10634 ParsedType::make(ObjectType), 10635 /*EnteringContext=*/false, 10636 Template); 10637 return Template.get(); 10638 } 10639 10640 template<typename Derived> 10641 ExprResult 10642 TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 10643 SourceLocation OpLoc, 10644 Expr *OrigCallee, 10645 Expr *First, 10646 Expr *Second) { 10647 Expr *Callee = OrigCallee->IgnoreParenCasts(); 10648 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 10649 10650 if (First->getObjectKind() == OK_ObjCProperty) { 10651 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 10652 if (BinaryOperator::isAssignmentOp(Opc)) 10653 return SemaRef.checkPseudoObjectAssignment(/*Scope=*/nullptr, OpLoc, Opc, 10654 First, Second); 10655 ExprResult Result = SemaRef.CheckPlaceholderExpr(First); 10656 if (Result.isInvalid()) 10657 return ExprError(); 10658 First = Result.get(); 10659 } 10660 10661 if (Second && Second->getObjectKind() == OK_ObjCProperty) { 10662 ExprResult Result = SemaRef.CheckPlaceholderExpr(Second); 10663 if (Result.isInvalid()) 10664 return ExprError(); 10665 Second = Result.get(); 10666 } 10667 10668 // Determine whether this should be a builtin operation. 10669 if (Op == OO_Subscript) { 10670 if (!First->getType()->isOverloadableType() && 10671 !Second->getType()->isOverloadableType()) 10672 return getSema().CreateBuiltinArraySubscriptExpr(First, 10673 Callee->getLocStart(), 10674 Second, OpLoc); 10675 } else if (Op == OO_Arrow) { 10676 // -> is never a builtin operation. 10677 return SemaRef.BuildOverloadedArrowExpr(nullptr, First, OpLoc); 10678 } else if (Second == nullptr || isPostIncDec) { 10679 if (!First->getType()->isOverloadableType()) { 10680 // The argument is not of overloadable type, so try to create a 10681 // built-in unary operation. 10682 UnaryOperatorKind Opc 10683 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 10684 10685 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 10686 } 10687 } else { 10688 if (!First->getType()->isOverloadableType() && 10689 !Second->getType()->isOverloadableType()) { 10690 // Neither of the arguments is an overloadable type, so try to 10691 // create a built-in binary operation. 10692 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 10693 ExprResult Result 10694 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 10695 if (Result.isInvalid()) 10696 return ExprError(); 10697 10698 return Result; 10699 } 10700 } 10701 10702 // Compute the transformed set of functions (and function templates) to be 10703 // used during overload resolution. 10704 UnresolvedSet<16> Functions; 10705 10706 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 10707 assert(ULE->requiresADL()); 10708 Functions.append(ULE->decls_begin(), ULE->decls_end()); 10709 } else { 10710 // If we've resolved this to a particular non-member function, just call 10711 // that function. If we resolved it to a member function, 10712 // CreateOverloaded* will find that function for us. 10713 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl(); 10714 if (!isa<CXXMethodDecl>(ND)) 10715 Functions.addDecl(ND); 10716 } 10717 10718 // Add any functions found via argument-dependent lookup. 10719 Expr *Args[2] = { First, Second }; 10720 unsigned NumArgs = 1 + (Second != nullptr); 10721 10722 // Create the overloaded operator invocation for unary operators. 10723 if (NumArgs == 1 || isPostIncDec) { 10724 UnaryOperatorKind Opc 10725 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 10726 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 10727 } 10728 10729 if (Op == OO_Subscript) { 10730 SourceLocation LBrace; 10731 SourceLocation RBrace; 10732 10733 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { 10734 DeclarationNameLoc NameLoc = DRE->getNameInfo().getInfo(); 10735 LBrace = SourceLocation::getFromRawEncoding( 10736 NameLoc.CXXOperatorName.BeginOpNameLoc); 10737 RBrace = SourceLocation::getFromRawEncoding( 10738 NameLoc.CXXOperatorName.EndOpNameLoc); 10739 } else { 10740 LBrace = Callee->getLocStart(); 10741 RBrace = OpLoc; 10742 } 10743 10744 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, 10745 First, Second); 10746 } 10747 10748 // Create the overloaded operator invocation for binary operators. 10749 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 10750 ExprResult Result 10751 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 10752 if (Result.isInvalid()) 10753 return ExprError(); 10754 10755 return Result; 10756 } 10757 10758 template<typename Derived> 10759 ExprResult 10760 TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 10761 SourceLocation OperatorLoc, 10762 bool isArrow, 10763 CXXScopeSpec &SS, 10764 TypeSourceInfo *ScopeType, 10765 SourceLocation CCLoc, 10766 SourceLocation TildeLoc, 10767 PseudoDestructorTypeStorage Destroyed) { 10768 QualType BaseType = Base->getType(); 10769 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 10770 (!isArrow && !BaseType->getAs<RecordType>()) || 10771 (isArrow && BaseType->getAs<PointerType>() && 10772 !BaseType->getAs<PointerType>()->getPointeeType() 10773 ->template getAs<RecordType>())){ 10774 // This pseudo-destructor expression is still a pseudo-destructor. 10775 return SemaRef.BuildPseudoDestructorExpr( 10776 Base, OperatorLoc, isArrow ? tok::arrow : tok::period, SS, ScopeType, 10777 CCLoc, TildeLoc, Destroyed); 10778 } 10779 10780 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 10781 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 10782 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 10783 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 10784 NameInfo.setNamedTypeInfo(DestroyedType); 10785 10786 // The scope type is now known to be a valid nested name specifier 10787 // component. Tack it on to the end of the nested name specifier. 10788 if (ScopeType) { 10789 if (!ScopeType->getType()->getAs<TagType>()) { 10790 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(), 10791 diag::err_expected_class_or_namespace) 10792 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus; 10793 return ExprError(); 10794 } 10795 SS.Extend(SemaRef.Context, SourceLocation(), ScopeType->getTypeLoc(), 10796 CCLoc); 10797 } 10798 10799 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 10800 return getSema().BuildMemberReferenceExpr(Base, BaseType, 10801 OperatorLoc, isArrow, 10802 SS, TemplateKWLoc, 10803 /*FIXME: FirstQualifier*/ nullptr, 10804 NameInfo, 10805 /*TemplateArgs*/ nullptr); 10806 } 10807 10808 template<typename Derived> 10809 StmtResult 10810 TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) { 10811 SourceLocation Loc = S->getLocStart(); 10812 CapturedDecl *CD = S->getCapturedDecl(); 10813 unsigned NumParams = CD->getNumParams(); 10814 unsigned ContextParamPos = CD->getContextParamPosition(); 10815 SmallVector<Sema::CapturedParamNameType, 4> Params; 10816 for (unsigned I = 0; I < NumParams; ++I) { 10817 if (I != ContextParamPos) { 10818 Params.push_back( 10819 std::make_pair( 10820 CD->getParam(I)->getName(), 10821 getDerived().TransformType(CD->getParam(I)->getType()))); 10822 } else { 10823 Params.push_back(std::make_pair(StringRef(), QualType())); 10824 } 10825 } 10826 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr, 10827 S->getCapturedRegionKind(), Params); 10828 StmtResult Body; 10829 { 10830 Sema::CompoundScopeRAII CompoundScope(getSema()); 10831 Body = getDerived().TransformStmt(S->getCapturedStmt()); 10832 } 10833 10834 if (Body.isInvalid()) { 10835 getSema().ActOnCapturedRegionError(); 10836 return StmtError(); 10837 } 10838 10839 return getSema().ActOnCapturedRegionEnd(Body.get()); 10840 } 10841 10842 } // end namespace clang 10843 10844 #endif 10845