TreeTransform.h revision 303b96f255d61ae3dff913d777d3f40332786257
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 ArrayRef<UnexpandedParameterPack> Unexpanded, 251 bool &ShouldExpand, 252 bool &RetainExpansion, 253 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 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 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 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 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 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(E); 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 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); 2674 Optional<unsigned> NumExpansions = OrigNumExpansions; 2675 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 2676 Pattern->getSourceRange(), 2677 Unexpanded, 2678 Expand, RetainExpansion, 2679 NumExpansions)) 2680 return true; 2681 2682 if (!Expand) { 2683 // The transform has determined that we should perform a simple 2684 // transformation on the pack expansion, producing another pack 2685 // expansion. 2686 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2687 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 2688 if (OutPattern.isInvalid()) 2689 return true; 2690 2691 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 2692 Expansion->getEllipsisLoc(), 2693 NumExpansions); 2694 if (Out.isInvalid()) 2695 return true; 2696 2697 if (ArgChanged) 2698 *ArgChanged = true; 2699 Outputs.push_back(Out.get()); 2700 continue; 2701 } 2702 2703 // Record right away that the argument was changed. This needs 2704 // to happen even if the array expands to nothing. 2705 if (ArgChanged) *ArgChanged = true; 2706 2707 // The transform has determined that we should perform an elementwise 2708 // expansion of the pattern. Do so. 2709 for (unsigned I = 0; I != *NumExpansions; ++I) { 2710 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2711 ExprResult Out = getDerived().TransformExpr(Pattern); 2712 if (Out.isInvalid()) 2713 return true; 2714 2715 if (Out.get()->containsUnexpandedParameterPack()) { 2716 Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), 2717 OrigNumExpansions); 2718 if (Out.isInvalid()) 2719 return true; 2720 } 2721 2722 Outputs.push_back(Out.get()); 2723 } 2724 2725 continue; 2726 } 2727 2728 ExprResult Result = 2729 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false) 2730 : getDerived().TransformExpr(Inputs[I]); 2731 if (Result.isInvalid()) 2732 return true; 2733 2734 if (Result.get() != Inputs[I] && ArgChanged) 2735 *ArgChanged = true; 2736 2737 Outputs.push_back(Result.get()); 2738 } 2739 2740 return false; 2741} 2742 2743template<typename Derived> 2744NestedNameSpecifierLoc 2745TreeTransform<Derived>::TransformNestedNameSpecifierLoc( 2746 NestedNameSpecifierLoc NNS, 2747 QualType ObjectType, 2748 NamedDecl *FirstQualifierInScope) { 2749 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 2750 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; 2751 Qualifier = Qualifier.getPrefix()) 2752 Qualifiers.push_back(Qualifier); 2753 2754 CXXScopeSpec SS; 2755 while (!Qualifiers.empty()) { 2756 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 2757 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier(); 2758 2759 switch (QNNS->getKind()) { 2760 case NestedNameSpecifier::Identifier: 2761 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0, 2762 *QNNS->getAsIdentifier(), 2763 Q.getLocalBeginLoc(), 2764 Q.getLocalEndLoc(), 2765 ObjectType, false, SS, 2766 FirstQualifierInScope, false)) 2767 return NestedNameSpecifierLoc(); 2768 2769 break; 2770 2771 case NestedNameSpecifier::Namespace: { 2772 NamespaceDecl *NS 2773 = cast_or_null<NamespaceDecl>( 2774 getDerived().TransformDecl( 2775 Q.getLocalBeginLoc(), 2776 QNNS->getAsNamespace())); 2777 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); 2778 break; 2779 } 2780 2781 case NestedNameSpecifier::NamespaceAlias: { 2782 NamespaceAliasDecl *Alias 2783 = cast_or_null<NamespaceAliasDecl>( 2784 getDerived().TransformDecl(Q.getLocalBeginLoc(), 2785 QNNS->getAsNamespaceAlias())); 2786 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(), 2787 Q.getLocalEndLoc()); 2788 break; 2789 } 2790 2791 case NestedNameSpecifier::Global: 2792 // There is no meaningful transformation that one could perform on the 2793 // global scope. 2794 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); 2795 break; 2796 2797 case NestedNameSpecifier::TypeSpecWithTemplate: 2798 case NestedNameSpecifier::TypeSpec: { 2799 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType, 2800 FirstQualifierInScope, SS); 2801 2802 if (!TL) 2803 return NestedNameSpecifierLoc(); 2804 2805 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || 2806 (SemaRef.getLangOpts().CPlusPlus11 && 2807 TL.getType()->isEnumeralType())) { 2808 assert(!TL.getType().hasLocalQualifiers() && 2809 "Can't get cv-qualifiers here"); 2810 if (TL.getType()->isEnumeralType()) 2811 SemaRef.Diag(TL.getBeginLoc(), 2812 diag::warn_cxx98_compat_enum_nested_name_spec); 2813 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL, 2814 Q.getLocalEndLoc()); 2815 break; 2816 } 2817 // If the nested-name-specifier is an invalid type def, don't emit an 2818 // error because a previous error should have already been emitted. 2819 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>(); 2820 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { 2821 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) 2822 << TL.getType() << SS.getRange(); 2823 } 2824 return NestedNameSpecifierLoc(); 2825 } 2826 } 2827 2828 // The qualifier-in-scope and object type only apply to the leftmost entity. 2829 FirstQualifierInScope = 0; 2830 ObjectType = QualType(); 2831 } 2832 2833 // Don't rebuild the nested-name-specifier if we don't have to. 2834 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && 2835 !getDerived().AlwaysRebuild()) 2836 return NNS; 2837 2838 // If we can re-use the source-location data from the original 2839 // nested-name-specifier, do so. 2840 if (SS.location_size() == NNS.getDataLength() && 2841 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) 2842 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); 2843 2844 // Allocate new nested-name-specifier location information. 2845 return SS.getWithLocInContext(SemaRef.Context); 2846} 2847 2848template<typename Derived> 2849DeclarationNameInfo 2850TreeTransform<Derived> 2851::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 2852 DeclarationName Name = NameInfo.getName(); 2853 if (!Name) 2854 return DeclarationNameInfo(); 2855 2856 switch (Name.getNameKind()) { 2857 case DeclarationName::Identifier: 2858 case DeclarationName::ObjCZeroArgSelector: 2859 case DeclarationName::ObjCOneArgSelector: 2860 case DeclarationName::ObjCMultiArgSelector: 2861 case DeclarationName::CXXOperatorName: 2862 case DeclarationName::CXXLiteralOperatorName: 2863 case DeclarationName::CXXUsingDirective: 2864 return NameInfo; 2865 2866 case DeclarationName::CXXConstructorName: 2867 case DeclarationName::CXXDestructorName: 2868 case DeclarationName::CXXConversionFunctionName: { 2869 TypeSourceInfo *NewTInfo; 2870 CanQualType NewCanTy; 2871 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 2872 NewTInfo = getDerived().TransformType(OldTInfo); 2873 if (!NewTInfo) 2874 return DeclarationNameInfo(); 2875 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 2876 } 2877 else { 2878 NewTInfo = 0; 2879 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 2880 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 2881 if (NewT.isNull()) 2882 return DeclarationNameInfo(); 2883 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 2884 } 2885 2886 DeclarationName NewName 2887 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 2888 NewCanTy); 2889 DeclarationNameInfo NewNameInfo(NameInfo); 2890 NewNameInfo.setName(NewName); 2891 NewNameInfo.setNamedTypeInfo(NewTInfo); 2892 return NewNameInfo; 2893 } 2894 } 2895 2896 llvm_unreachable("Unknown name kind."); 2897} 2898 2899template<typename Derived> 2900TemplateName 2901TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, 2902 TemplateName Name, 2903 SourceLocation NameLoc, 2904 QualType ObjectType, 2905 NamedDecl *FirstQualifierInScope) { 2906 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 2907 TemplateDecl *Template = QTN->getTemplateDecl(); 2908 assert(Template && "qualified template name must refer to a template"); 2909 2910 TemplateDecl *TransTemplate 2911 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 2912 Template)); 2913 if (!TransTemplate) 2914 return TemplateName(); 2915 2916 if (!getDerived().AlwaysRebuild() && 2917 SS.getScopeRep() == QTN->getQualifier() && 2918 TransTemplate == Template) 2919 return Name; 2920 2921 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(), 2922 TransTemplate); 2923 } 2924 2925 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 2926 if (SS.getScopeRep()) { 2927 // These apply to the scope specifier, not the template. 2928 ObjectType = QualType(); 2929 FirstQualifierInScope = 0; 2930 } 2931 2932 if (!getDerived().AlwaysRebuild() && 2933 SS.getScopeRep() == DTN->getQualifier() && 2934 ObjectType.isNull()) 2935 return Name; 2936 2937 if (DTN->isIdentifier()) { 2938 return getDerived().RebuildTemplateName(SS, 2939 *DTN->getIdentifier(), 2940 NameLoc, 2941 ObjectType, 2942 FirstQualifierInScope); 2943 } 2944 2945 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc, 2946 ObjectType); 2947 } 2948 2949 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 2950 TemplateDecl *TransTemplate 2951 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 2952 Template)); 2953 if (!TransTemplate) 2954 return TemplateName(); 2955 2956 if (!getDerived().AlwaysRebuild() && 2957 TransTemplate == Template) 2958 return Name; 2959 2960 return TemplateName(TransTemplate); 2961 } 2962 2963 if (SubstTemplateTemplateParmPackStorage *SubstPack 2964 = Name.getAsSubstTemplateTemplateParmPack()) { 2965 TemplateTemplateParmDecl *TransParam 2966 = cast_or_null<TemplateTemplateParmDecl>( 2967 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); 2968 if (!TransParam) 2969 return TemplateName(); 2970 2971 if (!getDerived().AlwaysRebuild() && 2972 TransParam == SubstPack->getParameterPack()) 2973 return Name; 2974 2975 return getDerived().RebuildTemplateName(TransParam, 2976 SubstPack->getArgumentPack()); 2977 } 2978 2979 // These should be getting filtered out before they reach the AST. 2980 llvm_unreachable("overloaded function decl survived to here"); 2981} 2982 2983template<typename Derived> 2984void TreeTransform<Derived>::InventTemplateArgumentLoc( 2985 const TemplateArgument &Arg, 2986 TemplateArgumentLoc &Output) { 2987 SourceLocation Loc = getDerived().getBaseLocation(); 2988 switch (Arg.getKind()) { 2989 case TemplateArgument::Null: 2990 llvm_unreachable("null template argument in TreeTransform"); 2991 break; 2992 2993 case TemplateArgument::Type: 2994 Output = TemplateArgumentLoc(Arg, 2995 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 2996 2997 break; 2998 2999 case TemplateArgument::Template: 3000 case TemplateArgument::TemplateExpansion: { 3001 NestedNameSpecifierLocBuilder Builder; 3002 TemplateName Template = Arg.getAsTemplate(); 3003 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 3004 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc); 3005 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3006 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc); 3007 3008 if (Arg.getKind() == TemplateArgument::Template) 3009 Output = TemplateArgumentLoc(Arg, 3010 Builder.getWithLocInContext(SemaRef.Context), 3011 Loc); 3012 else 3013 Output = TemplateArgumentLoc(Arg, 3014 Builder.getWithLocInContext(SemaRef.Context), 3015 Loc, Loc); 3016 3017 break; 3018 } 3019 3020 case TemplateArgument::Expression: 3021 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 3022 break; 3023 3024 case TemplateArgument::Declaration: 3025 case TemplateArgument::Integral: 3026 case TemplateArgument::Pack: 3027 case TemplateArgument::NullPtr: 3028 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 3029 break; 3030 } 3031} 3032 3033template<typename Derived> 3034bool TreeTransform<Derived>::TransformTemplateArgument( 3035 const TemplateArgumentLoc &Input, 3036 TemplateArgumentLoc &Output) { 3037 const TemplateArgument &Arg = Input.getArgument(); 3038 switch (Arg.getKind()) { 3039 case TemplateArgument::Null: 3040 case TemplateArgument::Integral: 3041 case TemplateArgument::Pack: 3042 case TemplateArgument::Declaration: 3043 case TemplateArgument::NullPtr: 3044 llvm_unreachable("Unexpected TemplateArgument"); 3045 3046 case TemplateArgument::Type: { 3047 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 3048 if (DI == NULL) 3049 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 3050 3051 DI = getDerived().TransformType(DI); 3052 if (!DI) return true; 3053 3054 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 3055 return false; 3056 } 3057 3058 case TemplateArgument::Template: { 3059 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc(); 3060 if (QualifierLoc) { 3061 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); 3062 if (!QualifierLoc) 3063 return true; 3064 } 3065 3066 CXXScopeSpec SS; 3067 SS.Adopt(QualifierLoc); 3068 TemplateName Template 3069 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(), 3070 Input.getTemplateNameLoc()); 3071 if (Template.isNull()) 3072 return true; 3073 3074 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc, 3075 Input.getTemplateNameLoc()); 3076 return false; 3077 } 3078 3079 case TemplateArgument::TemplateExpansion: 3080 llvm_unreachable("Caller should expand pack expansions"); 3081 3082 case TemplateArgument::Expression: { 3083 // Template argument expressions are constant expressions. 3084 EnterExpressionEvaluationContext Unevaluated(getSema(), 3085 Sema::ConstantEvaluated); 3086 3087 Expr *InputExpr = Input.getSourceExpression(); 3088 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 3089 3090 ExprResult E = getDerived().TransformExpr(InputExpr); 3091 E = SemaRef.ActOnConstantExpression(E); 3092 if (E.isInvalid()) return true; 3093 Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); 3094 return false; 3095 } 3096 } 3097 3098 // Work around bogus GCC warning 3099 return true; 3100} 3101 3102/// \brief Iterator adaptor that invents template argument location information 3103/// for each of the template arguments in its underlying iterator. 3104template<typename Derived, typename InputIterator> 3105class TemplateArgumentLocInventIterator { 3106 TreeTransform<Derived> &Self; 3107 InputIterator Iter; 3108 3109public: 3110 typedef TemplateArgumentLoc value_type; 3111 typedef TemplateArgumentLoc reference; 3112 typedef typename std::iterator_traits<InputIterator>::difference_type 3113 difference_type; 3114 typedef std::input_iterator_tag iterator_category; 3115 3116 class pointer { 3117 TemplateArgumentLoc Arg; 3118 3119 public: 3120 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3121 3122 const TemplateArgumentLoc *operator->() const { return &Arg; } 3123 }; 3124 3125 TemplateArgumentLocInventIterator() { } 3126 3127 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, 3128 InputIterator Iter) 3129 : Self(Self), Iter(Iter) { } 3130 3131 TemplateArgumentLocInventIterator &operator++() { 3132 ++Iter; 3133 return *this; 3134 } 3135 3136 TemplateArgumentLocInventIterator operator++(int) { 3137 TemplateArgumentLocInventIterator Old(*this); 3138 ++(*this); 3139 return Old; 3140 } 3141 3142 reference operator*() const { 3143 TemplateArgumentLoc Result; 3144 Self.InventTemplateArgumentLoc(*Iter, Result); 3145 return Result; 3146 } 3147 3148 pointer operator->() const { return pointer(**this); } 3149 3150 friend bool operator==(const TemplateArgumentLocInventIterator &X, 3151 const TemplateArgumentLocInventIterator &Y) { 3152 return X.Iter == Y.Iter; 3153 } 3154 3155 friend bool operator!=(const TemplateArgumentLocInventIterator &X, 3156 const TemplateArgumentLocInventIterator &Y) { 3157 return X.Iter != Y.Iter; 3158 } 3159}; 3160 3161template<typename Derived> 3162template<typename InputIterator> 3163bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, 3164 InputIterator Last, 3165 TemplateArgumentListInfo &Outputs) { 3166 for (; First != Last; ++First) { 3167 TemplateArgumentLoc Out; 3168 TemplateArgumentLoc In = *First; 3169 3170 if (In.getArgument().getKind() == TemplateArgument::Pack) { 3171 // Unpack argument packs, which we translate them into separate 3172 // arguments. 3173 // FIXME: We could do much better if we could guarantee that the 3174 // TemplateArgumentLocInfo for the pack expansion would be usable for 3175 // all of the template arguments in the argument pack. 3176 typedef TemplateArgumentLocInventIterator<Derived, 3177 TemplateArgument::pack_iterator> 3178 PackLocIterator; 3179 if (TransformTemplateArguments(PackLocIterator(*this, 3180 In.getArgument().pack_begin()), 3181 PackLocIterator(*this, 3182 In.getArgument().pack_end()), 3183 Outputs)) 3184 return true; 3185 3186 continue; 3187 } 3188 3189 if (In.getArgument().isPackExpansion()) { 3190 // We have a pack expansion, for which we will be substituting into 3191 // the pattern. 3192 SourceLocation Ellipsis; 3193 Optional<unsigned> OrigNumExpansions; 3194 TemplateArgumentLoc Pattern 3195 = In.getPackExpansionPattern(Ellipsis, OrigNumExpansions, 3196 getSema().Context); 3197 3198 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3199 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3200 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 3201 3202 // Determine whether the set of unexpanded parameter packs can and should 3203 // be expanded. 3204 bool Expand = true; 3205 bool RetainExpansion = false; 3206 Optional<unsigned> NumExpansions = OrigNumExpansions; 3207 if (getDerived().TryExpandParameterPacks(Ellipsis, 3208 Pattern.getSourceRange(), 3209 Unexpanded, 3210 Expand, 3211 RetainExpansion, 3212 NumExpansions)) 3213 return true; 3214 3215 if (!Expand) { 3216 // The transform has determined that we should perform a simple 3217 // transformation on the pack expansion, producing another pack 3218 // expansion. 3219 TemplateArgumentLoc OutPattern; 3220 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3221 if (getDerived().TransformTemplateArgument(Pattern, OutPattern)) 3222 return true; 3223 3224 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis, 3225 NumExpansions); 3226 if (Out.getArgument().isNull()) 3227 return true; 3228 3229 Outputs.addArgument(Out); 3230 continue; 3231 } 3232 3233 // The transform has determined that we should perform an elementwise 3234 // expansion of the pattern. Do so. 3235 for (unsigned I = 0; I != *NumExpansions; ++I) { 3236 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3237 3238 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3239 return true; 3240 3241 if (Out.getArgument().containsUnexpandedParameterPack()) { 3242 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3243 OrigNumExpansions); 3244 if (Out.getArgument().isNull()) 3245 return true; 3246 } 3247 3248 Outputs.addArgument(Out); 3249 } 3250 3251 // If we're supposed to retain a pack expansion, do so by temporarily 3252 // forgetting the partially-substituted parameter pack. 3253 if (RetainExpansion) { 3254 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3255 3256 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3257 return true; 3258 3259 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3260 OrigNumExpansions); 3261 if (Out.getArgument().isNull()) 3262 return true; 3263 3264 Outputs.addArgument(Out); 3265 } 3266 3267 continue; 3268 } 3269 3270 // The simple case: 3271 if (getDerived().TransformTemplateArgument(In, Out)) 3272 return true; 3273 3274 Outputs.addArgument(Out); 3275 } 3276 3277 return false; 3278 3279} 3280 3281//===----------------------------------------------------------------------===// 3282// Type transformation 3283//===----------------------------------------------------------------------===// 3284 3285template<typename Derived> 3286QualType TreeTransform<Derived>::TransformType(QualType T) { 3287 if (getDerived().AlreadyTransformed(T)) 3288 return T; 3289 3290 // Temporary workaround. All of these transformations should 3291 // eventually turn into transformations on TypeLocs. 3292 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T, 3293 getDerived().getBaseLocation()); 3294 3295 TypeSourceInfo *NewDI = getDerived().TransformType(DI); 3296 3297 if (!NewDI) 3298 return QualType(); 3299 3300 return NewDI->getType(); 3301} 3302 3303template<typename Derived> 3304TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { 3305 // Refine the base location to the type's location. 3306 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(), 3307 getDerived().getBaseEntity()); 3308 if (getDerived().AlreadyTransformed(DI->getType())) 3309 return DI; 3310 3311 TypeLocBuilder TLB; 3312 3313 TypeLoc TL = DI->getTypeLoc(); 3314 TLB.reserve(TL.getFullDataSize()); 3315 3316 QualType Result = getDerived().TransformType(TLB, TL); 3317 if (Result.isNull()) 3318 return 0; 3319 3320 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3321} 3322 3323template<typename Derived> 3324QualType 3325TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 3326 switch (T.getTypeLocClass()) { 3327#define ABSTRACT_TYPELOC(CLASS, PARENT) 3328#define TYPELOC(CLASS, PARENT) \ 3329 case TypeLoc::CLASS: \ 3330 return getDerived().Transform##CLASS##Type(TLB, \ 3331 T.castAs<CLASS##TypeLoc>()); 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 const AutoType *AutoTy; 3369 if (const SubstTemplateTypeParmType *SubstTypeParam 3370 = dyn_cast<SubstTemplateTypeParmType>(Result)) { 3371 QualType Replacement = SubstTypeParam->getReplacementType(); 3372 Qualifiers Qs = Replacement.getQualifiers(); 3373 Qs.removeObjCLifetime(); 3374 Replacement 3375 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), 3376 Qs); 3377 Result = SemaRef.Context.getSubstTemplateTypeParmType( 3378 SubstTypeParam->getReplacedParameter(), 3379 Replacement); 3380 TLB.TypeWasModifiedSafely(Result); 3381 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) { 3382 // 'auto' types behave the same way as template parameters. 3383 QualType Deduced = AutoTy->getDeducedType(); 3384 Qualifiers Qs = Deduced.getQualifiers(); 3385 Qs.removeObjCLifetime(); 3386 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), 3387 Qs); 3388 Result = SemaRef.Context.getAutoType(Deduced); 3389 TLB.TypeWasModifiedSafely(Result); 3390 } else { 3391 // Otherwise, complain about the addition of a qualifier to an 3392 // already-qualified type. 3393 SourceRange R = TLB.getTemporaryTypeLoc(Result).getSourceRange(); 3394 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant) 3395 << Result << R; 3396 3397 Quals.removeObjCLifetime(); 3398 } 3399 } 3400 } 3401 if (!Quals.empty()) { 3402 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals); 3403 TLB.push<QualifiedTypeLoc>(Result); 3404 // No location information to preserve. 3405 } 3406 3407 return Result; 3408} 3409 3410template<typename Derived> 3411TypeLoc 3412TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL, 3413 QualType ObjectType, 3414 NamedDecl *UnqualLookup, 3415 CXXScopeSpec &SS) { 3416 QualType T = TL.getType(); 3417 if (getDerived().AlreadyTransformed(T)) 3418 return TL; 3419 3420 TypeLocBuilder TLB; 3421 QualType Result; 3422 3423 if (isa<TemplateSpecializationType>(T)) { 3424 TemplateSpecializationTypeLoc SpecTL = 3425 TL.castAs<TemplateSpecializationTypeLoc>(); 3426 3427 TemplateName Template = 3428 getDerived().TransformTemplateName(SS, 3429 SpecTL.getTypePtr()->getTemplateName(), 3430 SpecTL.getTemplateNameLoc(), 3431 ObjectType, UnqualLookup); 3432 if (Template.isNull()) 3433 return TypeLoc(); 3434 3435 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3436 Template); 3437 } else if (isa<DependentTemplateSpecializationType>(T)) { 3438 DependentTemplateSpecializationTypeLoc SpecTL = 3439 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3440 3441 TemplateName Template 3442 = getDerived().RebuildTemplateName(SS, 3443 *SpecTL.getTypePtr()->getIdentifier(), 3444 SpecTL.getTemplateNameLoc(), 3445 ObjectType, UnqualLookup); 3446 if (Template.isNull()) 3447 return TypeLoc(); 3448 3449 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3450 SpecTL, 3451 Template, 3452 SS); 3453 } else { 3454 // Nothing special needs to be done for these. 3455 Result = getDerived().TransformType(TLB, TL); 3456 } 3457 3458 if (Result.isNull()) 3459 return TypeLoc(); 3460 3461 return TLB.getTypeSourceInfo(SemaRef.Context, Result)->getTypeLoc(); 3462} 3463 3464template<typename Derived> 3465TypeSourceInfo * 3466TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 3467 QualType ObjectType, 3468 NamedDecl *UnqualLookup, 3469 CXXScopeSpec &SS) { 3470 // FIXME: Painfully copy-paste from the above! 3471 3472 QualType T = TSInfo->getType(); 3473 if (getDerived().AlreadyTransformed(T)) 3474 return TSInfo; 3475 3476 TypeLocBuilder TLB; 3477 QualType Result; 3478 3479 TypeLoc TL = TSInfo->getTypeLoc(); 3480 if (isa<TemplateSpecializationType>(T)) { 3481 TemplateSpecializationTypeLoc SpecTL = 3482 TL.castAs<TemplateSpecializationTypeLoc>(); 3483 3484 TemplateName Template 3485 = getDerived().TransformTemplateName(SS, 3486 SpecTL.getTypePtr()->getTemplateName(), 3487 SpecTL.getTemplateNameLoc(), 3488 ObjectType, UnqualLookup); 3489 if (Template.isNull()) 3490 return 0; 3491 3492 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3493 Template); 3494 } else if (isa<DependentTemplateSpecializationType>(T)) { 3495 DependentTemplateSpecializationTypeLoc SpecTL = 3496 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3497 3498 TemplateName Template 3499 = getDerived().RebuildTemplateName(SS, 3500 *SpecTL.getTypePtr()->getIdentifier(), 3501 SpecTL.getTemplateNameLoc(), 3502 ObjectType, UnqualLookup); 3503 if (Template.isNull()) 3504 return 0; 3505 3506 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3507 SpecTL, 3508 Template, 3509 SS); 3510 } else { 3511 // Nothing special needs to be done for these. 3512 Result = getDerived().TransformType(TLB, TL); 3513 } 3514 3515 if (Result.isNull()) 3516 return 0; 3517 3518 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3519} 3520 3521template <class TyLoc> static inline 3522QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 3523 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 3524 NewT.setNameLoc(T.getNameLoc()); 3525 return T.getType(); 3526} 3527 3528template<typename Derived> 3529QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 3530 BuiltinTypeLoc T) { 3531 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 3532 NewT.setBuiltinLoc(T.getBuiltinLoc()); 3533 if (T.needsExtraLocalData()) 3534 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 3535 return T.getType(); 3536} 3537 3538template<typename Derived> 3539QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 3540 ComplexTypeLoc T) { 3541 // FIXME: recurse? 3542 return TransformTypeSpecType(TLB, T); 3543} 3544 3545template<typename Derived> 3546QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 3547 PointerTypeLoc TL) { 3548 QualType PointeeType 3549 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3550 if (PointeeType.isNull()) 3551 return QualType(); 3552 3553 QualType Result = TL.getType(); 3554 if (PointeeType->getAs<ObjCObjectType>()) { 3555 // A dependent pointer type 'T *' has is being transformed such 3556 // that an Objective-C class type is being replaced for 'T'. The 3557 // resulting pointer type is an ObjCObjectPointerType, not a 3558 // PointerType. 3559 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); 3560 3561 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 3562 NewT.setStarLoc(TL.getStarLoc()); 3563 return Result; 3564 } 3565 3566 if (getDerived().AlwaysRebuild() || 3567 PointeeType != TL.getPointeeLoc().getType()) { 3568 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 3569 if (Result.isNull()) 3570 return QualType(); 3571 } 3572 3573 // Objective-C ARC can add lifetime qualifiers to the type that we're 3574 // pointing to. 3575 TLB.TypeWasModifiedSafely(Result->getPointeeType()); 3576 3577 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 3578 NewT.setSigilLoc(TL.getSigilLoc()); 3579 return Result; 3580} 3581 3582template<typename Derived> 3583QualType 3584TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 3585 BlockPointerTypeLoc TL) { 3586 QualType PointeeType 3587 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3588 if (PointeeType.isNull()) 3589 return QualType(); 3590 3591 QualType Result = TL.getType(); 3592 if (getDerived().AlwaysRebuild() || 3593 PointeeType != TL.getPointeeLoc().getType()) { 3594 Result = getDerived().RebuildBlockPointerType(PointeeType, 3595 TL.getSigilLoc()); 3596 if (Result.isNull()) 3597 return QualType(); 3598 } 3599 3600 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); 3601 NewT.setSigilLoc(TL.getSigilLoc()); 3602 return Result; 3603} 3604 3605/// Transforms a reference type. Note that somewhat paradoxically we 3606/// don't care whether the type itself is an l-value type or an r-value 3607/// type; we only care if the type was *written* as an l-value type 3608/// or an r-value type. 3609template<typename Derived> 3610QualType 3611TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 3612 ReferenceTypeLoc TL) { 3613 const ReferenceType *T = TL.getTypePtr(); 3614 3615 // Note that this works with the pointee-as-written. 3616 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3617 if (PointeeType.isNull()) 3618 return QualType(); 3619 3620 QualType Result = TL.getType(); 3621 if (getDerived().AlwaysRebuild() || 3622 PointeeType != T->getPointeeTypeAsWritten()) { 3623 Result = getDerived().RebuildReferenceType(PointeeType, 3624 T->isSpelledAsLValue(), 3625 TL.getSigilLoc()); 3626 if (Result.isNull()) 3627 return QualType(); 3628 } 3629 3630 // Objective-C ARC can add lifetime qualifiers to the type that we're 3631 // referring to. 3632 TLB.TypeWasModifiedSafely( 3633 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten()); 3634 3635 // r-value references can be rebuilt as l-value references. 3636 ReferenceTypeLoc NewTL; 3637 if (isa<LValueReferenceType>(Result)) 3638 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 3639 else 3640 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 3641 NewTL.setSigilLoc(TL.getSigilLoc()); 3642 3643 return Result; 3644} 3645 3646template<typename Derived> 3647QualType 3648TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 3649 LValueReferenceTypeLoc TL) { 3650 return TransformReferenceType(TLB, TL); 3651} 3652 3653template<typename Derived> 3654QualType 3655TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 3656 RValueReferenceTypeLoc TL) { 3657 return TransformReferenceType(TLB, TL); 3658} 3659 3660template<typename Derived> 3661QualType 3662TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 3663 MemberPointerTypeLoc TL) { 3664 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3665 if (PointeeType.isNull()) 3666 return QualType(); 3667 3668 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo(); 3669 TypeSourceInfo* NewClsTInfo = 0; 3670 if (OldClsTInfo) { 3671 NewClsTInfo = getDerived().TransformType(OldClsTInfo); 3672 if (!NewClsTInfo) 3673 return QualType(); 3674 } 3675 3676 const MemberPointerType *T = TL.getTypePtr(); 3677 QualType OldClsType = QualType(T->getClass(), 0); 3678 QualType NewClsType; 3679 if (NewClsTInfo) 3680 NewClsType = NewClsTInfo->getType(); 3681 else { 3682 NewClsType = getDerived().TransformType(OldClsType); 3683 if (NewClsType.isNull()) 3684 return QualType(); 3685 } 3686 3687 QualType Result = TL.getType(); 3688 if (getDerived().AlwaysRebuild() || 3689 PointeeType != T->getPointeeType() || 3690 NewClsType != OldClsType) { 3691 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType, 3692 TL.getStarLoc()); 3693 if (Result.isNull()) 3694 return QualType(); 3695 } 3696 3697 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 3698 NewTL.setSigilLoc(TL.getSigilLoc()); 3699 NewTL.setClassTInfo(NewClsTInfo); 3700 3701 return Result; 3702} 3703 3704template<typename Derived> 3705QualType 3706TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 3707 ConstantArrayTypeLoc TL) { 3708 const ConstantArrayType *T = TL.getTypePtr(); 3709 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3710 if (ElementType.isNull()) 3711 return QualType(); 3712 3713 QualType Result = TL.getType(); 3714 if (getDerived().AlwaysRebuild() || 3715 ElementType != T->getElementType()) { 3716 Result = getDerived().RebuildConstantArrayType(ElementType, 3717 T->getSizeModifier(), 3718 T->getSize(), 3719 T->getIndexTypeCVRQualifiers(), 3720 TL.getBracketsRange()); 3721 if (Result.isNull()) 3722 return QualType(); 3723 } 3724 3725 // We might have either a ConstantArrayType or a VariableArrayType now: 3726 // a ConstantArrayType is allowed to have an element type which is a 3727 // VariableArrayType if the type is dependent. Fortunately, all array 3728 // types have the same location layout. 3729 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3730 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3731 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3732 3733 Expr *Size = TL.getSizeExpr(); 3734 if (Size) { 3735 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3736 Sema::ConstantEvaluated); 3737 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 3738 Size = SemaRef.ActOnConstantExpression(Size).take(); 3739 } 3740 NewTL.setSizeExpr(Size); 3741 3742 return Result; 3743} 3744 3745template<typename Derived> 3746QualType TreeTransform<Derived>::TransformIncompleteArrayType( 3747 TypeLocBuilder &TLB, 3748 IncompleteArrayTypeLoc TL) { 3749 const IncompleteArrayType *T = TL.getTypePtr(); 3750 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3751 if (ElementType.isNull()) 3752 return QualType(); 3753 3754 QualType Result = TL.getType(); 3755 if (getDerived().AlwaysRebuild() || 3756 ElementType != T->getElementType()) { 3757 Result = getDerived().RebuildIncompleteArrayType(ElementType, 3758 T->getSizeModifier(), 3759 T->getIndexTypeCVRQualifiers(), 3760 TL.getBracketsRange()); 3761 if (Result.isNull()) 3762 return QualType(); 3763 } 3764 3765 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 3766 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3767 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3768 NewTL.setSizeExpr(0); 3769 3770 return Result; 3771} 3772 3773template<typename Derived> 3774QualType 3775TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 3776 VariableArrayTypeLoc TL) { 3777 const VariableArrayType *T = TL.getTypePtr(); 3778 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3779 if (ElementType.isNull()) 3780 return QualType(); 3781 3782 ExprResult SizeResult 3783 = getDerived().TransformExpr(T->getSizeExpr()); 3784 if (SizeResult.isInvalid()) 3785 return QualType(); 3786 3787 Expr *Size = SizeResult.take(); 3788 3789 QualType Result = TL.getType(); 3790 if (getDerived().AlwaysRebuild() || 3791 ElementType != T->getElementType() || 3792 Size != T->getSizeExpr()) { 3793 Result = getDerived().RebuildVariableArrayType(ElementType, 3794 T->getSizeModifier(), 3795 Size, 3796 T->getIndexTypeCVRQualifiers(), 3797 TL.getBracketsRange()); 3798 if (Result.isNull()) 3799 return QualType(); 3800 } 3801 3802 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 3803 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3804 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3805 NewTL.setSizeExpr(Size); 3806 3807 return Result; 3808} 3809 3810template<typename Derived> 3811QualType 3812TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 3813 DependentSizedArrayTypeLoc TL) { 3814 const DependentSizedArrayType *T = TL.getTypePtr(); 3815 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3816 if (ElementType.isNull()) 3817 return QualType(); 3818 3819 // Array bounds are constant expressions. 3820 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3821 Sema::ConstantEvaluated); 3822 3823 // Prefer the expression from the TypeLoc; the other may have been uniqued. 3824 Expr *origSize = TL.getSizeExpr(); 3825 if (!origSize) origSize = T->getSizeExpr(); 3826 3827 ExprResult sizeResult 3828 = getDerived().TransformExpr(origSize); 3829 sizeResult = SemaRef.ActOnConstantExpression(sizeResult); 3830 if (sizeResult.isInvalid()) 3831 return QualType(); 3832 3833 Expr *size = sizeResult.get(); 3834 3835 QualType Result = TL.getType(); 3836 if (getDerived().AlwaysRebuild() || 3837 ElementType != T->getElementType() || 3838 size != origSize) { 3839 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 3840 T->getSizeModifier(), 3841 size, 3842 T->getIndexTypeCVRQualifiers(), 3843 TL.getBracketsRange()); 3844 if (Result.isNull()) 3845 return QualType(); 3846 } 3847 3848 // We might have any sort of array type now, but fortunately they 3849 // all have the same location layout. 3850 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3851 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3852 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3853 NewTL.setSizeExpr(size); 3854 3855 return Result; 3856} 3857 3858template<typename Derived> 3859QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 3860 TypeLocBuilder &TLB, 3861 DependentSizedExtVectorTypeLoc TL) { 3862 const DependentSizedExtVectorType *T = TL.getTypePtr(); 3863 3864 // FIXME: ext vector locs should be nested 3865 QualType ElementType = getDerived().TransformType(T->getElementType()); 3866 if (ElementType.isNull()) 3867 return QualType(); 3868 3869 // Vector sizes are constant expressions. 3870 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3871 Sema::ConstantEvaluated); 3872 3873 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 3874 Size = SemaRef.ActOnConstantExpression(Size); 3875 if (Size.isInvalid()) 3876 return QualType(); 3877 3878 QualType Result = TL.getType(); 3879 if (getDerived().AlwaysRebuild() || 3880 ElementType != T->getElementType() || 3881 Size.get() != T->getSizeExpr()) { 3882 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 3883 Size.take(), 3884 T->getAttributeLoc()); 3885 if (Result.isNull()) 3886 return QualType(); 3887 } 3888 3889 // Result might be dependent or not. 3890 if (isa<DependentSizedExtVectorType>(Result)) { 3891 DependentSizedExtVectorTypeLoc NewTL 3892 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 3893 NewTL.setNameLoc(TL.getNameLoc()); 3894 } else { 3895 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3896 NewTL.setNameLoc(TL.getNameLoc()); 3897 } 3898 3899 return Result; 3900} 3901 3902template<typename Derived> 3903QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 3904 VectorTypeLoc TL) { 3905 const VectorType *T = TL.getTypePtr(); 3906 QualType ElementType = getDerived().TransformType(T->getElementType()); 3907 if (ElementType.isNull()) 3908 return QualType(); 3909 3910 QualType Result = TL.getType(); 3911 if (getDerived().AlwaysRebuild() || 3912 ElementType != T->getElementType()) { 3913 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 3914 T->getVectorKind()); 3915 if (Result.isNull()) 3916 return QualType(); 3917 } 3918 3919 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 3920 NewTL.setNameLoc(TL.getNameLoc()); 3921 3922 return Result; 3923} 3924 3925template<typename Derived> 3926QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 3927 ExtVectorTypeLoc TL) { 3928 const VectorType *T = TL.getTypePtr(); 3929 QualType ElementType = getDerived().TransformType(T->getElementType()); 3930 if (ElementType.isNull()) 3931 return QualType(); 3932 3933 QualType Result = TL.getType(); 3934 if (getDerived().AlwaysRebuild() || 3935 ElementType != T->getElementType()) { 3936 Result = getDerived().RebuildExtVectorType(ElementType, 3937 T->getNumElements(), 3938 /*FIXME*/ SourceLocation()); 3939 if (Result.isNull()) 3940 return QualType(); 3941 } 3942 3943 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3944 NewTL.setNameLoc(TL.getNameLoc()); 3945 3946 return Result; 3947} 3948 3949template <typename Derived> 3950ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( 3951 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, 3952 bool ExpectParameterPack) { 3953 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 3954 TypeSourceInfo *NewDI = 0; 3955 3956 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { 3957 // If we're substituting into a pack expansion type and we know the 3958 // length we want to expand to, just substitute for the pattern. 3959 TypeLoc OldTL = OldDI->getTypeLoc(); 3960 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>(); 3961 3962 TypeLocBuilder TLB; 3963 TypeLoc NewTL = OldDI->getTypeLoc(); 3964 TLB.reserve(NewTL.getFullDataSize()); 3965 3966 QualType Result = getDerived().TransformType(TLB, 3967 OldExpansionTL.getPatternLoc()); 3968 if (Result.isNull()) 3969 return 0; 3970 3971 Result = RebuildPackExpansionType(Result, 3972 OldExpansionTL.getPatternLoc().getSourceRange(), 3973 OldExpansionTL.getEllipsisLoc(), 3974 NumExpansions); 3975 if (Result.isNull()) 3976 return 0; 3977 3978 PackExpansionTypeLoc NewExpansionTL 3979 = TLB.push<PackExpansionTypeLoc>(Result); 3980 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); 3981 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result); 3982 } else 3983 NewDI = getDerived().TransformType(OldDI); 3984 if (!NewDI) 3985 return 0; 3986 3987 if (NewDI == OldDI && indexAdjustment == 0) 3988 return OldParm; 3989 3990 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context, 3991 OldParm->getDeclContext(), 3992 OldParm->getInnerLocStart(), 3993 OldParm->getLocation(), 3994 OldParm->getIdentifier(), 3995 NewDI->getType(), 3996 NewDI, 3997 OldParm->getStorageClass(), 3998 OldParm->getStorageClassAsWritten(), 3999 /* DefArg */ NULL); 4000 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 4001 OldParm->getFunctionScopeIndex() + indexAdjustment); 4002 return newParm; 4003} 4004 4005template<typename Derived> 4006bool TreeTransform<Derived>:: 4007 TransformFunctionTypeParams(SourceLocation Loc, 4008 ParmVarDecl **Params, unsigned NumParams, 4009 const QualType *ParamTypes, 4010 SmallVectorImpl<QualType> &OutParamTypes, 4011 SmallVectorImpl<ParmVarDecl*> *PVars) { 4012 int indexAdjustment = 0; 4013 4014 for (unsigned i = 0; i != NumParams; ++i) { 4015 if (ParmVarDecl *OldParm = Params[i]) { 4016 assert(OldParm->getFunctionScopeIndex() == i); 4017 4018 Optional<unsigned> NumExpansions; 4019 ParmVarDecl *NewParm = 0; 4020 if (OldParm->isParameterPack()) { 4021 // We have a function parameter pack that may need to be expanded. 4022 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4023 4024 // Find the parameter packs that could be expanded. 4025 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); 4026 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); 4027 TypeLoc Pattern = ExpansionTL.getPatternLoc(); 4028 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 4029 assert(Unexpanded.size() > 0 && "Could not find parameter packs!"); 4030 4031 // Determine whether we should expand the parameter packs. 4032 bool ShouldExpand = false; 4033 bool RetainExpansion = false; 4034 Optional<unsigned> OrigNumExpansions = 4035 ExpansionTL.getTypePtr()->getNumExpansions(); 4036 NumExpansions = OrigNumExpansions; 4037 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 4038 Pattern.getSourceRange(), 4039 Unexpanded, 4040 ShouldExpand, 4041 RetainExpansion, 4042 NumExpansions)) { 4043 return true; 4044 } 4045 4046 if (ShouldExpand) { 4047 // Expand the function parameter pack into multiple, separate 4048 // parameters. 4049 getDerived().ExpandingFunctionParameterPack(OldParm); 4050 for (unsigned I = 0; I != *NumExpansions; ++I) { 4051 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4052 ParmVarDecl *NewParm 4053 = getDerived().TransformFunctionTypeParam(OldParm, 4054 indexAdjustment++, 4055 OrigNumExpansions, 4056 /*ExpectParameterPack=*/false); 4057 if (!NewParm) 4058 return true; 4059 4060 OutParamTypes.push_back(NewParm->getType()); 4061 if (PVars) 4062 PVars->push_back(NewParm); 4063 } 4064 4065 // If we're supposed to retain a pack expansion, do so by temporarily 4066 // forgetting the partially-substituted parameter pack. 4067 if (RetainExpansion) { 4068 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4069 ParmVarDecl *NewParm 4070 = getDerived().TransformFunctionTypeParam(OldParm, 4071 indexAdjustment++, 4072 OrigNumExpansions, 4073 /*ExpectParameterPack=*/false); 4074 if (!NewParm) 4075 return true; 4076 4077 OutParamTypes.push_back(NewParm->getType()); 4078 if (PVars) 4079 PVars->push_back(NewParm); 4080 } 4081 4082 // The next parameter should have the same adjustment as the 4083 // last thing we pushed, but we post-incremented indexAdjustment 4084 // on every push. Also, if we push nothing, the adjustment should 4085 // go down by one. 4086 indexAdjustment--; 4087 4088 // We're done with the pack expansion. 4089 continue; 4090 } 4091 4092 // We'll substitute the parameter now without expanding the pack 4093 // expansion. 4094 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4095 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 4096 indexAdjustment, 4097 NumExpansions, 4098 /*ExpectParameterPack=*/true); 4099 } else { 4100 NewParm = getDerived().TransformFunctionTypeParam( 4101 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); 4102 } 4103 4104 if (!NewParm) 4105 return true; 4106 4107 OutParamTypes.push_back(NewParm->getType()); 4108 if (PVars) 4109 PVars->push_back(NewParm); 4110 continue; 4111 } 4112 4113 // Deal with the possibility that we don't have a parameter 4114 // declaration for this parameter. 4115 QualType OldType = ParamTypes[i]; 4116 bool IsPackExpansion = false; 4117 Optional<unsigned> NumExpansions; 4118 QualType NewType; 4119 if (const PackExpansionType *Expansion 4120 = dyn_cast<PackExpansionType>(OldType)) { 4121 // We have a function parameter pack that may need to be expanded. 4122 QualType Pattern = Expansion->getPattern(); 4123 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4124 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 4125 4126 // Determine whether we should expand the parameter packs. 4127 bool ShouldExpand = false; 4128 bool RetainExpansion = false; 4129 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(), 4130 Unexpanded, 4131 ShouldExpand, 4132 RetainExpansion, 4133 NumExpansions)) { 4134 return true; 4135 } 4136 4137 if (ShouldExpand) { 4138 // Expand the function parameter pack into multiple, separate 4139 // parameters. 4140 for (unsigned I = 0; I != *NumExpansions; ++I) { 4141 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4142 QualType NewType = getDerived().TransformType(Pattern); 4143 if (NewType.isNull()) 4144 return true; 4145 4146 OutParamTypes.push_back(NewType); 4147 if (PVars) 4148 PVars->push_back(0); 4149 } 4150 4151 // We're done with the pack expansion. 4152 continue; 4153 } 4154 4155 // If we're supposed to retain a pack expansion, do so by temporarily 4156 // forgetting the partially-substituted parameter pack. 4157 if (RetainExpansion) { 4158 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4159 QualType NewType = getDerived().TransformType(Pattern); 4160 if (NewType.isNull()) 4161 return true; 4162 4163 OutParamTypes.push_back(NewType); 4164 if (PVars) 4165 PVars->push_back(0); 4166 } 4167 4168 // We'll substitute the parameter now without expanding the pack 4169 // expansion. 4170 OldType = Expansion->getPattern(); 4171 IsPackExpansion = true; 4172 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4173 NewType = getDerived().TransformType(OldType); 4174 } else { 4175 NewType = getDerived().TransformType(OldType); 4176 } 4177 4178 if (NewType.isNull()) 4179 return true; 4180 4181 if (IsPackExpansion) 4182 NewType = getSema().Context.getPackExpansionType(NewType, 4183 NumExpansions); 4184 4185 OutParamTypes.push_back(NewType); 4186 if (PVars) 4187 PVars->push_back(0); 4188 } 4189 4190#ifndef NDEBUG 4191 if (PVars) { 4192 for (unsigned i = 0, e = PVars->size(); i != e; ++i) 4193 if (ParmVarDecl *parm = (*PVars)[i]) 4194 assert(parm->getFunctionScopeIndex() == i); 4195 } 4196#endif 4197 4198 return false; 4199} 4200 4201template<typename Derived> 4202QualType 4203TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4204 FunctionProtoTypeLoc TL) { 4205 return getDerived().TransformFunctionProtoType(TLB, TL, 0, 0); 4206} 4207 4208template<typename Derived> 4209QualType 4210TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4211 FunctionProtoTypeLoc TL, 4212 CXXRecordDecl *ThisContext, 4213 unsigned ThisTypeQuals) { 4214 // Transform the parameters and return type. 4215 // 4216 // We are required to instantiate the params and return type in source order. 4217 // When the function has a trailing return type, we instantiate the 4218 // parameters before the return type, since the return type can then refer 4219 // to the parameters themselves (via decltype, sizeof, etc.). 4220 // 4221 SmallVector<QualType, 4> ParamTypes; 4222 SmallVector<ParmVarDecl*, 4> ParamDecls; 4223 const FunctionProtoType *T = TL.getTypePtr(); 4224 4225 QualType ResultType; 4226 4227 if (T->hasTrailingReturn()) { 4228 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 4229 TL.getParmArray(), 4230 TL.getNumArgs(), 4231 TL.getTypePtr()->arg_type_begin(), 4232 ParamTypes, &ParamDecls)) 4233 return QualType(); 4234 4235 { 4236 // C++11 [expr.prim.general]p3: 4237 // If a declaration declares a member function or member function 4238 // template of a class X, the expression this is a prvalue of type 4239 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 4240 // and the end of the function-definition, member-declarator, or 4241 // declarator. 4242 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals); 4243 4244 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4245 if (ResultType.isNull()) 4246 return QualType(); 4247 } 4248 } 4249 else { 4250 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4251 if (ResultType.isNull()) 4252 return QualType(); 4253 4254 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 4255 TL.getParmArray(), 4256 TL.getNumArgs(), 4257 TL.getTypePtr()->arg_type_begin(), 4258 ParamTypes, &ParamDecls)) 4259 return QualType(); 4260 } 4261 4262 // FIXME: Need to transform the exception-specification too. 4263 4264 QualType Result = TL.getType(); 4265 if (getDerived().AlwaysRebuild() || 4266 ResultType != T->getResultType() || 4267 T->getNumArgs() != ParamTypes.size() || 4268 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 4269 Result = getDerived().RebuildFunctionProtoType(ResultType, 4270 ParamTypes.data(), 4271 ParamTypes.size(), 4272 T->isVariadic(), 4273 T->hasTrailingReturn(), 4274 T->getTypeQuals(), 4275 T->getRefQualifier(), 4276 T->getExtInfo()); 4277 if (Result.isNull()) 4278 return QualType(); 4279 } 4280 4281 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 4282 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4283 NewTL.setLParenLoc(TL.getLParenLoc()); 4284 NewTL.setRParenLoc(TL.getRParenLoc()); 4285 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4286 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 4287 NewTL.setArg(i, ParamDecls[i]); 4288 4289 return Result; 4290} 4291 4292template<typename Derived> 4293QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 4294 TypeLocBuilder &TLB, 4295 FunctionNoProtoTypeLoc TL) { 4296 const FunctionNoProtoType *T = TL.getTypePtr(); 4297 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4298 if (ResultType.isNull()) 4299 return QualType(); 4300 4301 QualType Result = TL.getType(); 4302 if (getDerived().AlwaysRebuild() || 4303 ResultType != T->getResultType()) 4304 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 4305 4306 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 4307 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4308 NewTL.setLParenLoc(TL.getLParenLoc()); 4309 NewTL.setRParenLoc(TL.getRParenLoc()); 4310 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4311 4312 return Result; 4313} 4314 4315template<typename Derived> QualType 4316TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 4317 UnresolvedUsingTypeLoc TL) { 4318 const UnresolvedUsingType *T = TL.getTypePtr(); 4319 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 4320 if (!D) 4321 return QualType(); 4322 4323 QualType Result = TL.getType(); 4324 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 4325 Result = getDerived().RebuildUnresolvedUsingType(D); 4326 if (Result.isNull()) 4327 return QualType(); 4328 } 4329 4330 // We might get an arbitrary type spec type back. We should at 4331 // least always get a type spec type, though. 4332 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 4333 NewTL.setNameLoc(TL.getNameLoc()); 4334 4335 return Result; 4336} 4337 4338template<typename Derived> 4339QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 4340 TypedefTypeLoc TL) { 4341 const TypedefType *T = TL.getTypePtr(); 4342 TypedefNameDecl *Typedef 4343 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4344 T->getDecl())); 4345 if (!Typedef) 4346 return QualType(); 4347 4348 QualType Result = TL.getType(); 4349 if (getDerived().AlwaysRebuild() || 4350 Typedef != T->getDecl()) { 4351 Result = getDerived().RebuildTypedefType(Typedef); 4352 if (Result.isNull()) 4353 return QualType(); 4354 } 4355 4356 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 4357 NewTL.setNameLoc(TL.getNameLoc()); 4358 4359 return Result; 4360} 4361 4362template<typename Derived> 4363QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 4364 TypeOfExprTypeLoc TL) { 4365 // typeof expressions are not potentially evaluated contexts 4366 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4367 Sema::ReuseLambdaContextDecl); 4368 4369 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 4370 if (E.isInvalid()) 4371 return QualType(); 4372 4373 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get()); 4374 if (E.isInvalid()) 4375 return QualType(); 4376 4377 QualType Result = TL.getType(); 4378 if (getDerived().AlwaysRebuild() || 4379 E.get() != TL.getUnderlyingExpr()) { 4380 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 4381 if (Result.isNull()) 4382 return QualType(); 4383 } 4384 else E.take(); 4385 4386 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 4387 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4388 NewTL.setLParenLoc(TL.getLParenLoc()); 4389 NewTL.setRParenLoc(TL.getRParenLoc()); 4390 4391 return Result; 4392} 4393 4394template<typename Derived> 4395QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 4396 TypeOfTypeLoc TL) { 4397 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 4398 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 4399 if (!New_Under_TI) 4400 return QualType(); 4401 4402 QualType Result = TL.getType(); 4403 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 4404 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 4405 if (Result.isNull()) 4406 return QualType(); 4407 } 4408 4409 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 4410 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4411 NewTL.setLParenLoc(TL.getLParenLoc()); 4412 NewTL.setRParenLoc(TL.getRParenLoc()); 4413 NewTL.setUnderlyingTInfo(New_Under_TI); 4414 4415 return Result; 4416} 4417 4418template<typename Derived> 4419QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 4420 DecltypeTypeLoc TL) { 4421 const DecltypeType *T = TL.getTypePtr(); 4422 4423 // decltype expressions are not potentially evaluated contexts 4424 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 0, 4425 /*IsDecltype=*/ true); 4426 4427 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 4428 if (E.isInvalid()) 4429 return QualType(); 4430 4431 E = getSema().ActOnDecltypeExpression(E.take()); 4432 if (E.isInvalid()) 4433 return QualType(); 4434 4435 QualType Result = TL.getType(); 4436 if (getDerived().AlwaysRebuild() || 4437 E.get() != T->getUnderlyingExpr()) { 4438 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 4439 if (Result.isNull()) 4440 return QualType(); 4441 } 4442 else E.take(); 4443 4444 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 4445 NewTL.setNameLoc(TL.getNameLoc()); 4446 4447 return Result; 4448} 4449 4450template<typename Derived> 4451QualType TreeTransform<Derived>::TransformUnaryTransformType( 4452 TypeLocBuilder &TLB, 4453 UnaryTransformTypeLoc TL) { 4454 QualType Result = TL.getType(); 4455 if (Result->isDependentType()) { 4456 const UnaryTransformType *T = TL.getTypePtr(); 4457 QualType NewBase = 4458 getDerived().TransformType(TL.getUnderlyingTInfo())->getType(); 4459 Result = getDerived().RebuildUnaryTransformType(NewBase, 4460 T->getUTTKind(), 4461 TL.getKWLoc()); 4462 if (Result.isNull()) 4463 return QualType(); 4464 } 4465 4466 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result); 4467 NewTL.setKWLoc(TL.getKWLoc()); 4468 NewTL.setParensRange(TL.getParensRange()); 4469 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo()); 4470 return Result; 4471} 4472 4473template<typename Derived> 4474QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, 4475 AutoTypeLoc TL) { 4476 const AutoType *T = TL.getTypePtr(); 4477 QualType OldDeduced = T->getDeducedType(); 4478 QualType NewDeduced; 4479 if (!OldDeduced.isNull()) { 4480 NewDeduced = getDerived().TransformType(OldDeduced); 4481 if (NewDeduced.isNull()) 4482 return QualType(); 4483 } 4484 4485 QualType Result = TL.getType(); 4486 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced) { 4487 Result = getDerived().RebuildAutoType(NewDeduced); 4488 if (Result.isNull()) 4489 return QualType(); 4490 } 4491 4492 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 4493 NewTL.setNameLoc(TL.getNameLoc()); 4494 4495 return Result; 4496} 4497 4498template<typename Derived> 4499QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 4500 RecordTypeLoc TL) { 4501 const RecordType *T = TL.getTypePtr(); 4502 RecordDecl *Record 4503 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4504 T->getDecl())); 4505 if (!Record) 4506 return QualType(); 4507 4508 QualType Result = TL.getType(); 4509 if (getDerived().AlwaysRebuild() || 4510 Record != T->getDecl()) { 4511 Result = getDerived().RebuildRecordType(Record); 4512 if (Result.isNull()) 4513 return QualType(); 4514 } 4515 4516 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 4517 NewTL.setNameLoc(TL.getNameLoc()); 4518 4519 return Result; 4520} 4521 4522template<typename Derived> 4523QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 4524 EnumTypeLoc TL) { 4525 const EnumType *T = TL.getTypePtr(); 4526 EnumDecl *Enum 4527 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4528 T->getDecl())); 4529 if (!Enum) 4530 return QualType(); 4531 4532 QualType Result = TL.getType(); 4533 if (getDerived().AlwaysRebuild() || 4534 Enum != T->getDecl()) { 4535 Result = getDerived().RebuildEnumType(Enum); 4536 if (Result.isNull()) 4537 return QualType(); 4538 } 4539 4540 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 4541 NewTL.setNameLoc(TL.getNameLoc()); 4542 4543 return Result; 4544} 4545 4546template<typename Derived> 4547QualType TreeTransform<Derived>::TransformInjectedClassNameType( 4548 TypeLocBuilder &TLB, 4549 InjectedClassNameTypeLoc TL) { 4550 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 4551 TL.getTypePtr()->getDecl()); 4552 if (!D) return QualType(); 4553 4554 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 4555 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 4556 return T; 4557} 4558 4559template<typename Derived> 4560QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 4561 TypeLocBuilder &TLB, 4562 TemplateTypeParmTypeLoc TL) { 4563 return TransformTypeSpecType(TLB, TL); 4564} 4565 4566template<typename Derived> 4567QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 4568 TypeLocBuilder &TLB, 4569 SubstTemplateTypeParmTypeLoc TL) { 4570 const SubstTemplateTypeParmType *T = TL.getTypePtr(); 4571 4572 // Substitute into the replacement type, which itself might involve something 4573 // that needs to be transformed. This only tends to occur with default 4574 // template arguments of template template parameters. 4575 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName()); 4576 QualType Replacement = getDerived().TransformType(T->getReplacementType()); 4577 if (Replacement.isNull()) 4578 return QualType(); 4579 4580 // Always canonicalize the replacement type. 4581 Replacement = SemaRef.Context.getCanonicalType(Replacement); 4582 QualType Result 4583 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), 4584 Replacement); 4585 4586 // Propagate type-source information. 4587 SubstTemplateTypeParmTypeLoc NewTL 4588 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 4589 NewTL.setNameLoc(TL.getNameLoc()); 4590 return Result; 4591 4592} 4593 4594template<typename Derived> 4595QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( 4596 TypeLocBuilder &TLB, 4597 SubstTemplateTypeParmPackTypeLoc TL) { 4598 return TransformTypeSpecType(TLB, TL); 4599} 4600 4601template<typename Derived> 4602QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4603 TypeLocBuilder &TLB, 4604 TemplateSpecializationTypeLoc TL) { 4605 const TemplateSpecializationType *T = TL.getTypePtr(); 4606 4607 // The nested-name-specifier never matters in a TemplateSpecializationType, 4608 // because we can't have a dependent nested-name-specifier anyway. 4609 CXXScopeSpec SS; 4610 TemplateName Template 4611 = getDerived().TransformTemplateName(SS, T->getTemplateName(), 4612 TL.getTemplateNameLoc()); 4613 if (Template.isNull()) 4614 return QualType(); 4615 4616 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 4617} 4618 4619template<typename Derived> 4620QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB, 4621 AtomicTypeLoc TL) { 4622 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); 4623 if (ValueType.isNull()) 4624 return QualType(); 4625 4626 QualType Result = TL.getType(); 4627 if (getDerived().AlwaysRebuild() || 4628 ValueType != TL.getValueLoc().getType()) { 4629 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc()); 4630 if (Result.isNull()) 4631 return QualType(); 4632 } 4633 4634 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result); 4635 NewTL.setKWLoc(TL.getKWLoc()); 4636 NewTL.setLParenLoc(TL.getLParenLoc()); 4637 NewTL.setRParenLoc(TL.getRParenLoc()); 4638 4639 return Result; 4640} 4641 4642 /// \brief Simple iterator that traverses the template arguments in a 4643 /// container that provides a \c getArgLoc() member function. 4644 /// 4645 /// This iterator is intended to be used with the iterator form of 4646 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 4647 template<typename ArgLocContainer> 4648 class TemplateArgumentLocContainerIterator { 4649 ArgLocContainer *Container; 4650 unsigned Index; 4651 4652 public: 4653 typedef TemplateArgumentLoc value_type; 4654 typedef TemplateArgumentLoc reference; 4655 typedef int difference_type; 4656 typedef std::input_iterator_tag iterator_category; 4657 4658 class pointer { 4659 TemplateArgumentLoc Arg; 4660 4661 public: 4662 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 4663 4664 const TemplateArgumentLoc *operator->() const { 4665 return &Arg; 4666 } 4667 }; 4668 4669 4670 TemplateArgumentLocContainerIterator() {} 4671 4672 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 4673 unsigned Index) 4674 : Container(&Container), Index(Index) { } 4675 4676 TemplateArgumentLocContainerIterator &operator++() { 4677 ++Index; 4678 return *this; 4679 } 4680 4681 TemplateArgumentLocContainerIterator operator++(int) { 4682 TemplateArgumentLocContainerIterator Old(*this); 4683 ++(*this); 4684 return Old; 4685 } 4686 4687 TemplateArgumentLoc operator*() const { 4688 return Container->getArgLoc(Index); 4689 } 4690 4691 pointer operator->() const { 4692 return pointer(Container->getArgLoc(Index)); 4693 } 4694 4695 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 4696 const TemplateArgumentLocContainerIterator &Y) { 4697 return X.Container == Y.Container && X.Index == Y.Index; 4698 } 4699 4700 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 4701 const TemplateArgumentLocContainerIterator &Y) { 4702 return !(X == Y); 4703 } 4704 }; 4705 4706 4707template <typename Derived> 4708QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4709 TypeLocBuilder &TLB, 4710 TemplateSpecializationTypeLoc TL, 4711 TemplateName Template) { 4712 TemplateArgumentListInfo NewTemplateArgs; 4713 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4714 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4715 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 4716 ArgIterator; 4717 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4718 ArgIterator(TL, TL.getNumArgs()), 4719 NewTemplateArgs)) 4720 return QualType(); 4721 4722 // FIXME: maybe don't rebuild if all the template arguments are the same. 4723 4724 QualType Result = 4725 getDerived().RebuildTemplateSpecializationType(Template, 4726 TL.getTemplateNameLoc(), 4727 NewTemplateArgs); 4728 4729 if (!Result.isNull()) { 4730 // Specializations of template template parameters are represented as 4731 // TemplateSpecializationTypes, and substitution of type alias templates 4732 // within a dependent context can transform them into 4733 // DependentTemplateSpecializationTypes. 4734 if (isa<DependentTemplateSpecializationType>(Result)) { 4735 DependentTemplateSpecializationTypeLoc NewTL 4736 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4737 NewTL.setElaboratedKeywordLoc(SourceLocation()); 4738 NewTL.setQualifierLoc(NestedNameSpecifierLoc()); 4739 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4740 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4741 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4742 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4743 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4744 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4745 return Result; 4746 } 4747 4748 TemplateSpecializationTypeLoc NewTL 4749 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4750 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4751 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4752 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4753 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4754 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4755 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4756 } 4757 4758 return Result; 4759} 4760 4761template <typename Derived> 4762QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( 4763 TypeLocBuilder &TLB, 4764 DependentTemplateSpecializationTypeLoc TL, 4765 TemplateName Template, 4766 CXXScopeSpec &SS) { 4767 TemplateArgumentListInfo NewTemplateArgs; 4768 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4769 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4770 typedef TemplateArgumentLocContainerIterator< 4771 DependentTemplateSpecializationTypeLoc> ArgIterator; 4772 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4773 ArgIterator(TL, TL.getNumArgs()), 4774 NewTemplateArgs)) 4775 return QualType(); 4776 4777 // FIXME: maybe don't rebuild if all the template arguments are the same. 4778 4779 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 4780 QualType Result 4781 = getSema().Context.getDependentTemplateSpecializationType( 4782 TL.getTypePtr()->getKeyword(), 4783 DTN->getQualifier(), 4784 DTN->getIdentifier(), 4785 NewTemplateArgs); 4786 4787 DependentTemplateSpecializationTypeLoc NewTL 4788 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4789 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4790 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context)); 4791 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4792 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4793 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4794 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4795 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4796 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4797 return Result; 4798 } 4799 4800 QualType Result 4801 = getDerived().RebuildTemplateSpecializationType(Template, 4802 TL.getTemplateNameLoc(), 4803 NewTemplateArgs); 4804 4805 if (!Result.isNull()) { 4806 /// FIXME: Wrap this in an elaborated-type-specifier? 4807 TemplateSpecializationTypeLoc NewTL 4808 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4809 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4810 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4811 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4812 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4813 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4814 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4815 } 4816 4817 return Result; 4818} 4819 4820template<typename Derived> 4821QualType 4822TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 4823 ElaboratedTypeLoc TL) { 4824 const ElaboratedType *T = TL.getTypePtr(); 4825 4826 NestedNameSpecifierLoc QualifierLoc; 4827 // NOTE: the qualifier in an ElaboratedType is optional. 4828 if (TL.getQualifierLoc()) { 4829 QualifierLoc 4830 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4831 if (!QualifierLoc) 4832 return QualType(); 4833 } 4834 4835 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 4836 if (NamedT.isNull()) 4837 return QualType(); 4838 4839 // C++0x [dcl.type.elab]p2: 4840 // If the identifier resolves to a typedef-name or the simple-template-id 4841 // resolves to an alias template specialization, the 4842 // elaborated-type-specifier is ill-formed. 4843 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) { 4844 if (const TemplateSpecializationType *TST = 4845 NamedT->getAs<TemplateSpecializationType>()) { 4846 TemplateName Template = TST->getTemplateName(); 4847 if (TypeAliasTemplateDecl *TAT = 4848 dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) { 4849 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(), 4850 diag::err_tag_reference_non_tag) << 4; 4851 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at); 4852 } 4853 } 4854 } 4855 4856 QualType Result = TL.getType(); 4857 if (getDerived().AlwaysRebuild() || 4858 QualifierLoc != TL.getQualifierLoc() || 4859 NamedT != T->getNamedType()) { 4860 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(), 4861 T->getKeyword(), 4862 QualifierLoc, NamedT); 4863 if (Result.isNull()) 4864 return QualType(); 4865 } 4866 4867 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4868 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4869 NewTL.setQualifierLoc(QualifierLoc); 4870 return Result; 4871} 4872 4873template<typename Derived> 4874QualType TreeTransform<Derived>::TransformAttributedType( 4875 TypeLocBuilder &TLB, 4876 AttributedTypeLoc TL) { 4877 const AttributedType *oldType = TL.getTypePtr(); 4878 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); 4879 if (modifiedType.isNull()) 4880 return QualType(); 4881 4882 QualType result = TL.getType(); 4883 4884 // FIXME: dependent operand expressions? 4885 if (getDerived().AlwaysRebuild() || 4886 modifiedType != oldType->getModifiedType()) { 4887 // TODO: this is really lame; we should really be rebuilding the 4888 // equivalent type from first principles. 4889 QualType equivalentType 4890 = getDerived().TransformType(oldType->getEquivalentType()); 4891 if (equivalentType.isNull()) 4892 return QualType(); 4893 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), 4894 modifiedType, 4895 equivalentType); 4896 } 4897 4898 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); 4899 newTL.setAttrNameLoc(TL.getAttrNameLoc()); 4900 if (TL.hasAttrOperand()) 4901 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); 4902 if (TL.hasAttrExprOperand()) 4903 newTL.setAttrExprOperand(TL.getAttrExprOperand()); 4904 else if (TL.hasAttrEnumOperand()) 4905 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc()); 4906 4907 return result; 4908} 4909 4910template<typename Derived> 4911QualType 4912TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 4913 ParenTypeLoc TL) { 4914 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 4915 if (Inner.isNull()) 4916 return QualType(); 4917 4918 QualType Result = TL.getType(); 4919 if (getDerived().AlwaysRebuild() || 4920 Inner != TL.getInnerLoc().getType()) { 4921 Result = getDerived().RebuildParenType(Inner); 4922 if (Result.isNull()) 4923 return QualType(); 4924 } 4925 4926 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 4927 NewTL.setLParenLoc(TL.getLParenLoc()); 4928 NewTL.setRParenLoc(TL.getRParenLoc()); 4929 return Result; 4930} 4931 4932template<typename Derived> 4933QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 4934 DependentNameTypeLoc TL) { 4935 const DependentNameType *T = TL.getTypePtr(); 4936 4937 NestedNameSpecifierLoc QualifierLoc 4938 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4939 if (!QualifierLoc) 4940 return QualType(); 4941 4942 QualType Result 4943 = getDerived().RebuildDependentNameType(T->getKeyword(), 4944 TL.getElaboratedKeywordLoc(), 4945 QualifierLoc, 4946 T->getIdentifier(), 4947 TL.getNameLoc()); 4948 if (Result.isNull()) 4949 return QualType(); 4950 4951 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 4952 QualType NamedT = ElabT->getNamedType(); 4953 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 4954 4955 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4956 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4957 NewTL.setQualifierLoc(QualifierLoc); 4958 } else { 4959 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 4960 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4961 NewTL.setQualifierLoc(QualifierLoc); 4962 NewTL.setNameLoc(TL.getNameLoc()); 4963 } 4964 return Result; 4965} 4966 4967template<typename Derived> 4968QualType TreeTransform<Derived>:: 4969 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 4970 DependentTemplateSpecializationTypeLoc TL) { 4971 NestedNameSpecifierLoc QualifierLoc; 4972 if (TL.getQualifierLoc()) { 4973 QualifierLoc 4974 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4975 if (!QualifierLoc) 4976 return QualType(); 4977 } 4978 4979 return getDerived() 4980 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc); 4981} 4982 4983template<typename Derived> 4984QualType TreeTransform<Derived>:: 4985TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 4986 DependentTemplateSpecializationTypeLoc TL, 4987 NestedNameSpecifierLoc QualifierLoc) { 4988 const DependentTemplateSpecializationType *T = TL.getTypePtr(); 4989 4990 TemplateArgumentListInfo NewTemplateArgs; 4991 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4992 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4993 4994 typedef TemplateArgumentLocContainerIterator< 4995 DependentTemplateSpecializationTypeLoc> ArgIterator; 4996 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4997 ArgIterator(TL, TL.getNumArgs()), 4998 NewTemplateArgs)) 4999 return QualType(); 5000 5001 QualType Result 5002 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 5003 QualifierLoc, 5004 T->getIdentifier(), 5005 TL.getTemplateNameLoc(), 5006 NewTemplateArgs); 5007 if (Result.isNull()) 5008 return QualType(); 5009 5010 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 5011 QualType NamedT = ElabT->getNamedType(); 5012 5013 // Copy information relevant to the template specialization. 5014 TemplateSpecializationTypeLoc NamedTL 5015 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 5016 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5017 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5018 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 5019 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 5020 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5021 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5022 5023 // Copy information relevant to the elaborated type. 5024 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5025 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5026 NewTL.setQualifierLoc(QualifierLoc); 5027 } else if (isa<DependentTemplateSpecializationType>(Result)) { 5028 DependentTemplateSpecializationTypeLoc SpecTL 5029 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5030 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5031 SpecTL.setQualifierLoc(QualifierLoc); 5032 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5033 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5034 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5035 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5036 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5037 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5038 } else { 5039 TemplateSpecializationTypeLoc SpecTL 5040 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5041 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5042 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5043 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5044 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5045 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5046 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5047 } 5048 return Result; 5049} 5050 5051template<typename Derived> 5052QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 5053 PackExpansionTypeLoc TL) { 5054 QualType Pattern 5055 = getDerived().TransformType(TLB, TL.getPatternLoc()); 5056 if (Pattern.isNull()) 5057 return QualType(); 5058 5059 QualType Result = TL.getType(); 5060 if (getDerived().AlwaysRebuild() || 5061 Pattern != TL.getPatternLoc().getType()) { 5062 Result = getDerived().RebuildPackExpansionType(Pattern, 5063 TL.getPatternLoc().getSourceRange(), 5064 TL.getEllipsisLoc(), 5065 TL.getTypePtr()->getNumExpansions()); 5066 if (Result.isNull()) 5067 return QualType(); 5068 } 5069 5070 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); 5071 NewT.setEllipsisLoc(TL.getEllipsisLoc()); 5072 return Result; 5073} 5074 5075template<typename Derived> 5076QualType 5077TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 5078 ObjCInterfaceTypeLoc TL) { 5079 // ObjCInterfaceType is never dependent. 5080 TLB.pushFullCopy(TL); 5081 return TL.getType(); 5082} 5083 5084template<typename Derived> 5085QualType 5086TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 5087 ObjCObjectTypeLoc TL) { 5088 // ObjCObjectType is never dependent. 5089 TLB.pushFullCopy(TL); 5090 return TL.getType(); 5091} 5092 5093template<typename Derived> 5094QualType 5095TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 5096 ObjCObjectPointerTypeLoc TL) { 5097 // ObjCObjectPointerType is never dependent. 5098 TLB.pushFullCopy(TL); 5099 return TL.getType(); 5100} 5101 5102//===----------------------------------------------------------------------===// 5103// Statement transformation 5104//===----------------------------------------------------------------------===// 5105template<typename Derived> 5106StmtResult 5107TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 5108 return SemaRef.Owned(S); 5109} 5110 5111template<typename Derived> 5112StmtResult 5113TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 5114 return getDerived().TransformCompoundStmt(S, false); 5115} 5116 5117template<typename Derived> 5118StmtResult 5119TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 5120 bool IsStmtExpr) { 5121 Sema::CompoundScopeRAII CompoundScope(getSema()); 5122 5123 bool SubStmtInvalid = false; 5124 bool SubStmtChanged = false; 5125 SmallVector<Stmt*, 8> Statements; 5126 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 5127 B != BEnd; ++B) { 5128 StmtResult Result = getDerived().TransformStmt(*B); 5129 if (Result.isInvalid()) { 5130 // Immediately fail if this was a DeclStmt, since it's very 5131 // likely that this will cause problems for future statements. 5132 if (isa<DeclStmt>(*B)) 5133 return StmtError(); 5134 5135 // Otherwise, just keep processing substatements and fail later. 5136 SubStmtInvalid = true; 5137 continue; 5138 } 5139 5140 SubStmtChanged = SubStmtChanged || Result.get() != *B; 5141 Statements.push_back(Result.takeAs<Stmt>()); 5142 } 5143 5144 if (SubStmtInvalid) 5145 return StmtError(); 5146 5147 if (!getDerived().AlwaysRebuild() && 5148 !SubStmtChanged) 5149 return SemaRef.Owned(S); 5150 5151 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 5152 Statements, 5153 S->getRBracLoc(), 5154 IsStmtExpr); 5155} 5156 5157template<typename Derived> 5158StmtResult 5159TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 5160 ExprResult LHS, RHS; 5161 { 5162 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5163 Sema::ConstantEvaluated); 5164 5165 // Transform the left-hand case value. 5166 LHS = getDerived().TransformExpr(S->getLHS()); 5167 LHS = SemaRef.ActOnConstantExpression(LHS); 5168 if (LHS.isInvalid()) 5169 return StmtError(); 5170 5171 // Transform the right-hand case value (for the GNU case-range extension). 5172 RHS = getDerived().TransformExpr(S->getRHS()); 5173 RHS = SemaRef.ActOnConstantExpression(RHS); 5174 if (RHS.isInvalid()) 5175 return StmtError(); 5176 } 5177 5178 // Build the case statement. 5179 // Case statements are always rebuilt so that they will attached to their 5180 // transformed switch statement. 5181 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 5182 LHS.get(), 5183 S->getEllipsisLoc(), 5184 RHS.get(), 5185 S->getColonLoc()); 5186 if (Case.isInvalid()) 5187 return StmtError(); 5188 5189 // Transform the statement following the case 5190 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5191 if (SubStmt.isInvalid()) 5192 return StmtError(); 5193 5194 // Attach the body to the case statement 5195 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 5196} 5197 5198template<typename Derived> 5199StmtResult 5200TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 5201 // Transform the statement following the default case 5202 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5203 if (SubStmt.isInvalid()) 5204 return StmtError(); 5205 5206 // Default statements are always rebuilt 5207 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 5208 SubStmt.get()); 5209} 5210 5211template<typename Derived> 5212StmtResult 5213TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 5214 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5215 if (SubStmt.isInvalid()) 5216 return StmtError(); 5217 5218 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), 5219 S->getDecl()); 5220 if (!LD) 5221 return StmtError(); 5222 5223 5224 // FIXME: Pass the real colon location in. 5225 return getDerived().RebuildLabelStmt(S->getIdentLoc(), 5226 cast<LabelDecl>(LD), SourceLocation(), 5227 SubStmt.get()); 5228} 5229 5230template<typename Derived> 5231StmtResult 5232TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) { 5233 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5234 if (SubStmt.isInvalid()) 5235 return StmtError(); 5236 5237 // TODO: transform attributes 5238 if (SubStmt.get() == S->getSubStmt() /* && attrs are the same */) 5239 return S; 5240 5241 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), 5242 S->getAttrs(), 5243 SubStmt.get()); 5244} 5245 5246template<typename Derived> 5247StmtResult 5248TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 5249 // Transform the condition 5250 ExprResult Cond; 5251 VarDecl *ConditionVar = 0; 5252 if (S->getConditionVariable()) { 5253 ConditionVar 5254 = cast_or_null<VarDecl>( 5255 getDerived().TransformDefinition( 5256 S->getConditionVariable()->getLocation(), 5257 S->getConditionVariable())); 5258 if (!ConditionVar) 5259 return StmtError(); 5260 } else { 5261 Cond = getDerived().TransformExpr(S->getCond()); 5262 5263 if (Cond.isInvalid()) 5264 return StmtError(); 5265 5266 // Convert the condition to a boolean value. 5267 if (S->getCond()) { 5268 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), 5269 Cond.get()); 5270 if (CondE.isInvalid()) 5271 return StmtError(); 5272 5273 Cond = CondE.get(); 5274 } 5275 } 5276 5277 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5278 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5279 return StmtError(); 5280 5281 // Transform the "then" branch. 5282 StmtResult Then = getDerived().TransformStmt(S->getThen()); 5283 if (Then.isInvalid()) 5284 return StmtError(); 5285 5286 // Transform the "else" branch. 5287 StmtResult Else = getDerived().TransformStmt(S->getElse()); 5288 if (Else.isInvalid()) 5289 return StmtError(); 5290 5291 if (!getDerived().AlwaysRebuild() && 5292 FullCond.get() == S->getCond() && 5293 ConditionVar == S->getConditionVariable() && 5294 Then.get() == S->getThen() && 5295 Else.get() == S->getElse()) 5296 return SemaRef.Owned(S); 5297 5298 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 5299 Then.get(), 5300 S->getElseLoc(), Else.get()); 5301} 5302 5303template<typename Derived> 5304StmtResult 5305TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 5306 // Transform the condition. 5307 ExprResult Cond; 5308 VarDecl *ConditionVar = 0; 5309 if (S->getConditionVariable()) { 5310 ConditionVar 5311 = cast_or_null<VarDecl>( 5312 getDerived().TransformDefinition( 5313 S->getConditionVariable()->getLocation(), 5314 S->getConditionVariable())); 5315 if (!ConditionVar) 5316 return StmtError(); 5317 } else { 5318 Cond = getDerived().TransformExpr(S->getCond()); 5319 5320 if (Cond.isInvalid()) 5321 return StmtError(); 5322 } 5323 5324 // Rebuild the switch statement. 5325 StmtResult Switch 5326 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 5327 ConditionVar); 5328 if (Switch.isInvalid()) 5329 return StmtError(); 5330 5331 // Transform the body of the switch statement. 5332 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5333 if (Body.isInvalid()) 5334 return StmtError(); 5335 5336 // Complete the switch statement. 5337 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 5338 Body.get()); 5339} 5340 5341template<typename Derived> 5342StmtResult 5343TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 5344 // Transform the condition 5345 ExprResult Cond; 5346 VarDecl *ConditionVar = 0; 5347 if (S->getConditionVariable()) { 5348 ConditionVar 5349 = cast_or_null<VarDecl>( 5350 getDerived().TransformDefinition( 5351 S->getConditionVariable()->getLocation(), 5352 S->getConditionVariable())); 5353 if (!ConditionVar) 5354 return StmtError(); 5355 } else { 5356 Cond = getDerived().TransformExpr(S->getCond()); 5357 5358 if (Cond.isInvalid()) 5359 return StmtError(); 5360 5361 if (S->getCond()) { 5362 // Convert the condition to a boolean value. 5363 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), 5364 Cond.get()); 5365 if (CondE.isInvalid()) 5366 return StmtError(); 5367 Cond = CondE; 5368 } 5369 } 5370 5371 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5372 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5373 return StmtError(); 5374 5375 // Transform the body 5376 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5377 if (Body.isInvalid()) 5378 return StmtError(); 5379 5380 if (!getDerived().AlwaysRebuild() && 5381 FullCond.get() == S->getCond() && 5382 ConditionVar == S->getConditionVariable() && 5383 Body.get() == S->getBody()) 5384 return Owned(S); 5385 5386 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 5387 ConditionVar, Body.get()); 5388} 5389 5390template<typename Derived> 5391StmtResult 5392TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 5393 // Transform the body 5394 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5395 if (Body.isInvalid()) 5396 return StmtError(); 5397 5398 // Transform the condition 5399 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5400 if (Cond.isInvalid()) 5401 return StmtError(); 5402 5403 if (!getDerived().AlwaysRebuild() && 5404 Cond.get() == S->getCond() && 5405 Body.get() == S->getBody()) 5406 return SemaRef.Owned(S); 5407 5408 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 5409 /*FIXME:*/S->getWhileLoc(), Cond.get(), 5410 S->getRParenLoc()); 5411} 5412 5413template<typename Derived> 5414StmtResult 5415TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 5416 // Transform the initialization statement 5417 StmtResult Init = getDerived().TransformStmt(S->getInit()); 5418 if (Init.isInvalid()) 5419 return StmtError(); 5420 5421 // Transform the condition 5422 ExprResult Cond; 5423 VarDecl *ConditionVar = 0; 5424 if (S->getConditionVariable()) { 5425 ConditionVar 5426 = cast_or_null<VarDecl>( 5427 getDerived().TransformDefinition( 5428 S->getConditionVariable()->getLocation(), 5429 S->getConditionVariable())); 5430 if (!ConditionVar) 5431 return StmtError(); 5432 } else { 5433 Cond = getDerived().TransformExpr(S->getCond()); 5434 5435 if (Cond.isInvalid()) 5436 return StmtError(); 5437 5438 if (S->getCond()) { 5439 // Convert the condition to a boolean value. 5440 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), 5441 Cond.get()); 5442 if (CondE.isInvalid()) 5443 return StmtError(); 5444 5445 Cond = CondE.get(); 5446 } 5447 } 5448 5449 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5450 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5451 return StmtError(); 5452 5453 // Transform the increment 5454 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5455 if (Inc.isInvalid()) 5456 return StmtError(); 5457 5458 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get())); 5459 if (S->getInc() && !FullInc.get()) 5460 return StmtError(); 5461 5462 // Transform the body 5463 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5464 if (Body.isInvalid()) 5465 return StmtError(); 5466 5467 if (!getDerived().AlwaysRebuild() && 5468 Init.get() == S->getInit() && 5469 FullCond.get() == S->getCond() && 5470 Inc.get() == S->getInc() && 5471 Body.get() == S->getBody()) 5472 return SemaRef.Owned(S); 5473 5474 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 5475 Init.get(), FullCond, ConditionVar, 5476 FullInc, S->getRParenLoc(), Body.get()); 5477} 5478 5479template<typename Derived> 5480StmtResult 5481TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 5482 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), 5483 S->getLabel()); 5484 if (!LD) 5485 return StmtError(); 5486 5487 // Goto statements must always be rebuilt, to resolve the label. 5488 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 5489 cast<LabelDecl>(LD)); 5490} 5491 5492template<typename Derived> 5493StmtResult 5494TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 5495 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 5496 if (Target.isInvalid()) 5497 return StmtError(); 5498 Target = SemaRef.MaybeCreateExprWithCleanups(Target.take()); 5499 5500 if (!getDerived().AlwaysRebuild() && 5501 Target.get() == S->getTarget()) 5502 return SemaRef.Owned(S); 5503 5504 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 5505 Target.get()); 5506} 5507 5508template<typename Derived> 5509StmtResult 5510TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 5511 return SemaRef.Owned(S); 5512} 5513 5514template<typename Derived> 5515StmtResult 5516TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 5517 return SemaRef.Owned(S); 5518} 5519 5520template<typename Derived> 5521StmtResult 5522TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 5523 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 5524 if (Result.isInvalid()) 5525 return StmtError(); 5526 5527 // FIXME: We always rebuild the return statement because there is no way 5528 // to tell whether the return type of the function has changed. 5529 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 5530} 5531 5532template<typename Derived> 5533StmtResult 5534TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 5535 bool DeclChanged = false; 5536 SmallVector<Decl *, 4> Decls; 5537 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 5538 D != DEnd; ++D) { 5539 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 5540 *D); 5541 if (!Transformed) 5542 return StmtError(); 5543 5544 if (Transformed != *D) 5545 DeclChanged = true; 5546 5547 Decls.push_back(Transformed); 5548 } 5549 5550 if (!getDerived().AlwaysRebuild() && !DeclChanged) 5551 return SemaRef.Owned(S); 5552 5553 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 5554 S->getStartLoc(), S->getEndLoc()); 5555} 5556 5557template<typename Derived> 5558StmtResult 5559TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { 5560 5561 SmallVector<Expr*, 8> Constraints; 5562 SmallVector<Expr*, 8> Exprs; 5563 SmallVector<IdentifierInfo *, 4> Names; 5564 5565 ExprResult AsmString; 5566 SmallVector<Expr*, 8> Clobbers; 5567 5568 bool ExprsChanged = false; 5569 5570 // Go through the outputs. 5571 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 5572 Names.push_back(S->getOutputIdentifier(I)); 5573 5574 // No need to transform the constraint literal. 5575 Constraints.push_back(S->getOutputConstraintLiteral(I)); 5576 5577 // Transform the output expr. 5578 Expr *OutputExpr = S->getOutputExpr(I); 5579 ExprResult Result = getDerived().TransformExpr(OutputExpr); 5580 if (Result.isInvalid()) 5581 return StmtError(); 5582 5583 ExprsChanged |= Result.get() != OutputExpr; 5584 5585 Exprs.push_back(Result.get()); 5586 } 5587 5588 // Go through the inputs. 5589 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 5590 Names.push_back(S->getInputIdentifier(I)); 5591 5592 // No need to transform the constraint literal. 5593 Constraints.push_back(S->getInputConstraintLiteral(I)); 5594 5595 // Transform the input expr. 5596 Expr *InputExpr = S->getInputExpr(I); 5597 ExprResult Result = getDerived().TransformExpr(InputExpr); 5598 if (Result.isInvalid()) 5599 return StmtError(); 5600 5601 ExprsChanged |= Result.get() != InputExpr; 5602 5603 Exprs.push_back(Result.get()); 5604 } 5605 5606 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 5607 return SemaRef.Owned(S); 5608 5609 // Go through the clobbers. 5610 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 5611 Clobbers.push_back(S->getClobberStringLiteral(I)); 5612 5613 // No need to transform the asm string literal. 5614 AsmString = SemaRef.Owned(S->getAsmString()); 5615 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), 5616 S->isVolatile(), S->getNumOutputs(), 5617 S->getNumInputs(), Names.data(), 5618 Constraints, Exprs, AsmString.get(), 5619 Clobbers, S->getRParenLoc()); 5620} 5621 5622template<typename Derived> 5623StmtResult 5624TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { 5625 ArrayRef<Token> AsmToks = 5626 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); 5627 5628 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(), 5629 AsmToks, S->getEndLoc()); 5630} 5631 5632template<typename Derived> 5633StmtResult 5634TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 5635 // Transform the body of the @try. 5636 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 5637 if (TryBody.isInvalid()) 5638 return StmtError(); 5639 5640 // Transform the @catch statements (if present). 5641 bool AnyCatchChanged = false; 5642 SmallVector<Stmt*, 8> CatchStmts; 5643 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 5644 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 5645 if (Catch.isInvalid()) 5646 return StmtError(); 5647 if (Catch.get() != S->getCatchStmt(I)) 5648 AnyCatchChanged = true; 5649 CatchStmts.push_back(Catch.release()); 5650 } 5651 5652 // Transform the @finally statement (if present). 5653 StmtResult Finally; 5654 if (S->getFinallyStmt()) { 5655 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 5656 if (Finally.isInvalid()) 5657 return StmtError(); 5658 } 5659 5660 // If nothing changed, just retain this statement. 5661 if (!getDerived().AlwaysRebuild() && 5662 TryBody.get() == S->getTryBody() && 5663 !AnyCatchChanged && 5664 Finally.get() == S->getFinallyStmt()) 5665 return SemaRef.Owned(S); 5666 5667 // Build a new statement. 5668 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 5669 CatchStmts, Finally.get()); 5670} 5671 5672template<typename Derived> 5673StmtResult 5674TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 5675 // Transform the @catch parameter, if there is one. 5676 VarDecl *Var = 0; 5677 if (VarDecl *FromVar = S->getCatchParamDecl()) { 5678 TypeSourceInfo *TSInfo = 0; 5679 if (FromVar->getTypeSourceInfo()) { 5680 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 5681 if (!TSInfo) 5682 return StmtError(); 5683 } 5684 5685 QualType T; 5686 if (TSInfo) 5687 T = TSInfo->getType(); 5688 else { 5689 T = getDerived().TransformType(FromVar->getType()); 5690 if (T.isNull()) 5691 return StmtError(); 5692 } 5693 5694 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 5695 if (!Var) 5696 return StmtError(); 5697 } 5698 5699 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 5700 if (Body.isInvalid()) 5701 return StmtError(); 5702 5703 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 5704 S->getRParenLoc(), 5705 Var, Body.get()); 5706} 5707 5708template<typename Derived> 5709StmtResult 5710TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 5711 // Transform the body. 5712 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 5713 if (Body.isInvalid()) 5714 return StmtError(); 5715 5716 // If nothing changed, just retain this statement. 5717 if (!getDerived().AlwaysRebuild() && 5718 Body.get() == S->getFinallyBody()) 5719 return SemaRef.Owned(S); 5720 5721 // Build a new statement. 5722 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 5723 Body.get()); 5724} 5725 5726template<typename Derived> 5727StmtResult 5728TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5729 ExprResult Operand; 5730 if (S->getThrowExpr()) { 5731 Operand = getDerived().TransformExpr(S->getThrowExpr()); 5732 if (Operand.isInvalid()) 5733 return StmtError(); 5734 } 5735 5736 if (!getDerived().AlwaysRebuild() && 5737 Operand.get() == S->getThrowExpr()) 5738 return getSema().Owned(S); 5739 5740 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 5741} 5742 5743template<typename Derived> 5744StmtResult 5745TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 5746 ObjCAtSynchronizedStmt *S) { 5747 // Transform the object we are locking. 5748 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 5749 if (Object.isInvalid()) 5750 return StmtError(); 5751 Object = 5752 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(), 5753 Object.get()); 5754 if (Object.isInvalid()) 5755 return StmtError(); 5756 5757 // Transform the body. 5758 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 5759 if (Body.isInvalid()) 5760 return StmtError(); 5761 5762 // If nothing change, just retain the current statement. 5763 if (!getDerived().AlwaysRebuild() && 5764 Object.get() == S->getSynchExpr() && 5765 Body.get() == S->getSynchBody()) 5766 return SemaRef.Owned(S); 5767 5768 // Build a new statement. 5769 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 5770 Object.get(), Body.get()); 5771} 5772 5773template<typename Derived> 5774StmtResult 5775TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( 5776 ObjCAutoreleasePoolStmt *S) { 5777 // Transform the body. 5778 StmtResult Body = getDerived().TransformStmt(S->getSubStmt()); 5779 if (Body.isInvalid()) 5780 return StmtError(); 5781 5782 // If nothing changed, just retain this statement. 5783 if (!getDerived().AlwaysRebuild() && 5784 Body.get() == S->getSubStmt()) 5785 return SemaRef.Owned(S); 5786 5787 // Build a new statement. 5788 return getDerived().RebuildObjCAutoreleasePoolStmt( 5789 S->getAtLoc(), Body.get()); 5790} 5791 5792template<typename Derived> 5793StmtResult 5794TreeTransform<Derived>::TransformObjCForCollectionStmt( 5795 ObjCForCollectionStmt *S) { 5796 // Transform the element statement. 5797 StmtResult Element = getDerived().TransformStmt(S->getElement()); 5798 if (Element.isInvalid()) 5799 return StmtError(); 5800 5801 // Transform the collection expression. 5802 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 5803 if (Collection.isInvalid()) 5804 return StmtError(); 5805 5806 // Transform the body. 5807 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5808 if (Body.isInvalid()) 5809 return StmtError(); 5810 5811 // If nothing changed, just retain this statement. 5812 if (!getDerived().AlwaysRebuild() && 5813 Element.get() == S->getElement() && 5814 Collection.get() == S->getCollection() && 5815 Body.get() == S->getBody()) 5816 return SemaRef.Owned(S); 5817 5818 // Build a new statement. 5819 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 5820 Element.get(), 5821 Collection.get(), 5822 S->getRParenLoc(), 5823 Body.get()); 5824} 5825 5826 5827template<typename Derived> 5828StmtResult 5829TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 5830 // Transform the exception declaration, if any. 5831 VarDecl *Var = 0; 5832 if (S->getExceptionDecl()) { 5833 VarDecl *ExceptionDecl = S->getExceptionDecl(); 5834 TypeSourceInfo *T = getDerived().TransformType( 5835 ExceptionDecl->getTypeSourceInfo()); 5836 if (!T) 5837 return StmtError(); 5838 5839 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, 5840 ExceptionDecl->getInnerLocStart(), 5841 ExceptionDecl->getLocation(), 5842 ExceptionDecl->getIdentifier()); 5843 if (!Var || Var->isInvalidDecl()) 5844 return StmtError(); 5845 } 5846 5847 // Transform the actual exception handler. 5848 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 5849 if (Handler.isInvalid()) 5850 return StmtError(); 5851 5852 if (!getDerived().AlwaysRebuild() && 5853 !Var && 5854 Handler.get() == S->getHandlerBlock()) 5855 return SemaRef.Owned(S); 5856 5857 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 5858 Var, 5859 Handler.get()); 5860} 5861 5862template<typename Derived> 5863StmtResult 5864TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 5865 // Transform the try block itself. 5866 StmtResult TryBlock 5867 = getDerived().TransformCompoundStmt(S->getTryBlock()); 5868 if (TryBlock.isInvalid()) 5869 return StmtError(); 5870 5871 // Transform the handlers. 5872 bool HandlerChanged = false; 5873 SmallVector<Stmt*, 8> Handlers; 5874 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 5875 StmtResult Handler 5876 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 5877 if (Handler.isInvalid()) 5878 return StmtError(); 5879 5880 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 5881 Handlers.push_back(Handler.takeAs<Stmt>()); 5882 } 5883 5884 if (!getDerived().AlwaysRebuild() && 5885 TryBlock.get() == S->getTryBlock() && 5886 !HandlerChanged) 5887 return SemaRef.Owned(S); 5888 5889 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 5890 Handlers); 5891} 5892 5893template<typename Derived> 5894StmtResult 5895TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { 5896 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt()); 5897 if (Range.isInvalid()) 5898 return StmtError(); 5899 5900 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt()); 5901 if (BeginEnd.isInvalid()) 5902 return StmtError(); 5903 5904 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5905 if (Cond.isInvalid()) 5906 return StmtError(); 5907 if (Cond.get()) 5908 Cond = SemaRef.CheckBooleanCondition(Cond.take(), S->getColonLoc()); 5909 if (Cond.isInvalid()) 5910 return StmtError(); 5911 if (Cond.get()) 5912 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.take()); 5913 5914 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5915 if (Inc.isInvalid()) 5916 return StmtError(); 5917 if (Inc.get()) 5918 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.take()); 5919 5920 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); 5921 if (LoopVar.isInvalid()) 5922 return StmtError(); 5923 5924 StmtResult NewStmt = S; 5925 if (getDerived().AlwaysRebuild() || 5926 Range.get() != S->getRangeStmt() || 5927 BeginEnd.get() != S->getBeginEndStmt() || 5928 Cond.get() != S->getCond() || 5929 Inc.get() != S->getInc() || 5930 LoopVar.get() != S->getLoopVarStmt()) 5931 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 5932 S->getColonLoc(), Range.get(), 5933 BeginEnd.get(), Cond.get(), 5934 Inc.get(), LoopVar.get(), 5935 S->getRParenLoc()); 5936 5937 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5938 if (Body.isInvalid()) 5939 return StmtError(); 5940 5941 // Body has changed but we didn't rebuild the for-range statement. Rebuild 5942 // it now so we have a new statement to attach the body to. 5943 if (Body.get() != S->getBody() && NewStmt.get() == S) 5944 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 5945 S->getColonLoc(), Range.get(), 5946 BeginEnd.get(), Cond.get(), 5947 Inc.get(), LoopVar.get(), 5948 S->getRParenLoc()); 5949 5950 if (NewStmt.get() == S) 5951 return SemaRef.Owned(S); 5952 5953 return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); 5954} 5955 5956template<typename Derived> 5957StmtResult 5958TreeTransform<Derived>::TransformMSDependentExistsStmt( 5959 MSDependentExistsStmt *S) { 5960 // Transform the nested-name-specifier, if any. 5961 NestedNameSpecifierLoc QualifierLoc; 5962 if (S->getQualifierLoc()) { 5963 QualifierLoc 5964 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc()); 5965 if (!QualifierLoc) 5966 return StmtError(); 5967 } 5968 5969 // Transform the declaration name. 5970 DeclarationNameInfo NameInfo = S->getNameInfo(); 5971 if (NameInfo.getName()) { 5972 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 5973 if (!NameInfo.getName()) 5974 return StmtError(); 5975 } 5976 5977 // Check whether anything changed. 5978 if (!getDerived().AlwaysRebuild() && 5979 QualifierLoc == S->getQualifierLoc() && 5980 NameInfo.getName() == S->getNameInfo().getName()) 5981 return S; 5982 5983 // Determine whether this name exists, if we can. 5984 CXXScopeSpec SS; 5985 SS.Adopt(QualifierLoc); 5986 bool Dependent = false; 5987 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/0, SS, NameInfo)) { 5988 case Sema::IER_Exists: 5989 if (S->isIfExists()) 5990 break; 5991 5992 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 5993 5994 case Sema::IER_DoesNotExist: 5995 if (S->isIfNotExists()) 5996 break; 5997 5998 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 5999 6000 case Sema::IER_Dependent: 6001 Dependent = true; 6002 break; 6003 6004 case Sema::IER_Error: 6005 return StmtError(); 6006 } 6007 6008 // We need to continue with the instantiation, so do so now. 6009 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt()); 6010 if (SubStmt.isInvalid()) 6011 return StmtError(); 6012 6013 // If we have resolved the name, just transform to the substatement. 6014 if (!Dependent) 6015 return SubStmt; 6016 6017 // The name is still dependent, so build a dependent expression again. 6018 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(), 6019 S->isIfExists(), 6020 QualifierLoc, 6021 NameInfo, 6022 SubStmt.get()); 6023} 6024 6025template<typename Derived> 6026StmtResult 6027TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { 6028 StmtResult TryBlock; // = getDerived().TransformCompoundStmt(S->getTryBlock()); 6029 if(TryBlock.isInvalid()) return StmtError(); 6030 6031 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler()); 6032 if(!getDerived().AlwaysRebuild() && 6033 TryBlock.get() == S->getTryBlock() && 6034 Handler.get() == S->getHandler()) 6035 return SemaRef.Owned(S); 6036 6037 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), 6038 S->getTryLoc(), 6039 TryBlock.take(), 6040 Handler.take()); 6041} 6042 6043template<typename Derived> 6044StmtResult 6045TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { 6046 StmtResult Block; // = getDerived().TransformCompoundStatement(S->getBlock()); 6047 if(Block.isInvalid()) return StmtError(); 6048 6049 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), 6050 Block.take()); 6051} 6052 6053template<typename Derived> 6054StmtResult 6055TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { 6056 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr()); 6057 if(FilterExpr.isInvalid()) return StmtError(); 6058 6059 StmtResult Block; // = getDerived().TransformCompoundStatement(S->getBlock()); 6060 if(Block.isInvalid()) return StmtError(); 6061 6062 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), 6063 FilterExpr.take(), 6064 Block.take()); 6065} 6066 6067template<typename Derived> 6068StmtResult 6069TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { 6070 if(isa<SEHFinallyStmt>(Handler)) 6071 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler)); 6072 else 6073 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler)); 6074} 6075 6076//===----------------------------------------------------------------------===// 6077// Expression transformation 6078//===----------------------------------------------------------------------===// 6079template<typename Derived> 6080ExprResult 6081TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 6082 return SemaRef.Owned(E); 6083} 6084 6085template<typename Derived> 6086ExprResult 6087TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 6088 NestedNameSpecifierLoc QualifierLoc; 6089 if (E->getQualifierLoc()) { 6090 QualifierLoc 6091 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6092 if (!QualifierLoc) 6093 return ExprError(); 6094 } 6095 6096 ValueDecl *ND 6097 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 6098 E->getDecl())); 6099 if (!ND) 6100 return ExprError(); 6101 6102 DeclarationNameInfo NameInfo = E->getNameInfo(); 6103 if (NameInfo.getName()) { 6104 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6105 if (!NameInfo.getName()) 6106 return ExprError(); 6107 } 6108 6109 if (!getDerived().AlwaysRebuild() && 6110 QualifierLoc == E->getQualifierLoc() && 6111 ND == E->getDecl() && 6112 NameInfo.getName() == E->getDecl()->getDeclName() && 6113 !E->hasExplicitTemplateArgs()) { 6114 6115 // Mark it referenced in the new context regardless. 6116 // FIXME: this is a bit instantiation-specific. 6117 SemaRef.MarkDeclRefReferenced(E); 6118 6119 return SemaRef.Owned(E); 6120 } 6121 6122 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 6123 if (E->hasExplicitTemplateArgs()) { 6124 TemplateArgs = &TransArgs; 6125 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6126 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6127 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6128 E->getNumTemplateArgs(), 6129 TransArgs)) 6130 return ExprError(); 6131 } 6132 6133 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, 6134 TemplateArgs); 6135} 6136 6137template<typename Derived> 6138ExprResult 6139TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 6140 return SemaRef.Owned(E); 6141} 6142 6143template<typename Derived> 6144ExprResult 6145TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 6146 return SemaRef.Owned(E); 6147} 6148 6149template<typename Derived> 6150ExprResult 6151TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 6152 return SemaRef.Owned(E); 6153} 6154 6155template<typename Derived> 6156ExprResult 6157TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 6158 return SemaRef.Owned(E); 6159} 6160 6161template<typename Derived> 6162ExprResult 6163TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 6164 return SemaRef.Owned(E); 6165} 6166 6167template<typename Derived> 6168ExprResult 6169TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { 6170 return SemaRef.MaybeBindToTemporary(E); 6171} 6172 6173template<typename Derived> 6174ExprResult 6175TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { 6176 ExprResult ControllingExpr = 6177 getDerived().TransformExpr(E->getControllingExpr()); 6178 if (ControllingExpr.isInvalid()) 6179 return ExprError(); 6180 6181 SmallVector<Expr *, 4> AssocExprs; 6182 SmallVector<TypeSourceInfo *, 4> AssocTypes; 6183 for (unsigned i = 0; i != E->getNumAssocs(); ++i) { 6184 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i); 6185 if (TS) { 6186 TypeSourceInfo *AssocType = getDerived().TransformType(TS); 6187 if (!AssocType) 6188 return ExprError(); 6189 AssocTypes.push_back(AssocType); 6190 } else { 6191 AssocTypes.push_back(0); 6192 } 6193 6194 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); 6195 if (AssocExpr.isInvalid()) 6196 return ExprError(); 6197 AssocExprs.push_back(AssocExpr.release()); 6198 } 6199 6200 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), 6201 E->getDefaultLoc(), 6202 E->getRParenLoc(), 6203 ControllingExpr.release(), 6204 AssocTypes.data(), 6205 AssocExprs.data(), 6206 E->getNumAssocs()); 6207} 6208 6209template<typename Derived> 6210ExprResult 6211TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 6212 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6213 if (SubExpr.isInvalid()) 6214 return ExprError(); 6215 6216 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6217 return SemaRef.Owned(E); 6218 6219 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 6220 E->getRParen()); 6221} 6222 6223/// \brief The operand of a unary address-of operator has special rules: it's 6224/// allowed to refer to a non-static member of a class even if there's no 'this' 6225/// object available. 6226template<typename Derived> 6227ExprResult 6228TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { 6229 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) 6230 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true); 6231 else 6232 return getDerived().TransformExpr(E); 6233} 6234 6235template<typename Derived> 6236ExprResult 6237TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 6238 ExprResult SubExpr = TransformAddressOfOperand(E->getSubExpr()); 6239 if (SubExpr.isInvalid()) 6240 return ExprError(); 6241 6242 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6243 return SemaRef.Owned(E); 6244 6245 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 6246 E->getOpcode(), 6247 SubExpr.get()); 6248} 6249 6250template<typename Derived> 6251ExprResult 6252TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 6253 // Transform the type. 6254 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 6255 if (!Type) 6256 return ExprError(); 6257 6258 // Transform all of the components into components similar to what the 6259 // parser uses. 6260 // FIXME: It would be slightly more efficient in the non-dependent case to 6261 // just map FieldDecls, rather than requiring the rebuilder to look for 6262 // the fields again. However, __builtin_offsetof is rare enough in 6263 // template code that we don't care. 6264 bool ExprChanged = false; 6265 typedef Sema::OffsetOfComponent Component; 6266 typedef OffsetOfExpr::OffsetOfNode Node; 6267 SmallVector<Component, 4> Components; 6268 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 6269 const Node &ON = E->getComponent(I); 6270 Component Comp; 6271 Comp.isBrackets = true; 6272 Comp.LocStart = ON.getSourceRange().getBegin(); 6273 Comp.LocEnd = ON.getSourceRange().getEnd(); 6274 switch (ON.getKind()) { 6275 case Node::Array: { 6276 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 6277 ExprResult Index = getDerived().TransformExpr(FromIndex); 6278 if (Index.isInvalid()) 6279 return ExprError(); 6280 6281 ExprChanged = ExprChanged || Index.get() != FromIndex; 6282 Comp.isBrackets = true; 6283 Comp.U.E = Index.get(); 6284 break; 6285 } 6286 6287 case Node::Field: 6288 case Node::Identifier: 6289 Comp.isBrackets = false; 6290 Comp.U.IdentInfo = ON.getFieldName(); 6291 if (!Comp.U.IdentInfo) 6292 continue; 6293 6294 break; 6295 6296 case Node::Base: 6297 // Will be recomputed during the rebuild. 6298 continue; 6299 } 6300 6301 Components.push_back(Comp); 6302 } 6303 6304 // If nothing changed, retain the existing expression. 6305 if (!getDerived().AlwaysRebuild() && 6306 Type == E->getTypeSourceInfo() && 6307 !ExprChanged) 6308 return SemaRef.Owned(E); 6309 6310 // Build a new offsetof expression. 6311 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 6312 Components.data(), Components.size(), 6313 E->getRParenLoc()); 6314} 6315 6316template<typename Derived> 6317ExprResult 6318TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 6319 assert(getDerived().AlreadyTransformed(E->getType()) && 6320 "opaque value expression requires transformation"); 6321 return SemaRef.Owned(E); 6322} 6323 6324template<typename Derived> 6325ExprResult 6326TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { 6327 // Rebuild the syntactic form. The original syntactic form has 6328 // opaque-value expressions in it, so strip those away and rebuild 6329 // the result. This is a really awful way of doing this, but the 6330 // better solution (rebuilding the semantic expressions and 6331 // rebinding OVEs as necessary) doesn't work; we'd need 6332 // TreeTransform to not strip away implicit conversions. 6333 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E); 6334 ExprResult result = getDerived().TransformExpr(newSyntacticForm); 6335 if (result.isInvalid()) return ExprError(); 6336 6337 // If that gives us a pseudo-object result back, the pseudo-object 6338 // expression must have been an lvalue-to-rvalue conversion which we 6339 // should reapply. 6340 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) 6341 result = SemaRef.checkPseudoObjectRValue(result.take()); 6342 6343 return result; 6344} 6345 6346template<typename Derived> 6347ExprResult 6348TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( 6349 UnaryExprOrTypeTraitExpr *E) { 6350 if (E->isArgumentType()) { 6351 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 6352 6353 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 6354 if (!NewT) 6355 return ExprError(); 6356 6357 if (!getDerived().AlwaysRebuild() && OldT == NewT) 6358 return SemaRef.Owned(E); 6359 6360 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), 6361 E->getKind(), 6362 E->getSourceRange()); 6363 } 6364 6365 // C++0x [expr.sizeof]p1: 6366 // The operand is either an expression, which is an unevaluated operand 6367 // [...] 6368 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 6369 Sema::ReuseLambdaContextDecl); 6370 6371 ExprResult SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 6372 if (SubExpr.isInvalid()) 6373 return ExprError(); 6374 6375 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 6376 return SemaRef.Owned(E); 6377 6378 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), 6379 E->getOperatorLoc(), 6380 E->getKind(), 6381 E->getSourceRange()); 6382} 6383 6384template<typename Derived> 6385ExprResult 6386TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 6387 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6388 if (LHS.isInvalid()) 6389 return ExprError(); 6390 6391 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6392 if (RHS.isInvalid()) 6393 return ExprError(); 6394 6395 6396 if (!getDerived().AlwaysRebuild() && 6397 LHS.get() == E->getLHS() && 6398 RHS.get() == E->getRHS()) 6399 return SemaRef.Owned(E); 6400 6401 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 6402 /*FIXME:*/E->getLHS()->getLocStart(), 6403 RHS.get(), 6404 E->getRBracketLoc()); 6405} 6406 6407template<typename Derived> 6408ExprResult 6409TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 6410 // Transform the callee. 6411 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6412 if (Callee.isInvalid()) 6413 return ExprError(); 6414 6415 // Transform arguments. 6416 bool ArgChanged = false; 6417 SmallVector<Expr*, 8> Args; 6418 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6419 &ArgChanged)) 6420 return ExprError(); 6421 6422 if (!getDerived().AlwaysRebuild() && 6423 Callee.get() == E->getCallee() && 6424 !ArgChanged) 6425 return SemaRef.MaybeBindToTemporary(E); 6426 6427 // FIXME: Wrong source location information for the '('. 6428 SourceLocation FakeLParenLoc 6429 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 6430 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 6431 Args, 6432 E->getRParenLoc()); 6433} 6434 6435template<typename Derived> 6436ExprResult 6437TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 6438 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6439 if (Base.isInvalid()) 6440 return ExprError(); 6441 6442 NestedNameSpecifierLoc QualifierLoc; 6443 if (E->hasQualifier()) { 6444 QualifierLoc 6445 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6446 6447 if (!QualifierLoc) 6448 return ExprError(); 6449 } 6450 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 6451 6452 ValueDecl *Member 6453 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 6454 E->getMemberDecl())); 6455 if (!Member) 6456 return ExprError(); 6457 6458 NamedDecl *FoundDecl = E->getFoundDecl(); 6459 if (FoundDecl == E->getMemberDecl()) { 6460 FoundDecl = Member; 6461 } else { 6462 FoundDecl = cast_or_null<NamedDecl>( 6463 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 6464 if (!FoundDecl) 6465 return ExprError(); 6466 } 6467 6468 if (!getDerived().AlwaysRebuild() && 6469 Base.get() == E->getBase() && 6470 QualifierLoc == E->getQualifierLoc() && 6471 Member == E->getMemberDecl() && 6472 FoundDecl == E->getFoundDecl() && 6473 !E->hasExplicitTemplateArgs()) { 6474 6475 // Mark it referenced in the new context regardless. 6476 // FIXME: this is a bit instantiation-specific. 6477 SemaRef.MarkMemberReferenced(E); 6478 6479 return SemaRef.Owned(E); 6480 } 6481 6482 TemplateArgumentListInfo TransArgs; 6483 if (E->hasExplicitTemplateArgs()) { 6484 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6485 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6486 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6487 E->getNumTemplateArgs(), 6488 TransArgs)) 6489 return ExprError(); 6490 } 6491 6492 // FIXME: Bogus source location for the operator 6493 SourceLocation FakeOperatorLoc 6494 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 6495 6496 // FIXME: to do this check properly, we will need to preserve the 6497 // first-qualifier-in-scope here, just in case we had a dependent 6498 // base (and therefore couldn't do the check) and a 6499 // nested-name-qualifier (and therefore could do the lookup). 6500 NamedDecl *FirstQualifierInScope = 0; 6501 6502 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 6503 E->isArrow(), 6504 QualifierLoc, 6505 TemplateKWLoc, 6506 E->getMemberNameInfo(), 6507 Member, 6508 FoundDecl, 6509 (E->hasExplicitTemplateArgs() 6510 ? &TransArgs : 0), 6511 FirstQualifierInScope); 6512} 6513 6514template<typename Derived> 6515ExprResult 6516TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 6517 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6518 if (LHS.isInvalid()) 6519 return ExprError(); 6520 6521 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6522 if (RHS.isInvalid()) 6523 return ExprError(); 6524 6525 if (!getDerived().AlwaysRebuild() && 6526 LHS.get() == E->getLHS() && 6527 RHS.get() == E->getRHS()) 6528 return SemaRef.Owned(E); 6529 6530 Sema::FPContractStateRAII FPContractState(getSema()); 6531 getSema().FPFeatures.fp_contract = E->isFPContractable(); 6532 6533 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 6534 LHS.get(), RHS.get()); 6535} 6536 6537template<typename Derived> 6538ExprResult 6539TreeTransform<Derived>::TransformCompoundAssignOperator( 6540 CompoundAssignOperator *E) { 6541 return getDerived().TransformBinaryOperator(E); 6542} 6543 6544template<typename Derived> 6545ExprResult TreeTransform<Derived>:: 6546TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { 6547 // Just rebuild the common and RHS expressions and see whether we 6548 // get any changes. 6549 6550 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); 6551 if (commonExpr.isInvalid()) 6552 return ExprError(); 6553 6554 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); 6555 if (rhs.isInvalid()) 6556 return ExprError(); 6557 6558 if (!getDerived().AlwaysRebuild() && 6559 commonExpr.get() == e->getCommon() && 6560 rhs.get() == e->getFalseExpr()) 6561 return SemaRef.Owned(e); 6562 6563 return getDerived().RebuildConditionalOperator(commonExpr.take(), 6564 e->getQuestionLoc(), 6565 0, 6566 e->getColonLoc(), 6567 rhs.get()); 6568} 6569 6570template<typename Derived> 6571ExprResult 6572TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 6573 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 6574 if (Cond.isInvalid()) 6575 return ExprError(); 6576 6577 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6578 if (LHS.isInvalid()) 6579 return ExprError(); 6580 6581 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6582 if (RHS.isInvalid()) 6583 return ExprError(); 6584 6585 if (!getDerived().AlwaysRebuild() && 6586 Cond.get() == E->getCond() && 6587 LHS.get() == E->getLHS() && 6588 RHS.get() == E->getRHS()) 6589 return SemaRef.Owned(E); 6590 6591 return getDerived().RebuildConditionalOperator(Cond.get(), 6592 E->getQuestionLoc(), 6593 LHS.get(), 6594 E->getColonLoc(), 6595 RHS.get()); 6596} 6597 6598template<typename Derived> 6599ExprResult 6600TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 6601 // Implicit casts are eliminated during transformation, since they 6602 // will be recomputed by semantic analysis after transformation. 6603 return getDerived().TransformExpr(E->getSubExprAsWritten()); 6604} 6605 6606template<typename Derived> 6607ExprResult 6608TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 6609 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 6610 if (!Type) 6611 return ExprError(); 6612 6613 ExprResult SubExpr 6614 = getDerived().TransformExpr(E->getSubExprAsWritten()); 6615 if (SubExpr.isInvalid()) 6616 return ExprError(); 6617 6618 if (!getDerived().AlwaysRebuild() && 6619 Type == E->getTypeInfoAsWritten() && 6620 SubExpr.get() == E->getSubExpr()) 6621 return SemaRef.Owned(E); 6622 6623 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 6624 Type, 6625 E->getRParenLoc(), 6626 SubExpr.get()); 6627} 6628 6629template<typename Derived> 6630ExprResult 6631TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 6632 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 6633 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 6634 if (!NewT) 6635 return ExprError(); 6636 6637 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 6638 if (Init.isInvalid()) 6639 return ExprError(); 6640 6641 if (!getDerived().AlwaysRebuild() && 6642 OldT == NewT && 6643 Init.get() == E->getInitializer()) 6644 return SemaRef.MaybeBindToTemporary(E); 6645 6646 // Note: the expression type doesn't necessarily match the 6647 // type-as-written, but that's okay, because it should always be 6648 // derivable from the initializer. 6649 6650 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 6651 /*FIXME:*/E->getInitializer()->getLocEnd(), 6652 Init.get()); 6653} 6654 6655template<typename Derived> 6656ExprResult 6657TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 6658 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6659 if (Base.isInvalid()) 6660 return ExprError(); 6661 6662 if (!getDerived().AlwaysRebuild() && 6663 Base.get() == E->getBase()) 6664 return SemaRef.Owned(E); 6665 6666 // FIXME: Bad source location 6667 SourceLocation FakeOperatorLoc 6668 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 6669 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 6670 E->getAccessorLoc(), 6671 E->getAccessor()); 6672} 6673 6674template<typename Derived> 6675ExprResult 6676TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 6677 bool InitChanged = false; 6678 6679 SmallVector<Expr*, 4> Inits; 6680 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 6681 Inits, &InitChanged)) 6682 return ExprError(); 6683 6684 if (!getDerived().AlwaysRebuild() && !InitChanged) 6685 return SemaRef.Owned(E); 6686 6687 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, 6688 E->getRBraceLoc(), E->getType()); 6689} 6690 6691template<typename Derived> 6692ExprResult 6693TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 6694 Designation Desig; 6695 6696 // transform the initializer value 6697 ExprResult Init = getDerived().TransformExpr(E->getInit()); 6698 if (Init.isInvalid()) 6699 return ExprError(); 6700 6701 // transform the designators. 6702 SmallVector<Expr*, 4> ArrayExprs; 6703 bool ExprChanged = false; 6704 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 6705 DEnd = E->designators_end(); 6706 D != DEnd; ++D) { 6707 if (D->isFieldDesignator()) { 6708 Desig.AddDesignator(Designator::getField(D->getFieldName(), 6709 D->getDotLoc(), 6710 D->getFieldLoc())); 6711 continue; 6712 } 6713 6714 if (D->isArrayDesignator()) { 6715 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 6716 if (Index.isInvalid()) 6717 return ExprError(); 6718 6719 Desig.AddDesignator(Designator::getArray(Index.get(), 6720 D->getLBracketLoc())); 6721 6722 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 6723 ArrayExprs.push_back(Index.release()); 6724 continue; 6725 } 6726 6727 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 6728 ExprResult Start 6729 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 6730 if (Start.isInvalid()) 6731 return ExprError(); 6732 6733 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 6734 if (End.isInvalid()) 6735 return ExprError(); 6736 6737 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 6738 End.get(), 6739 D->getLBracketLoc(), 6740 D->getEllipsisLoc())); 6741 6742 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 6743 End.get() != E->getArrayRangeEnd(*D); 6744 6745 ArrayExprs.push_back(Start.release()); 6746 ArrayExprs.push_back(End.release()); 6747 } 6748 6749 if (!getDerived().AlwaysRebuild() && 6750 Init.get() == E->getInit() && 6751 !ExprChanged) 6752 return SemaRef.Owned(E); 6753 6754 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, 6755 E->getEqualOrColonLoc(), 6756 E->usesGNUSyntax(), Init.get()); 6757} 6758 6759template<typename Derived> 6760ExprResult 6761TreeTransform<Derived>::TransformImplicitValueInitExpr( 6762 ImplicitValueInitExpr *E) { 6763 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 6764 6765 // FIXME: Will we ever have proper type location here? Will we actually 6766 // need to transform the type? 6767 QualType T = getDerived().TransformType(E->getType()); 6768 if (T.isNull()) 6769 return ExprError(); 6770 6771 if (!getDerived().AlwaysRebuild() && 6772 T == E->getType()) 6773 return SemaRef.Owned(E); 6774 6775 return getDerived().RebuildImplicitValueInitExpr(T); 6776} 6777 6778template<typename Derived> 6779ExprResult 6780TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 6781 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 6782 if (!TInfo) 6783 return ExprError(); 6784 6785 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6786 if (SubExpr.isInvalid()) 6787 return ExprError(); 6788 6789 if (!getDerived().AlwaysRebuild() && 6790 TInfo == E->getWrittenTypeInfo() && 6791 SubExpr.get() == E->getSubExpr()) 6792 return SemaRef.Owned(E); 6793 6794 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 6795 TInfo, E->getRParenLoc()); 6796} 6797 6798template<typename Derived> 6799ExprResult 6800TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 6801 bool ArgumentChanged = false; 6802 SmallVector<Expr*, 4> Inits; 6803 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 6804 &ArgumentChanged)) 6805 return ExprError(); 6806 6807 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 6808 Inits, 6809 E->getRParenLoc()); 6810} 6811 6812/// \brief Transform an address-of-label expression. 6813/// 6814/// By default, the transformation of an address-of-label expression always 6815/// rebuilds the expression, so that the label identifier can be resolved to 6816/// the corresponding label statement by semantic analysis. 6817template<typename Derived> 6818ExprResult 6819TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 6820 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), 6821 E->getLabel()); 6822 if (!LD) 6823 return ExprError(); 6824 6825 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 6826 cast<LabelDecl>(LD)); 6827} 6828 6829template<typename Derived> 6830ExprResult 6831TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 6832 SemaRef.ActOnStartStmtExpr(); 6833 StmtResult SubStmt 6834 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 6835 if (SubStmt.isInvalid()) { 6836 SemaRef.ActOnStmtExprError(); 6837 return ExprError(); 6838 } 6839 6840 if (!getDerived().AlwaysRebuild() && 6841 SubStmt.get() == E->getSubStmt()) { 6842 // Calling this an 'error' is unintuitive, but it does the right thing. 6843 SemaRef.ActOnStmtExprError(); 6844 return SemaRef.MaybeBindToTemporary(E); 6845 } 6846 6847 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 6848 SubStmt.get(), 6849 E->getRParenLoc()); 6850} 6851 6852template<typename Derived> 6853ExprResult 6854TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 6855 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 6856 if (Cond.isInvalid()) 6857 return ExprError(); 6858 6859 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6860 if (LHS.isInvalid()) 6861 return ExprError(); 6862 6863 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6864 if (RHS.isInvalid()) 6865 return ExprError(); 6866 6867 if (!getDerived().AlwaysRebuild() && 6868 Cond.get() == E->getCond() && 6869 LHS.get() == E->getLHS() && 6870 RHS.get() == E->getRHS()) 6871 return SemaRef.Owned(E); 6872 6873 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 6874 Cond.get(), LHS.get(), RHS.get(), 6875 E->getRParenLoc()); 6876} 6877 6878template<typename Derived> 6879ExprResult 6880TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 6881 return SemaRef.Owned(E); 6882} 6883 6884template<typename Derived> 6885ExprResult 6886TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 6887 switch (E->getOperator()) { 6888 case OO_New: 6889 case OO_Delete: 6890 case OO_Array_New: 6891 case OO_Array_Delete: 6892 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 6893 6894 case OO_Call: { 6895 // This is a call to an object's operator(). 6896 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 6897 6898 // Transform the object itself. 6899 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 6900 if (Object.isInvalid()) 6901 return ExprError(); 6902 6903 // FIXME: Poor location information 6904 SourceLocation FakeLParenLoc 6905 = SemaRef.PP.getLocForEndOfToken( 6906 static_cast<Expr *>(Object.get())->getLocEnd()); 6907 6908 // Transform the call arguments. 6909 SmallVector<Expr*, 8> Args; 6910 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 6911 Args)) 6912 return ExprError(); 6913 6914 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 6915 Args, 6916 E->getLocEnd()); 6917 } 6918 6919#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 6920 case OO_##Name: 6921#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 6922#include "clang/Basic/OperatorKinds.def" 6923 case OO_Subscript: 6924 // Handled below. 6925 break; 6926 6927 case OO_Conditional: 6928 llvm_unreachable("conditional operator is not actually overloadable"); 6929 6930 case OO_None: 6931 case NUM_OVERLOADED_OPERATORS: 6932 llvm_unreachable("not an overloaded operator?"); 6933 } 6934 6935 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6936 if (Callee.isInvalid()) 6937 return ExprError(); 6938 6939 ExprResult First; 6940 if (E->getOperator() == OO_Amp) 6941 First = getDerived().TransformAddressOfOperand(E->getArg(0)); 6942 else 6943 First = getDerived().TransformExpr(E->getArg(0)); 6944 if (First.isInvalid()) 6945 return ExprError(); 6946 6947 ExprResult Second; 6948 if (E->getNumArgs() == 2) { 6949 Second = getDerived().TransformExpr(E->getArg(1)); 6950 if (Second.isInvalid()) 6951 return ExprError(); 6952 } 6953 6954 if (!getDerived().AlwaysRebuild() && 6955 Callee.get() == E->getCallee() && 6956 First.get() == E->getArg(0) && 6957 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 6958 return SemaRef.MaybeBindToTemporary(E); 6959 6960 Sema::FPContractStateRAII FPContractState(getSema()); 6961 getSema().FPFeatures.fp_contract = E->isFPContractable(); 6962 6963 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 6964 E->getOperatorLoc(), 6965 Callee.get(), 6966 First.get(), 6967 Second.get()); 6968} 6969 6970template<typename Derived> 6971ExprResult 6972TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 6973 return getDerived().TransformCallExpr(E); 6974} 6975 6976template<typename Derived> 6977ExprResult 6978TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 6979 // Transform the callee. 6980 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6981 if (Callee.isInvalid()) 6982 return ExprError(); 6983 6984 // Transform exec config. 6985 ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); 6986 if (EC.isInvalid()) 6987 return ExprError(); 6988 6989 // Transform arguments. 6990 bool ArgChanged = false; 6991 SmallVector<Expr*, 8> Args; 6992 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6993 &ArgChanged)) 6994 return ExprError(); 6995 6996 if (!getDerived().AlwaysRebuild() && 6997 Callee.get() == E->getCallee() && 6998 !ArgChanged) 6999 return SemaRef.MaybeBindToTemporary(E); 7000 7001 // FIXME: Wrong source location information for the '('. 7002 SourceLocation FakeLParenLoc 7003 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 7004 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 7005 Args, 7006 E->getRParenLoc(), EC.get()); 7007} 7008 7009template<typename Derived> 7010ExprResult 7011TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 7012 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7013 if (!Type) 7014 return ExprError(); 7015 7016 ExprResult SubExpr 7017 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7018 if (SubExpr.isInvalid()) 7019 return ExprError(); 7020 7021 if (!getDerived().AlwaysRebuild() && 7022 Type == E->getTypeInfoAsWritten() && 7023 SubExpr.get() == E->getSubExpr()) 7024 return SemaRef.Owned(E); 7025 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 7026 E->getStmtClass(), 7027 E->getAngleBrackets().getBegin(), 7028 Type, 7029 E->getAngleBrackets().getEnd(), 7030 // FIXME. this should be '(' location 7031 E->getAngleBrackets().getEnd(), 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 CXXScopeSpec EmptySS; 7463 ScopeTypeInfo = getDerived().TransformTypeInObjectScope( 7464 E->getScopeTypeInfo(), ObjectType, 0, EmptySS); 7465 if (!ScopeTypeInfo) 7466 return ExprError(); 7467 } 7468 7469 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 7470 E->getOperatorLoc(), 7471 E->isArrow(), 7472 SS, 7473 ScopeTypeInfo, 7474 E->getColonColonLoc(), 7475 E->getTildeLoc(), 7476 Destroyed); 7477} 7478 7479template<typename Derived> 7480ExprResult 7481TreeTransform<Derived>::TransformUnresolvedLookupExpr( 7482 UnresolvedLookupExpr *Old) { 7483 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 7484 Sema::LookupOrdinaryName); 7485 7486 // Transform all the decls. 7487 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 7488 E = Old->decls_end(); I != E; ++I) { 7489 NamedDecl *InstD = static_cast<NamedDecl*>( 7490 getDerived().TransformDecl(Old->getNameLoc(), 7491 *I)); 7492 if (!InstD) { 7493 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 7494 // This can happen because of dependent hiding. 7495 if (isa<UsingShadowDecl>(*I)) 7496 continue; 7497 else 7498 return ExprError(); 7499 } 7500 7501 // Expand using declarations. 7502 if (isa<UsingDecl>(InstD)) { 7503 UsingDecl *UD = cast<UsingDecl>(InstD); 7504 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 7505 E = UD->shadow_end(); I != E; ++I) 7506 R.addDecl(*I); 7507 continue; 7508 } 7509 7510 R.addDecl(InstD); 7511 } 7512 7513 // Resolve a kind, but don't do any further analysis. If it's 7514 // ambiguous, the callee needs to deal with it. 7515 R.resolveKind(); 7516 7517 // Rebuild the nested-name qualifier, if present. 7518 CXXScopeSpec SS; 7519 if (Old->getQualifierLoc()) { 7520 NestedNameSpecifierLoc QualifierLoc 7521 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 7522 if (!QualifierLoc) 7523 return ExprError(); 7524 7525 SS.Adopt(QualifierLoc); 7526 } 7527 7528 if (Old->getNamingClass()) { 7529 CXXRecordDecl *NamingClass 7530 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 7531 Old->getNameLoc(), 7532 Old->getNamingClass())); 7533 if (!NamingClass) 7534 return ExprError(); 7535 7536 R.setNamingClass(NamingClass); 7537 } 7538 7539 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 7540 7541 // If we have neither explicit template arguments, nor the template keyword, 7542 // it's a normal declaration name. 7543 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) 7544 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 7545 7546 // If we have template arguments, rebuild them, then rebuild the 7547 // templateid expression. 7548 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 7549 if (Old->hasExplicitTemplateArgs() && 7550 getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 7551 Old->getNumTemplateArgs(), 7552 TransArgs)) 7553 return ExprError(); 7554 7555 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R, 7556 Old->requiresADL(), &TransArgs); 7557} 7558 7559template<typename Derived> 7560ExprResult 7561TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 7562 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 7563 if (!T) 7564 return ExprError(); 7565 7566 if (!getDerived().AlwaysRebuild() && 7567 T == E->getQueriedTypeSourceInfo()) 7568 return SemaRef.Owned(E); 7569 7570 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 7571 E->getLocStart(), 7572 T, 7573 E->getLocEnd()); 7574} 7575 7576template<typename Derived> 7577ExprResult 7578TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 7579 TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); 7580 if (!LhsT) 7581 return ExprError(); 7582 7583 TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); 7584 if (!RhsT) 7585 return ExprError(); 7586 7587 if (!getDerived().AlwaysRebuild() && 7588 LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) 7589 return SemaRef.Owned(E); 7590 7591 return getDerived().RebuildBinaryTypeTrait(E->getTrait(), 7592 E->getLocStart(), 7593 LhsT, RhsT, 7594 E->getLocEnd()); 7595} 7596 7597template<typename Derived> 7598ExprResult 7599TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { 7600 bool ArgChanged = false; 7601 SmallVector<TypeSourceInfo *, 4> Args; 7602 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 7603 TypeSourceInfo *From = E->getArg(I); 7604 TypeLoc FromTL = From->getTypeLoc(); 7605 if (!FromTL.getAs<PackExpansionTypeLoc>()) { 7606 TypeLocBuilder TLB; 7607 TLB.reserve(FromTL.getFullDataSize()); 7608 QualType To = getDerived().TransformType(TLB, FromTL); 7609 if (To.isNull()) 7610 return ExprError(); 7611 7612 if (To == From->getType()) 7613 Args.push_back(From); 7614 else { 7615 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7616 ArgChanged = true; 7617 } 7618 continue; 7619 } 7620 7621 ArgChanged = true; 7622 7623 // We have a pack expansion. Instantiate it. 7624 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>(); 7625 TypeLoc PatternTL = ExpansionTL.getPatternLoc(); 7626 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 7627 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded); 7628 7629 // Determine whether the set of unexpanded parameter packs can and should 7630 // be expanded. 7631 bool Expand = true; 7632 bool RetainExpansion = false; 7633 Optional<unsigned> OrigNumExpansions = 7634 ExpansionTL.getTypePtr()->getNumExpansions(); 7635 Optional<unsigned> NumExpansions = OrigNumExpansions; 7636 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 7637 PatternTL.getSourceRange(), 7638 Unexpanded, 7639 Expand, RetainExpansion, 7640 NumExpansions)) 7641 return ExprError(); 7642 7643 if (!Expand) { 7644 // The transform has determined that we should perform a simple 7645 // transformation on the pack expansion, producing another pack 7646 // expansion. 7647 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 7648 7649 TypeLocBuilder TLB; 7650 TLB.reserve(From->getTypeLoc().getFullDataSize()); 7651 7652 QualType To = getDerived().TransformType(TLB, PatternTL); 7653 if (To.isNull()) 7654 return ExprError(); 7655 7656 To = getDerived().RebuildPackExpansionType(To, 7657 PatternTL.getSourceRange(), 7658 ExpansionTL.getEllipsisLoc(), 7659 NumExpansions); 7660 if (To.isNull()) 7661 return ExprError(); 7662 7663 PackExpansionTypeLoc ToExpansionTL 7664 = TLB.push<PackExpansionTypeLoc>(To); 7665 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 7666 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7667 continue; 7668 } 7669 7670 // Expand the pack expansion by substituting for each argument in the 7671 // pack(s). 7672 for (unsigned I = 0; I != *NumExpansions; ++I) { 7673 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 7674 TypeLocBuilder TLB; 7675 TLB.reserve(PatternTL.getFullDataSize()); 7676 QualType To = getDerived().TransformType(TLB, PatternTL); 7677 if (To.isNull()) 7678 return ExprError(); 7679 7680 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7681 } 7682 7683 if (!RetainExpansion) 7684 continue; 7685 7686 // If we're supposed to retain a pack expansion, do so by temporarily 7687 // forgetting the partially-substituted parameter pack. 7688 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 7689 7690 TypeLocBuilder TLB; 7691 TLB.reserve(From->getTypeLoc().getFullDataSize()); 7692 7693 QualType To = getDerived().TransformType(TLB, PatternTL); 7694 if (To.isNull()) 7695 return ExprError(); 7696 7697 To = getDerived().RebuildPackExpansionType(To, 7698 PatternTL.getSourceRange(), 7699 ExpansionTL.getEllipsisLoc(), 7700 NumExpansions); 7701 if (To.isNull()) 7702 return ExprError(); 7703 7704 PackExpansionTypeLoc ToExpansionTL 7705 = TLB.push<PackExpansionTypeLoc>(To); 7706 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 7707 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7708 } 7709 7710 if (!getDerived().AlwaysRebuild() && !ArgChanged) 7711 return SemaRef.Owned(E); 7712 7713 return getDerived().RebuildTypeTrait(E->getTrait(), 7714 E->getLocStart(), 7715 Args, 7716 E->getLocEnd()); 7717} 7718 7719template<typename Derived> 7720ExprResult 7721TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 7722 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 7723 if (!T) 7724 return ExprError(); 7725 7726 if (!getDerived().AlwaysRebuild() && 7727 T == E->getQueriedTypeSourceInfo()) 7728 return SemaRef.Owned(E); 7729 7730 ExprResult SubExpr; 7731 { 7732 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7733 SubExpr = getDerived().TransformExpr(E->getDimensionExpression()); 7734 if (SubExpr.isInvalid()) 7735 return ExprError(); 7736 7737 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression()) 7738 return SemaRef.Owned(E); 7739 } 7740 7741 return getDerived().RebuildArrayTypeTrait(E->getTrait(), 7742 E->getLocStart(), 7743 T, 7744 SubExpr.get(), 7745 E->getLocEnd()); 7746} 7747 7748template<typename Derived> 7749ExprResult 7750TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { 7751 ExprResult SubExpr; 7752 { 7753 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7754 SubExpr = getDerived().TransformExpr(E->getQueriedExpression()); 7755 if (SubExpr.isInvalid()) 7756 return ExprError(); 7757 7758 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) 7759 return SemaRef.Owned(E); 7760 } 7761 7762 return getDerived().RebuildExpressionTrait( 7763 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd()); 7764} 7765 7766template<typename Derived> 7767ExprResult 7768TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 7769 DependentScopeDeclRefExpr *E) { 7770 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand*/false); 7771} 7772 7773template<typename Derived> 7774ExprResult 7775TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 7776 DependentScopeDeclRefExpr *E, 7777 bool IsAddressOfOperand) { 7778 NestedNameSpecifierLoc QualifierLoc 7779 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 7780 if (!QualifierLoc) 7781 return ExprError(); 7782 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 7783 7784 // TODO: If this is a conversion-function-id, verify that the 7785 // destination type name (if present) resolves the same way after 7786 // instantiation as it did in the local scope. 7787 7788 DeclarationNameInfo NameInfo 7789 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 7790 if (!NameInfo.getName()) 7791 return ExprError(); 7792 7793 if (!E->hasExplicitTemplateArgs()) { 7794 if (!getDerived().AlwaysRebuild() && 7795 QualifierLoc == E->getQualifierLoc() && 7796 // Note: it is sufficient to compare the Name component of NameInfo: 7797 // if name has not changed, DNLoc has not changed either. 7798 NameInfo.getName() == E->getDeclName()) 7799 return SemaRef.Owned(E); 7800 7801 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 7802 TemplateKWLoc, 7803 NameInfo, 7804 /*TemplateArgs*/ 0, 7805 IsAddressOfOperand); 7806 } 7807 7808 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 7809 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 7810 E->getNumTemplateArgs(), 7811 TransArgs)) 7812 return ExprError(); 7813 7814 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 7815 TemplateKWLoc, 7816 NameInfo, 7817 &TransArgs, 7818 IsAddressOfOperand); 7819} 7820 7821template<typename Derived> 7822ExprResult 7823TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 7824 // CXXConstructExprs other than for list-initialization and 7825 // CXXTemporaryObjectExpr are always implicit, so when we have 7826 // a 1-argument construction we just transform that argument. 7827 if ((E->getNumArgs() == 1 || 7828 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) && 7829 (!getDerived().DropCallArgument(E->getArg(0))) && 7830 !E->isListInitialization()) 7831 return getDerived().TransformExpr(E->getArg(0)); 7832 7833 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 7834 7835 QualType T = getDerived().TransformType(E->getType()); 7836 if (T.isNull()) 7837 return ExprError(); 7838 7839 CXXConstructorDecl *Constructor 7840 = cast_or_null<CXXConstructorDecl>( 7841 getDerived().TransformDecl(E->getLocStart(), 7842 E->getConstructor())); 7843 if (!Constructor) 7844 return ExprError(); 7845 7846 bool ArgumentChanged = false; 7847 SmallVector<Expr*, 8> Args; 7848 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7849 &ArgumentChanged)) 7850 return ExprError(); 7851 7852 if (!getDerived().AlwaysRebuild() && 7853 T == E->getType() && 7854 Constructor == E->getConstructor() && 7855 !ArgumentChanged) { 7856 // Mark the constructor as referenced. 7857 // FIXME: Instantiation-specific 7858 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 7859 return SemaRef.Owned(E); 7860 } 7861 7862 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 7863 Constructor, E->isElidable(), 7864 Args, 7865 E->hadMultipleCandidates(), 7866 E->isListInitialization(), 7867 E->requiresZeroInitialization(), 7868 E->getConstructionKind(), 7869 E->getParenRange()); 7870} 7871 7872/// \brief Transform a C++ temporary-binding expression. 7873/// 7874/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 7875/// transform the subexpression and return that. 7876template<typename Derived> 7877ExprResult 7878TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 7879 return getDerived().TransformExpr(E->getSubExpr()); 7880} 7881 7882/// \brief Transform a C++ expression that contains cleanups that should 7883/// be run after the expression is evaluated. 7884/// 7885/// Since ExprWithCleanups nodes are implicitly generated, we 7886/// just transform the subexpression and return that. 7887template<typename Derived> 7888ExprResult 7889TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 7890 return getDerived().TransformExpr(E->getSubExpr()); 7891} 7892 7893template<typename Derived> 7894ExprResult 7895TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 7896 CXXTemporaryObjectExpr *E) { 7897 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 7898 if (!T) 7899 return ExprError(); 7900 7901 CXXConstructorDecl *Constructor 7902 = cast_or_null<CXXConstructorDecl>( 7903 getDerived().TransformDecl(E->getLocStart(), 7904 E->getConstructor())); 7905 if (!Constructor) 7906 return ExprError(); 7907 7908 bool ArgumentChanged = false; 7909 SmallVector<Expr*, 8> Args; 7910 Args.reserve(E->getNumArgs()); 7911 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7912 &ArgumentChanged)) 7913 return ExprError(); 7914 7915 if (!getDerived().AlwaysRebuild() && 7916 T == E->getTypeSourceInfo() && 7917 Constructor == E->getConstructor() && 7918 !ArgumentChanged) { 7919 // FIXME: Instantiation-specific 7920 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 7921 return SemaRef.MaybeBindToTemporary(E); 7922 } 7923 7924 // FIXME: Pass in E->isListInitialization(). 7925 return getDerived().RebuildCXXTemporaryObjectExpr(T, 7926 /*FIXME:*/T->getTypeLoc().getEndLoc(), 7927 Args, 7928 E->getLocEnd()); 7929} 7930 7931template<typename Derived> 7932ExprResult 7933TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { 7934 // Transform the type of the lambda parameters and start the definition of 7935 // the lambda itself. 7936 TypeSourceInfo *MethodTy 7937 = TransformType(E->getCallOperator()->getTypeSourceInfo()); 7938 if (!MethodTy) 7939 return ExprError(); 7940 7941 // Create the local class that will describe the lambda. 7942 CXXRecordDecl *Class 7943 = getSema().createLambdaClosureType(E->getIntroducerRange(), 7944 MethodTy, 7945 /*KnownDependent=*/false); 7946 getDerived().transformedLocalDecl(E->getLambdaClass(), Class); 7947 7948 // Transform lambda parameters. 7949 SmallVector<QualType, 4> ParamTypes; 7950 SmallVector<ParmVarDecl *, 4> Params; 7951 if (getDerived().TransformFunctionTypeParams(E->getLocStart(), 7952 E->getCallOperator()->param_begin(), 7953 E->getCallOperator()->param_size(), 7954 0, ParamTypes, &Params)) 7955 return ExprError(); 7956 7957 // Build the call operator. 7958 CXXMethodDecl *CallOperator 7959 = getSema().startLambdaDefinition(Class, E->getIntroducerRange(), 7960 MethodTy, 7961 E->getCallOperator()->getLocEnd(), 7962 Params); 7963 getDerived().transformAttrs(E->getCallOperator(), CallOperator); 7964 7965 return getDerived().TransformLambdaScope(E, CallOperator); 7966} 7967 7968template<typename Derived> 7969ExprResult 7970TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, 7971 CXXMethodDecl *CallOperator) { 7972 // Introduce the context of the call operator. 7973 Sema::ContextRAII SavedContext(getSema(), CallOperator); 7974 7975 // Enter the scope of the lambda. 7976 sema::LambdaScopeInfo *LSI 7977 = getSema().enterLambdaScope(CallOperator, E->getIntroducerRange(), 7978 E->getCaptureDefault(), 7979 E->hasExplicitParameters(), 7980 E->hasExplicitResultType(), 7981 E->isMutable()); 7982 7983 // Transform captures. 7984 bool Invalid = false; 7985 bool FinishedExplicitCaptures = false; 7986 for (LambdaExpr::capture_iterator C = E->capture_begin(), 7987 CEnd = E->capture_end(); 7988 C != CEnd; ++C) { 7989 // When we hit the first implicit capture, tell Sema that we've finished 7990 // the list of explicit captures. 7991 if (!FinishedExplicitCaptures && C->isImplicit()) { 7992 getSema().finishLambdaExplicitCaptures(LSI); 7993 FinishedExplicitCaptures = true; 7994 } 7995 7996 // Capturing 'this' is trivial. 7997 if (C->capturesThis()) { 7998 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit()); 7999 continue; 8000 } 8001 8002 // Determine the capture kind for Sema. 8003 Sema::TryCaptureKind Kind 8004 = C->isImplicit()? Sema::TryCapture_Implicit 8005 : C->getCaptureKind() == LCK_ByCopy 8006 ? Sema::TryCapture_ExplicitByVal 8007 : Sema::TryCapture_ExplicitByRef; 8008 SourceLocation EllipsisLoc; 8009 if (C->isPackExpansion()) { 8010 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); 8011 bool ShouldExpand = false; 8012 bool RetainExpansion = false; 8013 Optional<unsigned> NumExpansions; 8014 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), 8015 C->getLocation(), 8016 Unexpanded, 8017 ShouldExpand, RetainExpansion, 8018 NumExpansions)) 8019 return ExprError(); 8020 8021 if (ShouldExpand) { 8022 // The transform has determined that we should perform an expansion; 8023 // transform and capture each of the arguments. 8024 // expansion of the pattern. Do so. 8025 VarDecl *Pack = C->getCapturedVar(); 8026 for (unsigned I = 0; I != *NumExpansions; ++I) { 8027 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 8028 VarDecl *CapturedVar 8029 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8030 Pack)); 8031 if (!CapturedVar) { 8032 Invalid = true; 8033 continue; 8034 } 8035 8036 // Capture the transformed variable. 8037 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8038 } 8039 continue; 8040 } 8041 8042 EllipsisLoc = C->getEllipsisLoc(); 8043 } 8044 8045 // Transform the captured variable. 8046 VarDecl *CapturedVar 8047 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8048 C->getCapturedVar())); 8049 if (!CapturedVar) { 8050 Invalid = true; 8051 continue; 8052 } 8053 8054 // Capture the transformed variable. 8055 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8056 } 8057 if (!FinishedExplicitCaptures) 8058 getSema().finishLambdaExplicitCaptures(LSI); 8059 8060 8061 // Enter a new evaluation context to insulate the lambda from any 8062 // cleanups from the enclosing full-expression. 8063 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 8064 8065 if (Invalid) { 8066 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, 8067 /*IsInstantiation=*/true); 8068 return ExprError(); 8069 } 8070 8071 // Instantiate the body of the lambda expression. 8072 StmtResult Body = getDerived().TransformStmt(E->getBody()); 8073 if (Body.isInvalid()) { 8074 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, 8075 /*IsInstantiation=*/true); 8076 return ExprError(); 8077 } 8078 8079 return getSema().ActOnLambdaExpr(E->getLocStart(), Body.take(), 8080 /*CurScope=*/0, /*IsInstantiation=*/true); 8081} 8082 8083template<typename Derived> 8084ExprResult 8085TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 8086 CXXUnresolvedConstructExpr *E) { 8087 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8088 if (!T) 8089 return ExprError(); 8090 8091 bool ArgumentChanged = false; 8092 SmallVector<Expr*, 8> Args; 8093 Args.reserve(E->arg_size()); 8094 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 8095 &ArgumentChanged)) 8096 return ExprError(); 8097 8098 if (!getDerived().AlwaysRebuild() && 8099 T == E->getTypeSourceInfo() && 8100 !ArgumentChanged) 8101 return SemaRef.Owned(E); 8102 8103 // FIXME: we're faking the locations of the commas 8104 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 8105 E->getLParenLoc(), 8106 Args, 8107 E->getRParenLoc()); 8108} 8109 8110template<typename Derived> 8111ExprResult 8112TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 8113 CXXDependentScopeMemberExpr *E) { 8114 // Transform the base of the expression. 8115 ExprResult Base((Expr*) 0); 8116 Expr *OldBase; 8117 QualType BaseType; 8118 QualType ObjectType; 8119 if (!E->isImplicitAccess()) { 8120 OldBase = E->getBase(); 8121 Base = getDerived().TransformExpr(OldBase); 8122 if (Base.isInvalid()) 8123 return ExprError(); 8124 8125 // Start the member reference and compute the object's type. 8126 ParsedType ObjectTy; 8127 bool MayBePseudoDestructor = false; 8128 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 8129 E->getOperatorLoc(), 8130 E->isArrow()? tok::arrow : tok::period, 8131 ObjectTy, 8132 MayBePseudoDestructor); 8133 if (Base.isInvalid()) 8134 return ExprError(); 8135 8136 ObjectType = ObjectTy.get(); 8137 BaseType = ((Expr*) Base.get())->getType(); 8138 } else { 8139 OldBase = 0; 8140 BaseType = getDerived().TransformType(E->getBaseType()); 8141 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 8142 } 8143 8144 // Transform the first part of the nested-name-specifier that qualifies 8145 // the member name. 8146 NamedDecl *FirstQualifierInScope 8147 = getDerived().TransformFirstQualifierInScope( 8148 E->getFirstQualifierFoundInScope(), 8149 E->getQualifierLoc().getBeginLoc()); 8150 8151 NestedNameSpecifierLoc QualifierLoc; 8152 if (E->getQualifier()) { 8153 QualifierLoc 8154 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 8155 ObjectType, 8156 FirstQualifierInScope); 8157 if (!QualifierLoc) 8158 return ExprError(); 8159 } 8160 8161 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 8162 8163 // TODO: If this is a conversion-function-id, verify that the 8164 // destination type name (if present) resolves the same way after 8165 // instantiation as it did in the local scope. 8166 8167 DeclarationNameInfo NameInfo 8168 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 8169 if (!NameInfo.getName()) 8170 return ExprError(); 8171 8172 if (!E->hasExplicitTemplateArgs()) { 8173 // This is a reference to a member without an explicitly-specified 8174 // template argument list. Optimize for this common case. 8175 if (!getDerived().AlwaysRebuild() && 8176 Base.get() == OldBase && 8177 BaseType == E->getBaseType() && 8178 QualifierLoc == E->getQualifierLoc() && 8179 NameInfo.getName() == E->getMember() && 8180 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 8181 return SemaRef.Owned(E); 8182 8183 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8184 BaseType, 8185 E->isArrow(), 8186 E->getOperatorLoc(), 8187 QualifierLoc, 8188 TemplateKWLoc, 8189 FirstQualifierInScope, 8190 NameInfo, 8191 /*TemplateArgs*/ 0); 8192 } 8193 8194 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 8195 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 8196 E->getNumTemplateArgs(), 8197 TransArgs)) 8198 return ExprError(); 8199 8200 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8201 BaseType, 8202 E->isArrow(), 8203 E->getOperatorLoc(), 8204 QualifierLoc, 8205 TemplateKWLoc, 8206 FirstQualifierInScope, 8207 NameInfo, 8208 &TransArgs); 8209} 8210 8211template<typename Derived> 8212ExprResult 8213TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 8214 // Transform the base of the expression. 8215 ExprResult Base((Expr*) 0); 8216 QualType BaseType; 8217 if (!Old->isImplicitAccess()) { 8218 Base = getDerived().TransformExpr(Old->getBase()); 8219 if (Base.isInvalid()) 8220 return ExprError(); 8221 Base = getSema().PerformMemberExprBaseConversion(Base.take(), 8222 Old->isArrow()); 8223 if (Base.isInvalid()) 8224 return ExprError(); 8225 BaseType = Base.get()->getType(); 8226 } else { 8227 BaseType = getDerived().TransformType(Old->getBaseType()); 8228 } 8229 8230 NestedNameSpecifierLoc QualifierLoc; 8231 if (Old->getQualifierLoc()) { 8232 QualifierLoc 8233 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 8234 if (!QualifierLoc) 8235 return ExprError(); 8236 } 8237 8238 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 8239 8240 LookupResult R(SemaRef, Old->getMemberNameInfo(), 8241 Sema::LookupOrdinaryName); 8242 8243 // Transform all the decls. 8244 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 8245 E = Old->decls_end(); I != E; ++I) { 8246 NamedDecl *InstD = static_cast<NamedDecl*>( 8247 getDerived().TransformDecl(Old->getMemberLoc(), 8248 *I)); 8249 if (!InstD) { 8250 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 8251 // This can happen because of dependent hiding. 8252 if (isa<UsingShadowDecl>(*I)) 8253 continue; 8254 else { 8255 R.clear(); 8256 return ExprError(); 8257 } 8258 } 8259 8260 // Expand using declarations. 8261 if (isa<UsingDecl>(InstD)) { 8262 UsingDecl *UD = cast<UsingDecl>(InstD); 8263 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 8264 E = UD->shadow_end(); I != E; ++I) 8265 R.addDecl(*I); 8266 continue; 8267 } 8268 8269 R.addDecl(InstD); 8270 } 8271 8272 R.resolveKind(); 8273 8274 // Determine the naming class. 8275 if (Old->getNamingClass()) { 8276 CXXRecordDecl *NamingClass 8277 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 8278 Old->getMemberLoc(), 8279 Old->getNamingClass())); 8280 if (!NamingClass) 8281 return ExprError(); 8282 8283 R.setNamingClass(NamingClass); 8284 } 8285 8286 TemplateArgumentListInfo TransArgs; 8287 if (Old->hasExplicitTemplateArgs()) { 8288 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 8289 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 8290 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 8291 Old->getNumTemplateArgs(), 8292 TransArgs)) 8293 return ExprError(); 8294 } 8295 8296 // FIXME: to do this check properly, we will need to preserve the 8297 // first-qualifier-in-scope here, just in case we had a dependent 8298 // base (and therefore couldn't do the check) and a 8299 // nested-name-qualifier (and therefore could do the lookup). 8300 NamedDecl *FirstQualifierInScope = 0; 8301 8302 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 8303 BaseType, 8304 Old->getOperatorLoc(), 8305 Old->isArrow(), 8306 QualifierLoc, 8307 TemplateKWLoc, 8308 FirstQualifierInScope, 8309 R, 8310 (Old->hasExplicitTemplateArgs() 8311 ? &TransArgs : 0)); 8312} 8313 8314template<typename Derived> 8315ExprResult 8316TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 8317 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8318 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 8319 if (SubExpr.isInvalid()) 8320 return ExprError(); 8321 8322 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 8323 return SemaRef.Owned(E); 8324 8325 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 8326} 8327 8328template<typename Derived> 8329ExprResult 8330TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 8331 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 8332 if (Pattern.isInvalid()) 8333 return ExprError(); 8334 8335 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 8336 return SemaRef.Owned(E); 8337 8338 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 8339 E->getNumExpansions()); 8340} 8341 8342template<typename Derived> 8343ExprResult 8344TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 8345 // If E is not value-dependent, then nothing will change when we transform it. 8346 // Note: This is an instantiation-centric view. 8347 if (!E->isValueDependent()) 8348 return SemaRef.Owned(E); 8349 8350 // Note: None of the implementations of TryExpandParameterPacks can ever 8351 // produce a diagnostic when given only a single unexpanded parameter pack, 8352 // so 8353 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 8354 bool ShouldExpand = false; 8355 bool RetainExpansion = false; 8356 Optional<unsigned> NumExpansions; 8357 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 8358 Unexpanded, 8359 ShouldExpand, RetainExpansion, 8360 NumExpansions)) 8361 return ExprError(); 8362 8363 if (RetainExpansion) 8364 return SemaRef.Owned(E); 8365 8366 NamedDecl *Pack = E->getPack(); 8367 if (!ShouldExpand) { 8368 Pack = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getPackLoc(), 8369 Pack)); 8370 if (!Pack) 8371 return ExprError(); 8372 } 8373 8374 8375 // We now know the length of the parameter pack, so build a new expression 8376 // that stores that length. 8377 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, 8378 E->getPackLoc(), E->getRParenLoc(), 8379 NumExpansions); 8380} 8381 8382template<typename Derived> 8383ExprResult 8384TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 8385 SubstNonTypeTemplateParmPackExpr *E) { 8386 // Default behavior is to do nothing with this transformation. 8387 return SemaRef.Owned(E); 8388} 8389 8390template<typename Derived> 8391ExprResult 8392TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( 8393 SubstNonTypeTemplateParmExpr *E) { 8394 // Default behavior is to do nothing with this transformation. 8395 return SemaRef.Owned(E); 8396} 8397 8398template<typename Derived> 8399ExprResult 8400TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { 8401 // Default behavior is to do nothing with this transformation. 8402 return SemaRef.Owned(E); 8403} 8404 8405template<typename Derived> 8406ExprResult 8407TreeTransform<Derived>::TransformMaterializeTemporaryExpr( 8408 MaterializeTemporaryExpr *E) { 8409 return getDerived().TransformExpr(E->GetTemporaryExpr()); 8410} 8411 8412template<typename Derived> 8413ExprResult 8414TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 8415 return SemaRef.MaybeBindToTemporary(E); 8416} 8417 8418template<typename Derived> 8419ExprResult 8420TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 8421 return SemaRef.Owned(E); 8422} 8423 8424template<typename Derived> 8425ExprResult 8426TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { 8427 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 8428 if (SubExpr.isInvalid()) 8429 return ExprError(); 8430 8431 if (!getDerived().AlwaysRebuild() && 8432 SubExpr.get() == E->getSubExpr()) 8433 return SemaRef.Owned(E); 8434 8435 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); 8436} 8437 8438template<typename Derived> 8439ExprResult 8440TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) { 8441 // Transform each of the elements. 8442 SmallVector<Expr *, 8> Elements; 8443 bool ArgChanged = false; 8444 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(), 8445 /*IsCall=*/false, Elements, &ArgChanged)) 8446 return ExprError(); 8447 8448 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8449 return SemaRef.MaybeBindToTemporary(E); 8450 8451 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(), 8452 Elements.data(), 8453 Elements.size()); 8454} 8455 8456template<typename Derived> 8457ExprResult 8458TreeTransform<Derived>::TransformObjCDictionaryLiteral( 8459 ObjCDictionaryLiteral *E) { 8460 // Transform each of the elements. 8461 SmallVector<ObjCDictionaryElement, 8> Elements; 8462 bool ArgChanged = false; 8463 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 8464 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I); 8465 8466 if (OrigElement.isPackExpansion()) { 8467 // This key/value element is a pack expansion. 8468 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 8469 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded); 8470 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded); 8471 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 8472 8473 // Determine whether the set of unexpanded parameter packs can 8474 // and should be expanded. 8475 bool Expand = true; 8476 bool RetainExpansion = false; 8477 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; 8478 Optional<unsigned> NumExpansions = OrigNumExpansions; 8479 SourceRange PatternRange(OrigElement.Key->getLocStart(), 8480 OrigElement.Value->getLocEnd()); 8481 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, 8482 PatternRange, 8483 Unexpanded, 8484 Expand, RetainExpansion, 8485 NumExpansions)) 8486 return ExprError(); 8487 8488 if (!Expand) { 8489 // The transform has determined that we should perform a simple 8490 // transformation on the pack expansion, producing another pack 8491 // expansion. 8492 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 8493 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8494 if (Key.isInvalid()) 8495 return ExprError(); 8496 8497 if (Key.get() != OrigElement.Key) 8498 ArgChanged = true; 8499 8500 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 8501 if (Value.isInvalid()) 8502 return ExprError(); 8503 8504 if (Value.get() != OrigElement.Value) 8505 ArgChanged = true; 8506 8507 ObjCDictionaryElement Expansion = { 8508 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions 8509 }; 8510 Elements.push_back(Expansion); 8511 continue; 8512 } 8513 8514 // Record right away that the argument was changed. This needs 8515 // to happen even if the array expands to nothing. 8516 ArgChanged = true; 8517 8518 // The transform has determined that we should perform an elementwise 8519 // expansion of the pattern. Do so. 8520 for (unsigned I = 0; I != *NumExpansions; ++I) { 8521 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 8522 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8523 if (Key.isInvalid()) 8524 return ExprError(); 8525 8526 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 8527 if (Value.isInvalid()) 8528 return ExprError(); 8529 8530 ObjCDictionaryElement Element = { 8531 Key.get(), Value.get(), SourceLocation(), NumExpansions 8532 }; 8533 8534 // If any unexpanded parameter packs remain, we still have a 8535 // pack expansion. 8536 if (Key.get()->containsUnexpandedParameterPack() || 8537 Value.get()->containsUnexpandedParameterPack()) 8538 Element.EllipsisLoc = OrigElement.EllipsisLoc; 8539 8540 Elements.push_back(Element); 8541 } 8542 8543 // We've finished with this pack expansion. 8544 continue; 8545 } 8546 8547 // Transform and check key. 8548 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8549 if (Key.isInvalid()) 8550 return ExprError(); 8551 8552 if (Key.get() != OrigElement.Key) 8553 ArgChanged = true; 8554 8555 // Transform and check value. 8556 ExprResult Value 8557 = getDerived().TransformExpr(OrigElement.Value); 8558 if (Value.isInvalid()) 8559 return ExprError(); 8560 8561 if (Value.get() != OrigElement.Value) 8562 ArgChanged = true; 8563 8564 ObjCDictionaryElement Element = { 8565 Key.get(), Value.get(), SourceLocation(), None 8566 }; 8567 Elements.push_back(Element); 8568 } 8569 8570 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8571 return SemaRef.MaybeBindToTemporary(E); 8572 8573 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(), 8574 Elements.data(), 8575 Elements.size()); 8576} 8577 8578template<typename Derived> 8579ExprResult 8580TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 8581 TypeSourceInfo *EncodedTypeInfo 8582 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 8583 if (!EncodedTypeInfo) 8584 return ExprError(); 8585 8586 if (!getDerived().AlwaysRebuild() && 8587 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 8588 return SemaRef.Owned(E); 8589 8590 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 8591 EncodedTypeInfo, 8592 E->getRParenLoc()); 8593} 8594 8595template<typename Derived> 8596ExprResult TreeTransform<Derived>:: 8597TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 8598 ExprResult result = getDerived().TransformExpr(E->getSubExpr()); 8599 if (result.isInvalid()) return ExprError(); 8600 Expr *subExpr = result.take(); 8601 8602 if (!getDerived().AlwaysRebuild() && 8603 subExpr == E->getSubExpr()) 8604 return SemaRef.Owned(E); 8605 8606 return SemaRef.Owned(new(SemaRef.Context) 8607 ObjCIndirectCopyRestoreExpr(subExpr, E->getType(), E->shouldCopy())); 8608} 8609 8610template<typename Derived> 8611ExprResult TreeTransform<Derived>:: 8612TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 8613 TypeSourceInfo *TSInfo 8614 = getDerived().TransformType(E->getTypeInfoAsWritten()); 8615 if (!TSInfo) 8616 return ExprError(); 8617 8618 ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); 8619 if (Result.isInvalid()) 8620 return ExprError(); 8621 8622 if (!getDerived().AlwaysRebuild() && 8623 TSInfo == E->getTypeInfoAsWritten() && 8624 Result.get() == E->getSubExpr()) 8625 return SemaRef.Owned(E); 8626 8627 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), 8628 E->getBridgeKeywordLoc(), TSInfo, 8629 Result.get()); 8630} 8631 8632template<typename Derived> 8633ExprResult 8634TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 8635 // Transform arguments. 8636 bool ArgChanged = false; 8637 SmallVector<Expr*, 8> Args; 8638 Args.reserve(E->getNumArgs()); 8639 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 8640 &ArgChanged)) 8641 return ExprError(); 8642 8643 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 8644 // Class message: transform the receiver type. 8645 TypeSourceInfo *ReceiverTypeInfo 8646 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 8647 if (!ReceiverTypeInfo) 8648 return ExprError(); 8649 8650 // If nothing changed, just retain the existing message send. 8651 if (!getDerived().AlwaysRebuild() && 8652 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 8653 return SemaRef.MaybeBindToTemporary(E); 8654 8655 // Build a new class message send. 8656 SmallVector<SourceLocation, 16> SelLocs; 8657 E->getSelectorLocs(SelLocs); 8658 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 8659 E->getSelector(), 8660 SelLocs, 8661 E->getMethodDecl(), 8662 E->getLeftLoc(), 8663 Args, 8664 E->getRightLoc()); 8665 } 8666 8667 // Instance message: transform the receiver 8668 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 8669 "Only class and instance messages may be instantiated"); 8670 ExprResult Receiver 8671 = getDerived().TransformExpr(E->getInstanceReceiver()); 8672 if (Receiver.isInvalid()) 8673 return ExprError(); 8674 8675 // If nothing changed, just retain the existing message send. 8676 if (!getDerived().AlwaysRebuild() && 8677 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 8678 return SemaRef.MaybeBindToTemporary(E); 8679 8680 // Build a new instance message send. 8681 SmallVector<SourceLocation, 16> SelLocs; 8682 E->getSelectorLocs(SelLocs); 8683 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 8684 E->getSelector(), 8685 SelLocs, 8686 E->getMethodDecl(), 8687 E->getLeftLoc(), 8688 Args, 8689 E->getRightLoc()); 8690} 8691 8692template<typename Derived> 8693ExprResult 8694TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 8695 return SemaRef.Owned(E); 8696} 8697 8698template<typename Derived> 8699ExprResult 8700TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 8701 return SemaRef.Owned(E); 8702} 8703 8704template<typename Derived> 8705ExprResult 8706TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 8707 // Transform the base expression. 8708 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8709 if (Base.isInvalid()) 8710 return ExprError(); 8711 8712 // We don't need to transform the ivar; it will never change. 8713 8714 // If nothing changed, just retain the existing expression. 8715 if (!getDerived().AlwaysRebuild() && 8716 Base.get() == E->getBase()) 8717 return SemaRef.Owned(E); 8718 8719 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 8720 E->getLocation(), 8721 E->isArrow(), E->isFreeIvar()); 8722} 8723 8724template<typename Derived> 8725ExprResult 8726TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 8727 // 'super' and types never change. Property never changes. Just 8728 // retain the existing expression. 8729 if (!E->isObjectReceiver()) 8730 return SemaRef.Owned(E); 8731 8732 // Transform the base expression. 8733 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8734 if (Base.isInvalid()) 8735 return ExprError(); 8736 8737 // We don't need to transform the property; it will never change. 8738 8739 // If nothing changed, just retain the existing expression. 8740 if (!getDerived().AlwaysRebuild() && 8741 Base.get() == E->getBase()) 8742 return SemaRef.Owned(E); 8743 8744 if (E->isExplicitProperty()) 8745 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 8746 E->getExplicitProperty(), 8747 E->getLocation()); 8748 8749 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 8750 SemaRef.Context.PseudoObjectTy, 8751 E->getImplicitPropertyGetter(), 8752 E->getImplicitPropertySetter(), 8753 E->getLocation()); 8754} 8755 8756template<typename Derived> 8757ExprResult 8758TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 8759 // Transform the base expression. 8760 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 8761 if (Base.isInvalid()) 8762 return ExprError(); 8763 8764 // Transform the key expression. 8765 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr()); 8766 if (Key.isInvalid()) 8767 return ExprError(); 8768 8769 // If nothing changed, just retain the existing expression. 8770 if (!getDerived().AlwaysRebuild() && 8771 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) 8772 return SemaRef.Owned(E); 8773 8774 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), 8775 Base.get(), Key.get(), 8776 E->getAtIndexMethodDecl(), 8777 E->setAtIndexMethodDecl()); 8778} 8779 8780template<typename Derived> 8781ExprResult 8782TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 8783 // Transform the base expression. 8784 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8785 if (Base.isInvalid()) 8786 return ExprError(); 8787 8788 // If nothing changed, just retain the existing expression. 8789 if (!getDerived().AlwaysRebuild() && 8790 Base.get() == E->getBase()) 8791 return SemaRef.Owned(E); 8792 8793 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 8794 E->isArrow()); 8795} 8796 8797template<typename Derived> 8798ExprResult 8799TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 8800 bool ArgumentChanged = false; 8801 SmallVector<Expr*, 8> SubExprs; 8802 SubExprs.reserve(E->getNumSubExprs()); 8803 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 8804 SubExprs, &ArgumentChanged)) 8805 return ExprError(); 8806 8807 if (!getDerived().AlwaysRebuild() && 8808 !ArgumentChanged) 8809 return SemaRef.Owned(E); 8810 8811 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 8812 SubExprs, 8813 E->getRParenLoc()); 8814} 8815 8816template<typename Derived> 8817ExprResult 8818TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 8819 BlockDecl *oldBlock = E->getBlockDecl(); 8820 8821 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/0); 8822 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 8823 8824 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 8825 blockScope->TheDecl->setBlockMissingReturnType( 8826 oldBlock->blockMissingReturnType()); 8827 8828 SmallVector<ParmVarDecl*, 4> params; 8829 SmallVector<QualType, 4> paramTypes; 8830 8831 // Parameter substitution. 8832 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 8833 oldBlock->param_begin(), 8834 oldBlock->param_size(), 8835 0, paramTypes, ¶ms)) { 8836 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 8837 return ExprError(); 8838 } 8839 8840 const FunctionType *exprFunctionType = E->getFunctionType(); 8841 QualType exprResultType = 8842 getDerived().TransformType(exprFunctionType->getResultType()); 8843 8844 // Don't allow returning a objc interface by value. 8845 if (exprResultType->isObjCObjectType()) { 8846 getSema().Diag(E->getCaretLocation(), 8847 diag::err_object_cannot_be_passed_returned_by_value) 8848 << 0 << exprResultType; 8849 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 8850 return ExprError(); 8851 } 8852 8853 QualType functionType = getDerived().RebuildFunctionProtoType( 8854 exprResultType, 8855 paramTypes.data(), 8856 paramTypes.size(), 8857 oldBlock->isVariadic(), 8858 false, 0, RQ_None, 8859 exprFunctionType->getExtInfo()); 8860 blockScope->FunctionType = functionType; 8861 8862 // Set the parameters on the block decl. 8863 if (!params.empty()) 8864 blockScope->TheDecl->setParams(params); 8865 8866 if (!oldBlock->blockMissingReturnType()) { 8867 blockScope->HasImplicitReturnType = false; 8868 blockScope->ReturnType = exprResultType; 8869 } 8870 8871 // Transform the body 8872 StmtResult body = getDerived().TransformStmt(E->getBody()); 8873 if (body.isInvalid()) { 8874 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 8875 return ExprError(); 8876 } 8877 8878#ifndef NDEBUG 8879 // In builds with assertions, make sure that we captured everything we 8880 // captured before. 8881 if (!SemaRef.getDiagnostics().hasErrorOccurred()) { 8882 for (BlockDecl::capture_iterator i = oldBlock->capture_begin(), 8883 e = oldBlock->capture_end(); i != e; ++i) { 8884 VarDecl *oldCapture = i->getVariable(); 8885 8886 // Ignore parameter packs. 8887 if (isa<ParmVarDecl>(oldCapture) && 8888 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 8889 continue; 8890 8891 VarDecl *newCapture = 8892 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 8893 oldCapture)); 8894 assert(blockScope->CaptureMap.count(newCapture)); 8895 } 8896 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()); 8897 } 8898#endif 8899 8900 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 8901 /*Scope=*/0); 8902} 8903 8904template<typename Derived> 8905ExprResult 8906TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { 8907 llvm_unreachable("Cannot transform asType expressions yet"); 8908} 8909 8910template<typename Derived> 8911ExprResult 8912TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { 8913 QualType RetTy = getDerived().TransformType(E->getType()); 8914 bool ArgumentChanged = false; 8915 SmallVector<Expr*, 8> SubExprs; 8916 SubExprs.reserve(E->getNumSubExprs()); 8917 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 8918 SubExprs, &ArgumentChanged)) 8919 return ExprError(); 8920 8921 if (!getDerived().AlwaysRebuild() && 8922 !ArgumentChanged) 8923 return SemaRef.Owned(E); 8924 8925 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, 8926 RetTy, E->getOp(), E->getRParenLoc()); 8927} 8928 8929//===----------------------------------------------------------------------===// 8930// Type reconstruction 8931//===----------------------------------------------------------------------===// 8932 8933template<typename Derived> 8934QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 8935 SourceLocation Star) { 8936 return SemaRef.BuildPointerType(PointeeType, Star, 8937 getDerived().getBaseEntity()); 8938} 8939 8940template<typename Derived> 8941QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 8942 SourceLocation Star) { 8943 return SemaRef.BuildBlockPointerType(PointeeType, Star, 8944 getDerived().getBaseEntity()); 8945} 8946 8947template<typename Derived> 8948QualType 8949TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 8950 bool WrittenAsLValue, 8951 SourceLocation Sigil) { 8952 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 8953 Sigil, getDerived().getBaseEntity()); 8954} 8955 8956template<typename Derived> 8957QualType 8958TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 8959 QualType ClassType, 8960 SourceLocation Sigil) { 8961 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 8962 Sigil, getDerived().getBaseEntity()); 8963} 8964 8965template<typename Derived> 8966QualType 8967TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 8968 ArrayType::ArraySizeModifier SizeMod, 8969 const llvm::APInt *Size, 8970 Expr *SizeExpr, 8971 unsigned IndexTypeQuals, 8972 SourceRange BracketsRange) { 8973 if (SizeExpr || !Size) 8974 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 8975 IndexTypeQuals, BracketsRange, 8976 getDerived().getBaseEntity()); 8977 8978 QualType Types[] = { 8979 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 8980 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 8981 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 8982 }; 8983 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 8984 QualType SizeType; 8985 for (unsigned I = 0; I != NumTypes; ++I) 8986 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 8987 SizeType = Types[I]; 8988 break; 8989 } 8990 8991 // Note that we can return a VariableArrayType here in the case where 8992 // the element type was a dependent VariableArrayType. 8993 IntegerLiteral *ArraySize 8994 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType, 8995 /*FIXME*/BracketsRange.getBegin()); 8996 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize, 8997 IndexTypeQuals, BracketsRange, 8998 getDerived().getBaseEntity()); 8999} 9000 9001template<typename Derived> 9002QualType 9003TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 9004 ArrayType::ArraySizeModifier SizeMod, 9005 const llvm::APInt &Size, 9006 unsigned IndexTypeQuals, 9007 SourceRange BracketsRange) { 9008 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 9009 IndexTypeQuals, BracketsRange); 9010} 9011 9012template<typename Derived> 9013QualType 9014TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 9015 ArrayType::ArraySizeModifier SizeMod, 9016 unsigned IndexTypeQuals, 9017 SourceRange BracketsRange) { 9018 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 9019 IndexTypeQuals, BracketsRange); 9020} 9021 9022template<typename Derived> 9023QualType 9024TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 9025 ArrayType::ArraySizeModifier SizeMod, 9026 Expr *SizeExpr, 9027 unsigned IndexTypeQuals, 9028 SourceRange BracketsRange) { 9029 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 9030 SizeExpr, 9031 IndexTypeQuals, BracketsRange); 9032} 9033 9034template<typename Derived> 9035QualType 9036TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 9037 ArrayType::ArraySizeModifier SizeMod, 9038 Expr *SizeExpr, 9039 unsigned IndexTypeQuals, 9040 SourceRange BracketsRange) { 9041 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 9042 SizeExpr, 9043 IndexTypeQuals, BracketsRange); 9044} 9045 9046template<typename Derived> 9047QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 9048 unsigned NumElements, 9049 VectorType::VectorKind VecKind) { 9050 // FIXME: semantic checking! 9051 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 9052} 9053 9054template<typename Derived> 9055QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 9056 unsigned NumElements, 9057 SourceLocation AttributeLoc) { 9058 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 9059 NumElements, true); 9060 IntegerLiteral *VectorSize 9061 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 9062 AttributeLoc); 9063 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 9064} 9065 9066template<typename Derived> 9067QualType 9068TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 9069 Expr *SizeExpr, 9070 SourceLocation AttributeLoc) { 9071 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 9072} 9073 9074template<typename Derived> 9075QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 9076 QualType *ParamTypes, 9077 unsigned NumParamTypes, 9078 bool Variadic, 9079 bool HasTrailingReturn, 9080 unsigned Quals, 9081 RefQualifierKind RefQualifier, 9082 const FunctionType::ExtInfo &Info) { 9083 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 9084 HasTrailingReturn, Quals, RefQualifier, 9085 getDerived().getBaseLocation(), 9086 getDerived().getBaseEntity(), 9087 Info); 9088} 9089 9090template<typename Derived> 9091QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 9092 return SemaRef.Context.getFunctionNoProtoType(T); 9093} 9094 9095template<typename Derived> 9096QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 9097 assert(D && "no decl found"); 9098 if (D->isInvalidDecl()) return QualType(); 9099 9100 // FIXME: Doesn't account for ObjCInterfaceDecl! 9101 TypeDecl *Ty; 9102 if (isa<UsingDecl>(D)) { 9103 UsingDecl *Using = cast<UsingDecl>(D); 9104 assert(Using->isTypeName() && 9105 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 9106 9107 // A valid resolved using typename decl points to exactly one type decl. 9108 assert(++Using->shadow_begin() == Using->shadow_end()); 9109 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 9110 9111 } else { 9112 assert(isa<UnresolvedUsingTypenameDecl>(D) && 9113 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 9114 Ty = cast<UnresolvedUsingTypenameDecl>(D); 9115 } 9116 9117 return SemaRef.Context.getTypeDeclType(Ty); 9118} 9119 9120template<typename Derived> 9121QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 9122 SourceLocation Loc) { 9123 return SemaRef.BuildTypeofExprType(E, Loc); 9124} 9125 9126template<typename Derived> 9127QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 9128 return SemaRef.Context.getTypeOfType(Underlying); 9129} 9130 9131template<typename Derived> 9132QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 9133 SourceLocation Loc) { 9134 return SemaRef.BuildDecltypeType(E, Loc); 9135} 9136 9137template<typename Derived> 9138QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, 9139 UnaryTransformType::UTTKind UKind, 9140 SourceLocation Loc) { 9141 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); 9142} 9143 9144template<typename Derived> 9145QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 9146 TemplateName Template, 9147 SourceLocation TemplateNameLoc, 9148 TemplateArgumentListInfo &TemplateArgs) { 9149 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 9150} 9151 9152template<typename Derived> 9153QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType, 9154 SourceLocation KWLoc) { 9155 return SemaRef.BuildAtomicType(ValueType, KWLoc); 9156} 9157 9158template<typename Derived> 9159TemplateName 9160TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9161 bool TemplateKW, 9162 TemplateDecl *Template) { 9163 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 9164 Template); 9165} 9166 9167template<typename Derived> 9168TemplateName 9169TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9170 const IdentifierInfo &Name, 9171 SourceLocation NameLoc, 9172 QualType ObjectType, 9173 NamedDecl *FirstQualifierInScope) { 9174 UnqualifiedId TemplateName; 9175 TemplateName.setIdentifier(&Name, NameLoc); 9176 Sema::TemplateTy Template; 9177 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9178 getSema().ActOnDependentTemplateName(/*Scope=*/0, 9179 SS, TemplateKWLoc, TemplateName, 9180 ParsedType::make(ObjectType), 9181 /*EnteringContext=*/false, 9182 Template); 9183 return Template.get(); 9184} 9185 9186template<typename Derived> 9187TemplateName 9188TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9189 OverloadedOperatorKind Operator, 9190 SourceLocation NameLoc, 9191 QualType ObjectType) { 9192 UnqualifiedId Name; 9193 // FIXME: Bogus location information. 9194 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 9195 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 9196 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9197 Sema::TemplateTy Template; 9198 getSema().ActOnDependentTemplateName(/*Scope=*/0, 9199 SS, TemplateKWLoc, Name, 9200 ParsedType::make(ObjectType), 9201 /*EnteringContext=*/false, 9202 Template); 9203 return Template.template getAsVal<TemplateName>(); 9204} 9205 9206template<typename Derived> 9207ExprResult 9208TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 9209 SourceLocation OpLoc, 9210 Expr *OrigCallee, 9211 Expr *First, 9212 Expr *Second) { 9213 Expr *Callee = OrigCallee->IgnoreParenCasts(); 9214 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 9215 9216 // Determine whether this should be a builtin operation. 9217 if (Op == OO_Subscript) { 9218 if (!First->getType()->isOverloadableType() && 9219 !Second->getType()->isOverloadableType()) 9220 return getSema().CreateBuiltinArraySubscriptExpr(First, 9221 Callee->getLocStart(), 9222 Second, OpLoc); 9223 } else if (Op == OO_Arrow) { 9224 // -> is never a builtin operation. 9225 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 9226 } else if (Second == 0 || isPostIncDec) { 9227 if (!First->getType()->isOverloadableType()) { 9228 // The argument is not of overloadable type, so try to create a 9229 // built-in unary operation. 9230 UnaryOperatorKind Opc 9231 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9232 9233 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 9234 } 9235 } else { 9236 if (!First->getType()->isOverloadableType() && 9237 !Second->getType()->isOverloadableType()) { 9238 // Neither of the arguments is an overloadable type, so try to 9239 // create a built-in binary operation. 9240 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9241 ExprResult Result 9242 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 9243 if (Result.isInvalid()) 9244 return ExprError(); 9245 9246 return Result; 9247 } 9248 } 9249 9250 // Compute the transformed set of functions (and function templates) to be 9251 // used during overload resolution. 9252 UnresolvedSet<16> Functions; 9253 9254 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 9255 assert(ULE->requiresADL()); 9256 9257 // FIXME: Do we have to check 9258 // IsAcceptableNonMemberOperatorCandidate for each of these? 9259 Functions.append(ULE->decls_begin(), ULE->decls_end()); 9260 } else { 9261 // If we've resolved this to a particular non-member function, just call 9262 // that function. If we resolved it to a member function, 9263 // CreateOverloaded* will find that function for us. 9264 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl(); 9265 if (!isa<CXXMethodDecl>(ND)) 9266 Functions.addDecl(ND); 9267 } 9268 9269 // Add any functions found via argument-dependent lookup. 9270 Expr *Args[2] = { First, Second }; 9271 unsigned NumArgs = 1 + (Second != 0); 9272 9273 // Create the overloaded operator invocation for unary operators. 9274 if (NumArgs == 1 || isPostIncDec) { 9275 UnaryOperatorKind Opc 9276 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9277 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 9278 } 9279 9280 if (Op == OO_Subscript) { 9281 SourceLocation LBrace; 9282 SourceLocation RBrace; 9283 9284 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { 9285 DeclarationNameLoc &NameLoc = DRE->getNameInfo().getInfo(); 9286 LBrace = SourceLocation::getFromRawEncoding( 9287 NameLoc.CXXOperatorName.BeginOpNameLoc); 9288 RBrace = SourceLocation::getFromRawEncoding( 9289 NameLoc.CXXOperatorName.EndOpNameLoc); 9290 } else { 9291 LBrace = Callee->getLocStart(); 9292 RBrace = OpLoc; 9293 } 9294 9295 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, 9296 First, Second); 9297 } 9298 9299 // Create the overloaded operator invocation for binary operators. 9300 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9301 ExprResult Result 9302 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 9303 if (Result.isInvalid()) 9304 return ExprError(); 9305 9306 return Result; 9307} 9308 9309template<typename Derived> 9310ExprResult 9311TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 9312 SourceLocation OperatorLoc, 9313 bool isArrow, 9314 CXXScopeSpec &SS, 9315 TypeSourceInfo *ScopeType, 9316 SourceLocation CCLoc, 9317 SourceLocation TildeLoc, 9318 PseudoDestructorTypeStorage Destroyed) { 9319 QualType BaseType = Base->getType(); 9320 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 9321 (!isArrow && !BaseType->getAs<RecordType>()) || 9322 (isArrow && BaseType->getAs<PointerType>() && 9323 !BaseType->getAs<PointerType>()->getPointeeType() 9324 ->template getAs<RecordType>())){ 9325 // This pseudo-destructor expression is still a pseudo-destructor. 9326 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 9327 isArrow? tok::arrow : tok::period, 9328 SS, ScopeType, CCLoc, TildeLoc, 9329 Destroyed, 9330 /*FIXME?*/true); 9331 } 9332 9333 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 9334 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 9335 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 9336 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 9337 NameInfo.setNamedTypeInfo(DestroyedType); 9338 9339 // The scope type is now known to be a valid nested name specifier 9340 // component. Tack it on to the end of the nested name specifier. 9341 if (ScopeType) 9342 SS.Extend(SemaRef.Context, SourceLocation(), 9343 ScopeType->getTypeLoc(), CCLoc); 9344 9345 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9346 return getSema().BuildMemberReferenceExpr(Base, BaseType, 9347 OperatorLoc, isArrow, 9348 SS, TemplateKWLoc, 9349 /*FIXME: FirstQualifier*/ 0, 9350 NameInfo, 9351 /*TemplateArgs*/ 0); 9352} 9353 9354} // end namespace clang 9355 9356#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 9357