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