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