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