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