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