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