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