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