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