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