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