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