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