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