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