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