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