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