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