TreeTransform.h revision 0d8e9646bc000bab521ce52ed294209a92298cef
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 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init)) 2634 Init = Binder->getSubExpr(); 2635 2636 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init)) 2637 Init = ICE->getSubExprAsWritten(); 2638 2639 // If this is not a direct-initializer, we only need to reconstruct 2640 // InitListExprs. Other forms of copy-initialization will be a no-op if 2641 // the initializer is already the right type. 2642 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init); 2643 if (!CXXDirectInit && !(Construct && Construct->isListInitialization())) 2644 return getDerived().TransformExpr(Init); 2645 2646 // Revert value-initialization back to empty parens. 2647 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Init)) { 2648 SourceRange Parens = VIE->getSourceRange(); 2649 return getDerived().RebuildParenListExpr(Parens.getBegin(), None, 2650 Parens.getEnd()); 2651 } 2652 2653 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization. 2654 if (isa<ImplicitValueInitExpr>(Init)) 2655 return getDerived().RebuildParenListExpr(SourceLocation(), None, 2656 SourceLocation()); 2657 2658 // Revert initialization by constructor back to a parenthesized or braced list 2659 // of expressions. Any other form of initializer can just be reused directly. 2660 if (!Construct || isa<CXXTemporaryObjectExpr>(Construct)) 2661 return getDerived().TransformExpr(Init); 2662 2663 SmallVector<Expr*, 8> NewArgs; 2664 bool ArgChanged = false; 2665 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(), 2666 /*IsCall*/true, NewArgs, &ArgChanged)) 2667 return ExprError(); 2668 2669 // If this was list initialization, revert to list form. 2670 if (Construct->isListInitialization()) 2671 return getDerived().RebuildInitList(Construct->getLocStart(), NewArgs, 2672 Construct->getLocEnd(), 2673 Construct->getType()); 2674 2675 // Build a ParenListExpr to represent anything else. 2676 SourceRange Parens = Construct->getParenRange(); 2677 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs, 2678 Parens.getEnd()); 2679} 2680 2681template<typename Derived> 2682bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, 2683 unsigned NumInputs, 2684 bool IsCall, 2685 SmallVectorImpl<Expr *> &Outputs, 2686 bool *ArgChanged) { 2687 for (unsigned I = 0; I != NumInputs; ++I) { 2688 // If requested, drop call arguments that need to be dropped. 2689 if (IsCall && getDerived().DropCallArgument(Inputs[I])) { 2690 if (ArgChanged) 2691 *ArgChanged = true; 2692 2693 break; 2694 } 2695 2696 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { 2697 Expr *Pattern = Expansion->getPattern(); 2698 2699 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2700 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 2701 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 2702 2703 // Determine whether the set of unexpanded parameter packs can and should 2704 // be expanded. 2705 bool Expand = true; 2706 bool RetainExpansion = false; 2707 Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); 2708 Optional<unsigned> NumExpansions = OrigNumExpansions; 2709 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 2710 Pattern->getSourceRange(), 2711 Unexpanded, 2712 Expand, RetainExpansion, 2713 NumExpansions)) 2714 return true; 2715 2716 if (!Expand) { 2717 // The transform has determined that we should perform a simple 2718 // transformation on the pack expansion, producing another pack 2719 // expansion. 2720 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2721 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 2722 if (OutPattern.isInvalid()) 2723 return true; 2724 2725 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 2726 Expansion->getEllipsisLoc(), 2727 NumExpansions); 2728 if (Out.isInvalid()) 2729 return true; 2730 2731 if (ArgChanged) 2732 *ArgChanged = true; 2733 Outputs.push_back(Out.get()); 2734 continue; 2735 } 2736 2737 // Record right away that the argument was changed. This needs 2738 // to happen even if the array expands to nothing. 2739 if (ArgChanged) *ArgChanged = true; 2740 2741 // The transform has determined that we should perform an elementwise 2742 // expansion of the pattern. Do so. 2743 for (unsigned I = 0; I != *NumExpansions; ++I) { 2744 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2745 ExprResult Out = getDerived().TransformExpr(Pattern); 2746 if (Out.isInvalid()) 2747 return true; 2748 2749 if (Out.get()->containsUnexpandedParameterPack()) { 2750 Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), 2751 OrigNumExpansions); 2752 if (Out.isInvalid()) 2753 return true; 2754 } 2755 2756 Outputs.push_back(Out.get()); 2757 } 2758 2759 continue; 2760 } 2761 2762 ExprResult Result = 2763 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false) 2764 : getDerived().TransformExpr(Inputs[I]); 2765 if (Result.isInvalid()) 2766 return true; 2767 2768 if (Result.get() != Inputs[I] && ArgChanged) 2769 *ArgChanged = true; 2770 2771 Outputs.push_back(Result.get()); 2772 } 2773 2774 return false; 2775} 2776 2777template<typename Derived> 2778NestedNameSpecifierLoc 2779TreeTransform<Derived>::TransformNestedNameSpecifierLoc( 2780 NestedNameSpecifierLoc NNS, 2781 QualType ObjectType, 2782 NamedDecl *FirstQualifierInScope) { 2783 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 2784 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; 2785 Qualifier = Qualifier.getPrefix()) 2786 Qualifiers.push_back(Qualifier); 2787 2788 CXXScopeSpec SS; 2789 while (!Qualifiers.empty()) { 2790 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 2791 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier(); 2792 2793 switch (QNNS->getKind()) { 2794 case NestedNameSpecifier::Identifier: 2795 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0, 2796 *QNNS->getAsIdentifier(), 2797 Q.getLocalBeginLoc(), 2798 Q.getLocalEndLoc(), 2799 ObjectType, false, SS, 2800 FirstQualifierInScope, false)) 2801 return NestedNameSpecifierLoc(); 2802 2803 break; 2804 2805 case NestedNameSpecifier::Namespace: { 2806 NamespaceDecl *NS 2807 = cast_or_null<NamespaceDecl>( 2808 getDerived().TransformDecl( 2809 Q.getLocalBeginLoc(), 2810 QNNS->getAsNamespace())); 2811 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); 2812 break; 2813 } 2814 2815 case NestedNameSpecifier::NamespaceAlias: { 2816 NamespaceAliasDecl *Alias 2817 = cast_or_null<NamespaceAliasDecl>( 2818 getDerived().TransformDecl(Q.getLocalBeginLoc(), 2819 QNNS->getAsNamespaceAlias())); 2820 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(), 2821 Q.getLocalEndLoc()); 2822 break; 2823 } 2824 2825 case NestedNameSpecifier::Global: 2826 // There is no meaningful transformation that one could perform on the 2827 // global scope. 2828 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); 2829 break; 2830 2831 case NestedNameSpecifier::TypeSpecWithTemplate: 2832 case NestedNameSpecifier::TypeSpec: { 2833 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType, 2834 FirstQualifierInScope, SS); 2835 2836 if (!TL) 2837 return NestedNameSpecifierLoc(); 2838 2839 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || 2840 (SemaRef.getLangOpts().CPlusPlus11 && 2841 TL.getType()->isEnumeralType())) { 2842 assert(!TL.getType().hasLocalQualifiers() && 2843 "Can't get cv-qualifiers here"); 2844 if (TL.getType()->isEnumeralType()) 2845 SemaRef.Diag(TL.getBeginLoc(), 2846 diag::warn_cxx98_compat_enum_nested_name_spec); 2847 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL, 2848 Q.getLocalEndLoc()); 2849 break; 2850 } 2851 // If the nested-name-specifier is an invalid type def, don't emit an 2852 // error because a previous error should have already been emitted. 2853 TypedefTypeLoc TTL = TL.getAs<TypedefTypeLoc>(); 2854 if (!TTL || !TTL.getTypedefNameDecl()->isInvalidDecl()) { 2855 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) 2856 << TL.getType() << SS.getRange(); 2857 } 2858 return NestedNameSpecifierLoc(); 2859 } 2860 } 2861 2862 // The qualifier-in-scope and object type only apply to the leftmost entity. 2863 FirstQualifierInScope = 0; 2864 ObjectType = QualType(); 2865 } 2866 2867 // Don't rebuild the nested-name-specifier if we don't have to. 2868 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && 2869 !getDerived().AlwaysRebuild()) 2870 return NNS; 2871 2872 // If we can re-use the source-location data from the original 2873 // nested-name-specifier, do so. 2874 if (SS.location_size() == NNS.getDataLength() && 2875 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) 2876 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); 2877 2878 // Allocate new nested-name-specifier location information. 2879 return SS.getWithLocInContext(SemaRef.Context); 2880} 2881 2882template<typename Derived> 2883DeclarationNameInfo 2884TreeTransform<Derived> 2885::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 2886 DeclarationName Name = NameInfo.getName(); 2887 if (!Name) 2888 return DeclarationNameInfo(); 2889 2890 switch (Name.getNameKind()) { 2891 case DeclarationName::Identifier: 2892 case DeclarationName::ObjCZeroArgSelector: 2893 case DeclarationName::ObjCOneArgSelector: 2894 case DeclarationName::ObjCMultiArgSelector: 2895 case DeclarationName::CXXOperatorName: 2896 case DeclarationName::CXXLiteralOperatorName: 2897 case DeclarationName::CXXUsingDirective: 2898 return NameInfo; 2899 2900 case DeclarationName::CXXConstructorName: 2901 case DeclarationName::CXXDestructorName: 2902 case DeclarationName::CXXConversionFunctionName: { 2903 TypeSourceInfo *NewTInfo; 2904 CanQualType NewCanTy; 2905 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 2906 NewTInfo = getDerived().TransformType(OldTInfo); 2907 if (!NewTInfo) 2908 return DeclarationNameInfo(); 2909 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 2910 } 2911 else { 2912 NewTInfo = 0; 2913 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 2914 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 2915 if (NewT.isNull()) 2916 return DeclarationNameInfo(); 2917 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 2918 } 2919 2920 DeclarationName NewName 2921 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 2922 NewCanTy); 2923 DeclarationNameInfo NewNameInfo(NameInfo); 2924 NewNameInfo.setName(NewName); 2925 NewNameInfo.setNamedTypeInfo(NewTInfo); 2926 return NewNameInfo; 2927 } 2928 } 2929 2930 llvm_unreachable("Unknown name kind."); 2931} 2932 2933template<typename Derived> 2934TemplateName 2935TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS, 2936 TemplateName Name, 2937 SourceLocation NameLoc, 2938 QualType ObjectType, 2939 NamedDecl *FirstQualifierInScope) { 2940 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 2941 TemplateDecl *Template = QTN->getTemplateDecl(); 2942 assert(Template && "qualified template name must refer to a template"); 2943 2944 TemplateDecl *TransTemplate 2945 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 2946 Template)); 2947 if (!TransTemplate) 2948 return TemplateName(); 2949 2950 if (!getDerived().AlwaysRebuild() && 2951 SS.getScopeRep() == QTN->getQualifier() && 2952 TransTemplate == Template) 2953 return Name; 2954 2955 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(), 2956 TransTemplate); 2957 } 2958 2959 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 2960 if (SS.getScopeRep()) { 2961 // These apply to the scope specifier, not the template. 2962 ObjectType = QualType(); 2963 FirstQualifierInScope = 0; 2964 } 2965 2966 if (!getDerived().AlwaysRebuild() && 2967 SS.getScopeRep() == DTN->getQualifier() && 2968 ObjectType.isNull()) 2969 return Name; 2970 2971 if (DTN->isIdentifier()) { 2972 return getDerived().RebuildTemplateName(SS, 2973 *DTN->getIdentifier(), 2974 NameLoc, 2975 ObjectType, 2976 FirstQualifierInScope); 2977 } 2978 2979 return getDerived().RebuildTemplateName(SS, DTN->getOperator(), NameLoc, 2980 ObjectType); 2981 } 2982 2983 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 2984 TemplateDecl *TransTemplate 2985 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(NameLoc, 2986 Template)); 2987 if (!TransTemplate) 2988 return TemplateName(); 2989 2990 if (!getDerived().AlwaysRebuild() && 2991 TransTemplate == Template) 2992 return Name; 2993 2994 return TemplateName(TransTemplate); 2995 } 2996 2997 if (SubstTemplateTemplateParmPackStorage *SubstPack 2998 = Name.getAsSubstTemplateTemplateParmPack()) { 2999 TemplateTemplateParmDecl *TransParam 3000 = cast_or_null<TemplateTemplateParmDecl>( 3001 getDerived().TransformDecl(NameLoc, SubstPack->getParameterPack())); 3002 if (!TransParam) 3003 return TemplateName(); 3004 3005 if (!getDerived().AlwaysRebuild() && 3006 TransParam == SubstPack->getParameterPack()) 3007 return Name; 3008 3009 return getDerived().RebuildTemplateName(TransParam, 3010 SubstPack->getArgumentPack()); 3011 } 3012 3013 // These should be getting filtered out before they reach the AST. 3014 llvm_unreachable("overloaded function decl survived to here"); 3015} 3016 3017template<typename Derived> 3018void TreeTransform<Derived>::InventTemplateArgumentLoc( 3019 const TemplateArgument &Arg, 3020 TemplateArgumentLoc &Output) { 3021 SourceLocation Loc = getDerived().getBaseLocation(); 3022 switch (Arg.getKind()) { 3023 case TemplateArgument::Null: 3024 llvm_unreachable("null template argument in TreeTransform"); 3025 break; 3026 3027 case TemplateArgument::Type: 3028 Output = TemplateArgumentLoc(Arg, 3029 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 3030 3031 break; 3032 3033 case TemplateArgument::Template: 3034 case TemplateArgument::TemplateExpansion: { 3035 NestedNameSpecifierLocBuilder Builder; 3036 TemplateName Template = Arg.getAsTemplate(); 3037 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 3038 Builder.MakeTrivial(SemaRef.Context, DTN->getQualifier(), Loc); 3039 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3040 Builder.MakeTrivial(SemaRef.Context, QTN->getQualifier(), Loc); 3041 3042 if (Arg.getKind() == TemplateArgument::Template) 3043 Output = TemplateArgumentLoc(Arg, 3044 Builder.getWithLocInContext(SemaRef.Context), 3045 Loc); 3046 else 3047 Output = TemplateArgumentLoc(Arg, 3048 Builder.getWithLocInContext(SemaRef.Context), 3049 Loc, Loc); 3050 3051 break; 3052 } 3053 3054 case TemplateArgument::Expression: 3055 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 3056 break; 3057 3058 case TemplateArgument::Declaration: 3059 case TemplateArgument::Integral: 3060 case TemplateArgument::Pack: 3061 case TemplateArgument::NullPtr: 3062 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 3063 break; 3064 } 3065} 3066 3067template<typename Derived> 3068bool TreeTransform<Derived>::TransformTemplateArgument( 3069 const TemplateArgumentLoc &Input, 3070 TemplateArgumentLoc &Output) { 3071 const TemplateArgument &Arg = Input.getArgument(); 3072 switch (Arg.getKind()) { 3073 case TemplateArgument::Null: 3074 case TemplateArgument::Integral: 3075 case TemplateArgument::Pack: 3076 case TemplateArgument::Declaration: 3077 case TemplateArgument::NullPtr: 3078 llvm_unreachable("Unexpected TemplateArgument"); 3079 3080 case TemplateArgument::Type: { 3081 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 3082 if (DI == NULL) 3083 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 3084 3085 DI = getDerived().TransformType(DI); 3086 if (!DI) return true; 3087 3088 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 3089 return false; 3090 } 3091 3092 case TemplateArgument::Template: { 3093 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc(); 3094 if (QualifierLoc) { 3095 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc); 3096 if (!QualifierLoc) 3097 return true; 3098 } 3099 3100 CXXScopeSpec SS; 3101 SS.Adopt(QualifierLoc); 3102 TemplateName Template 3103 = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(), 3104 Input.getTemplateNameLoc()); 3105 if (Template.isNull()) 3106 return true; 3107 3108 Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc, 3109 Input.getTemplateNameLoc()); 3110 return false; 3111 } 3112 3113 case TemplateArgument::TemplateExpansion: 3114 llvm_unreachable("Caller should expand pack expansions"); 3115 3116 case TemplateArgument::Expression: { 3117 // Template argument expressions are constant expressions. 3118 EnterExpressionEvaluationContext Unevaluated(getSema(), 3119 Sema::ConstantEvaluated); 3120 3121 Expr *InputExpr = Input.getSourceExpression(); 3122 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 3123 3124 ExprResult E = getDerived().TransformExpr(InputExpr); 3125 E = SemaRef.ActOnConstantExpression(E); 3126 if (E.isInvalid()) return true; 3127 Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); 3128 return false; 3129 } 3130 } 3131 3132 // Work around bogus GCC warning 3133 return true; 3134} 3135 3136/// \brief Iterator adaptor that invents template argument location information 3137/// for each of the template arguments in its underlying iterator. 3138template<typename Derived, typename InputIterator> 3139class TemplateArgumentLocInventIterator { 3140 TreeTransform<Derived> &Self; 3141 InputIterator Iter; 3142 3143public: 3144 typedef TemplateArgumentLoc value_type; 3145 typedef TemplateArgumentLoc reference; 3146 typedef typename std::iterator_traits<InputIterator>::difference_type 3147 difference_type; 3148 typedef std::input_iterator_tag iterator_category; 3149 3150 class pointer { 3151 TemplateArgumentLoc Arg; 3152 3153 public: 3154 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3155 3156 const TemplateArgumentLoc *operator->() const { return &Arg; } 3157 }; 3158 3159 TemplateArgumentLocInventIterator() { } 3160 3161 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, 3162 InputIterator Iter) 3163 : Self(Self), Iter(Iter) { } 3164 3165 TemplateArgumentLocInventIterator &operator++() { 3166 ++Iter; 3167 return *this; 3168 } 3169 3170 TemplateArgumentLocInventIterator operator++(int) { 3171 TemplateArgumentLocInventIterator Old(*this); 3172 ++(*this); 3173 return Old; 3174 } 3175 3176 reference operator*() const { 3177 TemplateArgumentLoc Result; 3178 Self.InventTemplateArgumentLoc(*Iter, Result); 3179 return Result; 3180 } 3181 3182 pointer operator->() const { return pointer(**this); } 3183 3184 friend bool operator==(const TemplateArgumentLocInventIterator &X, 3185 const TemplateArgumentLocInventIterator &Y) { 3186 return X.Iter == Y.Iter; 3187 } 3188 3189 friend bool operator!=(const TemplateArgumentLocInventIterator &X, 3190 const TemplateArgumentLocInventIterator &Y) { 3191 return X.Iter != Y.Iter; 3192 } 3193}; 3194 3195template<typename Derived> 3196template<typename InputIterator> 3197bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, 3198 InputIterator Last, 3199 TemplateArgumentListInfo &Outputs) { 3200 for (; First != Last; ++First) { 3201 TemplateArgumentLoc Out; 3202 TemplateArgumentLoc In = *First; 3203 3204 if (In.getArgument().getKind() == TemplateArgument::Pack) { 3205 // Unpack argument packs, which we translate them into separate 3206 // arguments. 3207 // FIXME: We could do much better if we could guarantee that the 3208 // TemplateArgumentLocInfo for the pack expansion would be usable for 3209 // all of the template arguments in the argument pack. 3210 typedef TemplateArgumentLocInventIterator<Derived, 3211 TemplateArgument::pack_iterator> 3212 PackLocIterator; 3213 if (TransformTemplateArguments(PackLocIterator(*this, 3214 In.getArgument().pack_begin()), 3215 PackLocIterator(*this, 3216 In.getArgument().pack_end()), 3217 Outputs)) 3218 return true; 3219 3220 continue; 3221 } 3222 3223 if (In.getArgument().isPackExpansion()) { 3224 // We have a pack expansion, for which we will be substituting into 3225 // the pattern. 3226 SourceLocation Ellipsis; 3227 Optional<unsigned> OrigNumExpansions; 3228 TemplateArgumentLoc Pattern 3229 = In.getPackExpansionPattern(Ellipsis, OrigNumExpansions, 3230 getSema().Context); 3231 3232 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3233 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3234 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 3235 3236 // Determine whether the set of unexpanded parameter packs can and should 3237 // be expanded. 3238 bool Expand = true; 3239 bool RetainExpansion = false; 3240 Optional<unsigned> NumExpansions = OrigNumExpansions; 3241 if (getDerived().TryExpandParameterPacks(Ellipsis, 3242 Pattern.getSourceRange(), 3243 Unexpanded, 3244 Expand, 3245 RetainExpansion, 3246 NumExpansions)) 3247 return true; 3248 3249 if (!Expand) { 3250 // The transform has determined that we should perform a simple 3251 // transformation on the pack expansion, producing another pack 3252 // expansion. 3253 TemplateArgumentLoc OutPattern; 3254 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3255 if (getDerived().TransformTemplateArgument(Pattern, OutPattern)) 3256 return true; 3257 3258 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis, 3259 NumExpansions); 3260 if (Out.getArgument().isNull()) 3261 return true; 3262 3263 Outputs.addArgument(Out); 3264 continue; 3265 } 3266 3267 // The transform has determined that we should perform an elementwise 3268 // expansion of the pattern. Do so. 3269 for (unsigned I = 0; I != *NumExpansions; ++I) { 3270 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3271 3272 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3273 return true; 3274 3275 if (Out.getArgument().containsUnexpandedParameterPack()) { 3276 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3277 OrigNumExpansions); 3278 if (Out.getArgument().isNull()) 3279 return true; 3280 } 3281 3282 Outputs.addArgument(Out); 3283 } 3284 3285 // If we're supposed to retain a pack expansion, do so by temporarily 3286 // forgetting the partially-substituted parameter pack. 3287 if (RetainExpansion) { 3288 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3289 3290 if (getDerived().TransformTemplateArgument(Pattern, Out)) 3291 return true; 3292 3293 Out = getDerived().RebuildPackExpansion(Out, Ellipsis, 3294 OrigNumExpansions); 3295 if (Out.getArgument().isNull()) 3296 return true; 3297 3298 Outputs.addArgument(Out); 3299 } 3300 3301 continue; 3302 } 3303 3304 // The simple case: 3305 if (getDerived().TransformTemplateArgument(In, Out)) 3306 return true; 3307 3308 Outputs.addArgument(Out); 3309 } 3310 3311 return false; 3312 3313} 3314 3315//===----------------------------------------------------------------------===// 3316// Type transformation 3317//===----------------------------------------------------------------------===// 3318 3319template<typename Derived> 3320QualType TreeTransform<Derived>::TransformType(QualType T) { 3321 if (getDerived().AlreadyTransformed(T)) 3322 return T; 3323 3324 // Temporary workaround. All of these transformations should 3325 // eventually turn into transformations on TypeLocs. 3326 TypeSourceInfo *DI = getSema().Context.getTrivialTypeSourceInfo(T, 3327 getDerived().getBaseLocation()); 3328 3329 TypeSourceInfo *NewDI = getDerived().TransformType(DI); 3330 3331 if (!NewDI) 3332 return QualType(); 3333 3334 return NewDI->getType(); 3335} 3336 3337template<typename Derived> 3338TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { 3339 // Refine the base location to the type's location. 3340 TemporaryBase Rebase(*this, DI->getTypeLoc().getBeginLoc(), 3341 getDerived().getBaseEntity()); 3342 if (getDerived().AlreadyTransformed(DI->getType())) 3343 return DI; 3344 3345 TypeLocBuilder TLB; 3346 3347 TypeLoc TL = DI->getTypeLoc(); 3348 TLB.reserve(TL.getFullDataSize()); 3349 3350 QualType Result = getDerived().TransformType(TLB, TL); 3351 if (Result.isNull()) 3352 return 0; 3353 3354 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3355} 3356 3357template<typename Derived> 3358QualType 3359TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 3360 switch (T.getTypeLocClass()) { 3361#define ABSTRACT_TYPELOC(CLASS, PARENT) 3362#define TYPELOC(CLASS, PARENT) \ 3363 case TypeLoc::CLASS: \ 3364 return getDerived().Transform##CLASS##Type(TLB, \ 3365 T.castAs<CLASS##TypeLoc>()); 3366#include "clang/AST/TypeLocNodes.def" 3367 } 3368 3369 llvm_unreachable("unhandled type loc!"); 3370} 3371 3372/// FIXME: By default, this routine adds type qualifiers only to types 3373/// that can have qualifiers, and silently suppresses those qualifiers 3374/// that are not permitted (e.g., qualifiers on reference or function 3375/// types). This is the right thing for template instantiation, but 3376/// probably not for other clients. 3377template<typename Derived> 3378QualType 3379TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 3380 QualifiedTypeLoc T) { 3381 Qualifiers Quals = T.getType().getLocalQualifiers(); 3382 3383 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 3384 if (Result.isNull()) 3385 return QualType(); 3386 3387 // Silently suppress qualifiers if the result type can't be qualified. 3388 // FIXME: this is the right thing for template instantiation, but 3389 // probably not for other clients. 3390 if (Result->isFunctionType() || Result->isReferenceType()) 3391 return Result; 3392 3393 // Suppress Objective-C lifetime qualifiers if they don't make sense for the 3394 // resulting type. 3395 if (Quals.hasObjCLifetime()) { 3396 if (!Result->isObjCLifetimeType() && !Result->isDependentType()) 3397 Quals.removeObjCLifetime(); 3398 else if (Result.getObjCLifetime()) { 3399 // Objective-C ARC: 3400 // A lifetime qualifier applied to a substituted template parameter 3401 // overrides the lifetime qualifier from the template argument. 3402 const AutoType *AutoTy; 3403 if (const SubstTemplateTypeParmType *SubstTypeParam 3404 = dyn_cast<SubstTemplateTypeParmType>(Result)) { 3405 QualType Replacement = SubstTypeParam->getReplacementType(); 3406 Qualifiers Qs = Replacement.getQualifiers(); 3407 Qs.removeObjCLifetime(); 3408 Replacement 3409 = SemaRef.Context.getQualifiedType(Replacement.getUnqualifiedType(), 3410 Qs); 3411 Result = SemaRef.Context.getSubstTemplateTypeParmType( 3412 SubstTypeParam->getReplacedParameter(), 3413 Replacement); 3414 TLB.TypeWasModifiedSafely(Result); 3415 } else if ((AutoTy = dyn_cast<AutoType>(Result)) && AutoTy->isDeduced()) { 3416 // 'auto' types behave the same way as template parameters. 3417 QualType Deduced = AutoTy->getDeducedType(); 3418 Qualifiers Qs = Deduced.getQualifiers(); 3419 Qs.removeObjCLifetime(); 3420 Deduced = SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), 3421 Qs); 3422 Result = SemaRef.Context.getAutoType(Deduced, AutoTy->isDecltypeAuto()); 3423 TLB.TypeWasModifiedSafely(Result); 3424 } else { 3425 // Otherwise, complain about the addition of a qualifier to an 3426 // already-qualified type. 3427 SourceRange R = TLB.getTemporaryTypeLoc(Result).getSourceRange(); 3428 SemaRef.Diag(R.getBegin(), diag::err_attr_objc_ownership_redundant) 3429 << Result << R; 3430 3431 Quals.removeObjCLifetime(); 3432 } 3433 } 3434 } 3435 if (!Quals.empty()) { 3436 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals); 3437 // BuildQualifiedType might not add qualifiers if they are invalid. 3438 if (Result.hasLocalQualifiers()) 3439 TLB.push<QualifiedTypeLoc>(Result); 3440 // No location information to preserve. 3441 } 3442 3443 return Result; 3444} 3445 3446template<typename Derived> 3447TypeLoc 3448TreeTransform<Derived>::TransformTypeInObjectScope(TypeLoc TL, 3449 QualType ObjectType, 3450 NamedDecl *UnqualLookup, 3451 CXXScopeSpec &SS) { 3452 QualType T = TL.getType(); 3453 if (getDerived().AlreadyTransformed(T)) 3454 return TL; 3455 3456 TypeLocBuilder TLB; 3457 QualType Result; 3458 3459 if (isa<TemplateSpecializationType>(T)) { 3460 TemplateSpecializationTypeLoc SpecTL = 3461 TL.castAs<TemplateSpecializationTypeLoc>(); 3462 3463 TemplateName Template = 3464 getDerived().TransformTemplateName(SS, 3465 SpecTL.getTypePtr()->getTemplateName(), 3466 SpecTL.getTemplateNameLoc(), 3467 ObjectType, UnqualLookup); 3468 if (Template.isNull()) 3469 return TypeLoc(); 3470 3471 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3472 Template); 3473 } else if (isa<DependentTemplateSpecializationType>(T)) { 3474 DependentTemplateSpecializationTypeLoc SpecTL = 3475 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3476 3477 TemplateName Template 3478 = getDerived().RebuildTemplateName(SS, 3479 *SpecTL.getTypePtr()->getIdentifier(), 3480 SpecTL.getTemplateNameLoc(), 3481 ObjectType, UnqualLookup); 3482 if (Template.isNull()) 3483 return TypeLoc(); 3484 3485 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3486 SpecTL, 3487 Template, 3488 SS); 3489 } else { 3490 // Nothing special needs to be done for these. 3491 Result = getDerived().TransformType(TLB, TL); 3492 } 3493 3494 if (Result.isNull()) 3495 return TypeLoc(); 3496 3497 return TLB.getTypeSourceInfo(SemaRef.Context, Result)->getTypeLoc(); 3498} 3499 3500template<typename Derived> 3501TypeSourceInfo * 3502TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 3503 QualType ObjectType, 3504 NamedDecl *UnqualLookup, 3505 CXXScopeSpec &SS) { 3506 // FIXME: Painfully copy-paste from the above! 3507 3508 QualType T = TSInfo->getType(); 3509 if (getDerived().AlreadyTransformed(T)) 3510 return TSInfo; 3511 3512 TypeLocBuilder TLB; 3513 QualType Result; 3514 3515 TypeLoc TL = TSInfo->getTypeLoc(); 3516 if (isa<TemplateSpecializationType>(T)) { 3517 TemplateSpecializationTypeLoc SpecTL = 3518 TL.castAs<TemplateSpecializationTypeLoc>(); 3519 3520 TemplateName Template 3521 = getDerived().TransformTemplateName(SS, 3522 SpecTL.getTypePtr()->getTemplateName(), 3523 SpecTL.getTemplateNameLoc(), 3524 ObjectType, UnqualLookup); 3525 if (Template.isNull()) 3526 return 0; 3527 3528 Result = getDerived().TransformTemplateSpecializationType(TLB, SpecTL, 3529 Template); 3530 } else if (isa<DependentTemplateSpecializationType>(T)) { 3531 DependentTemplateSpecializationTypeLoc SpecTL = 3532 TL.castAs<DependentTemplateSpecializationTypeLoc>(); 3533 3534 TemplateName Template 3535 = getDerived().RebuildTemplateName(SS, 3536 *SpecTL.getTypePtr()->getIdentifier(), 3537 SpecTL.getTemplateNameLoc(), 3538 ObjectType, UnqualLookup); 3539 if (Template.isNull()) 3540 return 0; 3541 3542 Result = getDerived().TransformDependentTemplateSpecializationType(TLB, 3543 SpecTL, 3544 Template, 3545 SS); 3546 } else { 3547 // Nothing special needs to be done for these. 3548 Result = getDerived().TransformType(TLB, TL); 3549 } 3550 3551 if (Result.isNull()) 3552 return 0; 3553 3554 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 3555} 3556 3557template <class TyLoc> static inline 3558QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 3559 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 3560 NewT.setNameLoc(T.getNameLoc()); 3561 return T.getType(); 3562} 3563 3564template<typename Derived> 3565QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 3566 BuiltinTypeLoc T) { 3567 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 3568 NewT.setBuiltinLoc(T.getBuiltinLoc()); 3569 if (T.needsExtraLocalData()) 3570 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 3571 return T.getType(); 3572} 3573 3574template<typename Derived> 3575QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 3576 ComplexTypeLoc T) { 3577 // FIXME: recurse? 3578 return TransformTypeSpecType(TLB, T); 3579} 3580 3581template<typename Derived> 3582QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 3583 PointerTypeLoc TL) { 3584 QualType PointeeType 3585 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3586 if (PointeeType.isNull()) 3587 return QualType(); 3588 3589 QualType Result = TL.getType(); 3590 if (PointeeType->getAs<ObjCObjectType>()) { 3591 // A dependent pointer type 'T *' has is being transformed such 3592 // that an Objective-C class type is being replaced for 'T'. The 3593 // resulting pointer type is an ObjCObjectPointerType, not a 3594 // PointerType. 3595 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); 3596 3597 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 3598 NewT.setStarLoc(TL.getStarLoc()); 3599 return Result; 3600 } 3601 3602 if (getDerived().AlwaysRebuild() || 3603 PointeeType != TL.getPointeeLoc().getType()) { 3604 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 3605 if (Result.isNull()) 3606 return QualType(); 3607 } 3608 3609 // Objective-C ARC can add lifetime qualifiers to the type that we're 3610 // pointing to. 3611 TLB.TypeWasModifiedSafely(Result->getPointeeType()); 3612 3613 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 3614 NewT.setSigilLoc(TL.getSigilLoc()); 3615 return Result; 3616} 3617 3618template<typename Derived> 3619QualType 3620TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 3621 BlockPointerTypeLoc TL) { 3622 QualType PointeeType 3623 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3624 if (PointeeType.isNull()) 3625 return QualType(); 3626 3627 QualType Result = TL.getType(); 3628 if (getDerived().AlwaysRebuild() || 3629 PointeeType != TL.getPointeeLoc().getType()) { 3630 Result = getDerived().RebuildBlockPointerType(PointeeType, 3631 TL.getSigilLoc()); 3632 if (Result.isNull()) 3633 return QualType(); 3634 } 3635 3636 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); 3637 NewT.setSigilLoc(TL.getSigilLoc()); 3638 return Result; 3639} 3640 3641/// Transforms a reference type. Note that somewhat paradoxically we 3642/// don't care whether the type itself is an l-value type or an r-value 3643/// type; we only care if the type was *written* as an l-value type 3644/// or an r-value type. 3645template<typename Derived> 3646QualType 3647TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 3648 ReferenceTypeLoc TL) { 3649 const ReferenceType *T = TL.getTypePtr(); 3650 3651 // Note that this works with the pointee-as-written. 3652 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3653 if (PointeeType.isNull()) 3654 return QualType(); 3655 3656 QualType Result = TL.getType(); 3657 if (getDerived().AlwaysRebuild() || 3658 PointeeType != T->getPointeeTypeAsWritten()) { 3659 Result = getDerived().RebuildReferenceType(PointeeType, 3660 T->isSpelledAsLValue(), 3661 TL.getSigilLoc()); 3662 if (Result.isNull()) 3663 return QualType(); 3664 } 3665 3666 // Objective-C ARC can add lifetime qualifiers to the type that we're 3667 // referring to. 3668 TLB.TypeWasModifiedSafely( 3669 Result->getAs<ReferenceType>()->getPointeeTypeAsWritten()); 3670 3671 // r-value references can be rebuilt as l-value references. 3672 ReferenceTypeLoc NewTL; 3673 if (isa<LValueReferenceType>(Result)) 3674 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 3675 else 3676 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 3677 NewTL.setSigilLoc(TL.getSigilLoc()); 3678 3679 return Result; 3680} 3681 3682template<typename Derived> 3683QualType 3684TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 3685 LValueReferenceTypeLoc TL) { 3686 return TransformReferenceType(TLB, TL); 3687} 3688 3689template<typename Derived> 3690QualType 3691TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 3692 RValueReferenceTypeLoc TL) { 3693 return TransformReferenceType(TLB, TL); 3694} 3695 3696template<typename Derived> 3697QualType 3698TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 3699 MemberPointerTypeLoc TL) { 3700 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3701 if (PointeeType.isNull()) 3702 return QualType(); 3703 3704 TypeSourceInfo* OldClsTInfo = TL.getClassTInfo(); 3705 TypeSourceInfo* NewClsTInfo = 0; 3706 if (OldClsTInfo) { 3707 NewClsTInfo = getDerived().TransformType(OldClsTInfo); 3708 if (!NewClsTInfo) 3709 return QualType(); 3710 } 3711 3712 const MemberPointerType *T = TL.getTypePtr(); 3713 QualType OldClsType = QualType(T->getClass(), 0); 3714 QualType NewClsType; 3715 if (NewClsTInfo) 3716 NewClsType = NewClsTInfo->getType(); 3717 else { 3718 NewClsType = getDerived().TransformType(OldClsType); 3719 if (NewClsType.isNull()) 3720 return QualType(); 3721 } 3722 3723 QualType Result = TL.getType(); 3724 if (getDerived().AlwaysRebuild() || 3725 PointeeType != T->getPointeeType() || 3726 NewClsType != OldClsType) { 3727 Result = getDerived().RebuildMemberPointerType(PointeeType, NewClsType, 3728 TL.getStarLoc()); 3729 if (Result.isNull()) 3730 return QualType(); 3731 } 3732 3733 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 3734 NewTL.setSigilLoc(TL.getSigilLoc()); 3735 NewTL.setClassTInfo(NewClsTInfo); 3736 3737 return Result; 3738} 3739 3740template<typename Derived> 3741QualType 3742TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 3743 ConstantArrayTypeLoc TL) { 3744 const ConstantArrayType *T = TL.getTypePtr(); 3745 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3746 if (ElementType.isNull()) 3747 return QualType(); 3748 3749 QualType Result = TL.getType(); 3750 if (getDerived().AlwaysRebuild() || 3751 ElementType != T->getElementType()) { 3752 Result = getDerived().RebuildConstantArrayType(ElementType, 3753 T->getSizeModifier(), 3754 T->getSize(), 3755 T->getIndexTypeCVRQualifiers(), 3756 TL.getBracketsRange()); 3757 if (Result.isNull()) 3758 return QualType(); 3759 } 3760 3761 // We might have either a ConstantArrayType or a VariableArrayType now: 3762 // a ConstantArrayType is allowed to have an element type which is a 3763 // VariableArrayType if the type is dependent. Fortunately, all array 3764 // types have the same location layout. 3765 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3766 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3767 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3768 3769 Expr *Size = TL.getSizeExpr(); 3770 if (Size) { 3771 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3772 Sema::ConstantEvaluated); 3773 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 3774 Size = SemaRef.ActOnConstantExpression(Size).take(); 3775 } 3776 NewTL.setSizeExpr(Size); 3777 3778 return Result; 3779} 3780 3781template<typename Derived> 3782QualType TreeTransform<Derived>::TransformIncompleteArrayType( 3783 TypeLocBuilder &TLB, 3784 IncompleteArrayTypeLoc TL) { 3785 const IncompleteArrayType *T = TL.getTypePtr(); 3786 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3787 if (ElementType.isNull()) 3788 return QualType(); 3789 3790 QualType Result = TL.getType(); 3791 if (getDerived().AlwaysRebuild() || 3792 ElementType != T->getElementType()) { 3793 Result = getDerived().RebuildIncompleteArrayType(ElementType, 3794 T->getSizeModifier(), 3795 T->getIndexTypeCVRQualifiers(), 3796 TL.getBracketsRange()); 3797 if (Result.isNull()) 3798 return QualType(); 3799 } 3800 3801 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 3802 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3803 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3804 NewTL.setSizeExpr(0); 3805 3806 return Result; 3807} 3808 3809template<typename Derived> 3810QualType 3811TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 3812 VariableArrayTypeLoc TL) { 3813 const VariableArrayType *T = TL.getTypePtr(); 3814 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3815 if (ElementType.isNull()) 3816 return QualType(); 3817 3818 ExprResult SizeResult 3819 = getDerived().TransformExpr(T->getSizeExpr()); 3820 if (SizeResult.isInvalid()) 3821 return QualType(); 3822 3823 Expr *Size = SizeResult.take(); 3824 3825 QualType Result = TL.getType(); 3826 if (getDerived().AlwaysRebuild() || 3827 ElementType != T->getElementType() || 3828 Size != T->getSizeExpr()) { 3829 Result = getDerived().RebuildVariableArrayType(ElementType, 3830 T->getSizeModifier(), 3831 Size, 3832 T->getIndexTypeCVRQualifiers(), 3833 TL.getBracketsRange()); 3834 if (Result.isNull()) 3835 return QualType(); 3836 } 3837 3838 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 3839 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3840 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3841 NewTL.setSizeExpr(Size); 3842 3843 return Result; 3844} 3845 3846template<typename Derived> 3847QualType 3848TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 3849 DependentSizedArrayTypeLoc TL) { 3850 const DependentSizedArrayType *T = TL.getTypePtr(); 3851 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3852 if (ElementType.isNull()) 3853 return QualType(); 3854 3855 // Array bounds are constant expressions. 3856 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3857 Sema::ConstantEvaluated); 3858 3859 // Prefer the expression from the TypeLoc; the other may have been uniqued. 3860 Expr *origSize = TL.getSizeExpr(); 3861 if (!origSize) origSize = T->getSizeExpr(); 3862 3863 ExprResult sizeResult 3864 = getDerived().TransformExpr(origSize); 3865 sizeResult = SemaRef.ActOnConstantExpression(sizeResult); 3866 if (sizeResult.isInvalid()) 3867 return QualType(); 3868 3869 Expr *size = sizeResult.get(); 3870 3871 QualType Result = TL.getType(); 3872 if (getDerived().AlwaysRebuild() || 3873 ElementType != T->getElementType() || 3874 size != origSize) { 3875 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 3876 T->getSizeModifier(), 3877 size, 3878 T->getIndexTypeCVRQualifiers(), 3879 TL.getBracketsRange()); 3880 if (Result.isNull()) 3881 return QualType(); 3882 } 3883 3884 // We might have any sort of array type now, but fortunately they 3885 // all have the same location layout. 3886 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3887 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3888 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3889 NewTL.setSizeExpr(size); 3890 3891 return Result; 3892} 3893 3894template<typename Derived> 3895QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 3896 TypeLocBuilder &TLB, 3897 DependentSizedExtVectorTypeLoc TL) { 3898 const DependentSizedExtVectorType *T = TL.getTypePtr(); 3899 3900 // FIXME: ext vector locs should be nested 3901 QualType ElementType = getDerived().TransformType(T->getElementType()); 3902 if (ElementType.isNull()) 3903 return QualType(); 3904 3905 // Vector sizes are constant expressions. 3906 EnterExpressionEvaluationContext Unevaluated(SemaRef, 3907 Sema::ConstantEvaluated); 3908 3909 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 3910 Size = SemaRef.ActOnConstantExpression(Size); 3911 if (Size.isInvalid()) 3912 return QualType(); 3913 3914 QualType Result = TL.getType(); 3915 if (getDerived().AlwaysRebuild() || 3916 ElementType != T->getElementType() || 3917 Size.get() != T->getSizeExpr()) { 3918 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 3919 Size.take(), 3920 T->getAttributeLoc()); 3921 if (Result.isNull()) 3922 return QualType(); 3923 } 3924 3925 // Result might be dependent or not. 3926 if (isa<DependentSizedExtVectorType>(Result)) { 3927 DependentSizedExtVectorTypeLoc NewTL 3928 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 3929 NewTL.setNameLoc(TL.getNameLoc()); 3930 } else { 3931 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3932 NewTL.setNameLoc(TL.getNameLoc()); 3933 } 3934 3935 return Result; 3936} 3937 3938template<typename Derived> 3939QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 3940 VectorTypeLoc TL) { 3941 const VectorType *T = TL.getTypePtr(); 3942 QualType ElementType = getDerived().TransformType(T->getElementType()); 3943 if (ElementType.isNull()) 3944 return QualType(); 3945 3946 QualType Result = TL.getType(); 3947 if (getDerived().AlwaysRebuild() || 3948 ElementType != T->getElementType()) { 3949 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 3950 T->getVectorKind()); 3951 if (Result.isNull()) 3952 return QualType(); 3953 } 3954 3955 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 3956 NewTL.setNameLoc(TL.getNameLoc()); 3957 3958 return Result; 3959} 3960 3961template<typename Derived> 3962QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 3963 ExtVectorTypeLoc TL) { 3964 const VectorType *T = TL.getTypePtr(); 3965 QualType ElementType = getDerived().TransformType(T->getElementType()); 3966 if (ElementType.isNull()) 3967 return QualType(); 3968 3969 QualType Result = TL.getType(); 3970 if (getDerived().AlwaysRebuild() || 3971 ElementType != T->getElementType()) { 3972 Result = getDerived().RebuildExtVectorType(ElementType, 3973 T->getNumElements(), 3974 /*FIXME*/ SourceLocation()); 3975 if (Result.isNull()) 3976 return QualType(); 3977 } 3978 3979 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3980 NewTL.setNameLoc(TL.getNameLoc()); 3981 3982 return Result; 3983} 3984 3985template <typename Derived> 3986ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( 3987 ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, 3988 bool ExpectParameterPack) { 3989 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 3990 TypeSourceInfo *NewDI = 0; 3991 3992 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { 3993 // If we're substituting into a pack expansion type and we know the 3994 // length we want to expand to, just substitute for the pattern. 3995 TypeLoc OldTL = OldDI->getTypeLoc(); 3996 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>(); 3997 3998 TypeLocBuilder TLB; 3999 TypeLoc NewTL = OldDI->getTypeLoc(); 4000 TLB.reserve(NewTL.getFullDataSize()); 4001 4002 QualType Result = getDerived().TransformType(TLB, 4003 OldExpansionTL.getPatternLoc()); 4004 if (Result.isNull()) 4005 return 0; 4006 4007 Result = RebuildPackExpansionType(Result, 4008 OldExpansionTL.getPatternLoc().getSourceRange(), 4009 OldExpansionTL.getEllipsisLoc(), 4010 NumExpansions); 4011 if (Result.isNull()) 4012 return 0; 4013 4014 PackExpansionTypeLoc NewExpansionTL 4015 = TLB.push<PackExpansionTypeLoc>(Result); 4016 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); 4017 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result); 4018 } else 4019 NewDI = getDerived().TransformType(OldDI); 4020 if (!NewDI) 4021 return 0; 4022 4023 if (NewDI == OldDI && indexAdjustment == 0) 4024 return OldParm; 4025 4026 ParmVarDecl *newParm = ParmVarDecl::Create(SemaRef.Context, 4027 OldParm->getDeclContext(), 4028 OldParm->getInnerLocStart(), 4029 OldParm->getLocation(), 4030 OldParm->getIdentifier(), 4031 NewDI->getType(), 4032 NewDI, 4033 OldParm->getStorageClass(), 4034 /* DefArg */ NULL); 4035 newParm->setScopeInfo(OldParm->getFunctionScopeDepth(), 4036 OldParm->getFunctionScopeIndex() + indexAdjustment); 4037 return newParm; 4038} 4039 4040template<typename Derived> 4041bool TreeTransform<Derived>:: 4042 TransformFunctionTypeParams(SourceLocation Loc, 4043 ParmVarDecl **Params, unsigned NumParams, 4044 const QualType *ParamTypes, 4045 SmallVectorImpl<QualType> &OutParamTypes, 4046 SmallVectorImpl<ParmVarDecl*> *PVars) { 4047 int indexAdjustment = 0; 4048 4049 for (unsigned i = 0; i != NumParams; ++i) { 4050 if (ParmVarDecl *OldParm = Params[i]) { 4051 assert(OldParm->getFunctionScopeIndex() == i); 4052 4053 Optional<unsigned> NumExpansions; 4054 ParmVarDecl *NewParm = 0; 4055 if (OldParm->isParameterPack()) { 4056 // We have a function parameter pack that may need to be expanded. 4057 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4058 4059 // Find the parameter packs that could be expanded. 4060 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); 4061 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>(); 4062 TypeLoc Pattern = ExpansionTL.getPatternLoc(); 4063 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 4064 assert(Unexpanded.size() > 0 && "Could not find parameter packs!"); 4065 4066 // Determine whether we should expand the parameter packs. 4067 bool ShouldExpand = false; 4068 bool RetainExpansion = false; 4069 Optional<unsigned> OrigNumExpansions = 4070 ExpansionTL.getTypePtr()->getNumExpansions(); 4071 NumExpansions = OrigNumExpansions; 4072 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 4073 Pattern.getSourceRange(), 4074 Unexpanded, 4075 ShouldExpand, 4076 RetainExpansion, 4077 NumExpansions)) { 4078 return true; 4079 } 4080 4081 if (ShouldExpand) { 4082 // Expand the function parameter pack into multiple, separate 4083 // parameters. 4084 getDerived().ExpandingFunctionParameterPack(OldParm); 4085 for (unsigned I = 0; I != *NumExpansions; ++I) { 4086 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4087 ParmVarDecl *NewParm 4088 = getDerived().TransformFunctionTypeParam(OldParm, 4089 indexAdjustment++, 4090 OrigNumExpansions, 4091 /*ExpectParameterPack=*/false); 4092 if (!NewParm) 4093 return true; 4094 4095 OutParamTypes.push_back(NewParm->getType()); 4096 if (PVars) 4097 PVars->push_back(NewParm); 4098 } 4099 4100 // If we're supposed to retain a pack expansion, do so by temporarily 4101 // forgetting the partially-substituted parameter pack. 4102 if (RetainExpansion) { 4103 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4104 ParmVarDecl *NewParm 4105 = getDerived().TransformFunctionTypeParam(OldParm, 4106 indexAdjustment++, 4107 OrigNumExpansions, 4108 /*ExpectParameterPack=*/false); 4109 if (!NewParm) 4110 return true; 4111 4112 OutParamTypes.push_back(NewParm->getType()); 4113 if (PVars) 4114 PVars->push_back(NewParm); 4115 } 4116 4117 // The next parameter should have the same adjustment as the 4118 // last thing we pushed, but we post-incremented indexAdjustment 4119 // on every push. Also, if we push nothing, the adjustment should 4120 // go down by one. 4121 indexAdjustment--; 4122 4123 // We're done with the pack expansion. 4124 continue; 4125 } 4126 4127 // We'll substitute the parameter now without expanding the pack 4128 // expansion. 4129 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4130 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 4131 indexAdjustment, 4132 NumExpansions, 4133 /*ExpectParameterPack=*/true); 4134 } else { 4135 NewParm = getDerived().TransformFunctionTypeParam( 4136 OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false); 4137 } 4138 4139 if (!NewParm) 4140 return true; 4141 4142 OutParamTypes.push_back(NewParm->getType()); 4143 if (PVars) 4144 PVars->push_back(NewParm); 4145 continue; 4146 } 4147 4148 // Deal with the possibility that we don't have a parameter 4149 // declaration for this parameter. 4150 QualType OldType = ParamTypes[i]; 4151 bool IsPackExpansion = false; 4152 Optional<unsigned> NumExpansions; 4153 QualType NewType; 4154 if (const PackExpansionType *Expansion 4155 = dyn_cast<PackExpansionType>(OldType)) { 4156 // We have a function parameter pack that may need to be expanded. 4157 QualType Pattern = Expansion->getPattern(); 4158 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 4159 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 4160 4161 // Determine whether we should expand the parameter packs. 4162 bool ShouldExpand = false; 4163 bool RetainExpansion = false; 4164 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(), 4165 Unexpanded, 4166 ShouldExpand, 4167 RetainExpansion, 4168 NumExpansions)) { 4169 return true; 4170 } 4171 4172 if (ShouldExpand) { 4173 // Expand the function parameter pack into multiple, separate 4174 // parameters. 4175 for (unsigned I = 0; I != *NumExpansions; ++I) { 4176 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 4177 QualType NewType = getDerived().TransformType(Pattern); 4178 if (NewType.isNull()) 4179 return true; 4180 4181 OutParamTypes.push_back(NewType); 4182 if (PVars) 4183 PVars->push_back(0); 4184 } 4185 4186 // We're done with the pack expansion. 4187 continue; 4188 } 4189 4190 // If we're supposed to retain a pack expansion, do so by temporarily 4191 // forgetting the partially-substituted parameter pack. 4192 if (RetainExpansion) { 4193 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 4194 QualType NewType = getDerived().TransformType(Pattern); 4195 if (NewType.isNull()) 4196 return true; 4197 4198 OutParamTypes.push_back(NewType); 4199 if (PVars) 4200 PVars->push_back(0); 4201 } 4202 4203 // We'll substitute the parameter now without expanding the pack 4204 // expansion. 4205 OldType = Expansion->getPattern(); 4206 IsPackExpansion = true; 4207 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 4208 NewType = getDerived().TransformType(OldType); 4209 } else { 4210 NewType = getDerived().TransformType(OldType); 4211 } 4212 4213 if (NewType.isNull()) 4214 return true; 4215 4216 if (IsPackExpansion) 4217 NewType = getSema().Context.getPackExpansionType(NewType, 4218 NumExpansions); 4219 4220 OutParamTypes.push_back(NewType); 4221 if (PVars) 4222 PVars->push_back(0); 4223 } 4224 4225#ifndef NDEBUG 4226 if (PVars) { 4227 for (unsigned i = 0, e = PVars->size(); i != e; ++i) 4228 if (ParmVarDecl *parm = (*PVars)[i]) 4229 assert(parm->getFunctionScopeIndex() == i); 4230 } 4231#endif 4232 4233 return false; 4234} 4235 4236template<typename Derived> 4237QualType 4238TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4239 FunctionProtoTypeLoc TL) { 4240 return getDerived().TransformFunctionProtoType(TLB, TL, 0, 0); 4241} 4242 4243template<typename Derived> 4244QualType 4245TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 4246 FunctionProtoTypeLoc TL, 4247 CXXRecordDecl *ThisContext, 4248 unsigned ThisTypeQuals) { 4249 // Transform the parameters and return type. 4250 // 4251 // We are required to instantiate the params and return type in source order. 4252 // When the function has a trailing return type, we instantiate the 4253 // parameters before the return type, since the return type can then refer 4254 // to the parameters themselves (via decltype, sizeof, etc.). 4255 // 4256 SmallVector<QualType, 4> ParamTypes; 4257 SmallVector<ParmVarDecl*, 4> ParamDecls; 4258 const FunctionProtoType *T = TL.getTypePtr(); 4259 4260 QualType ResultType; 4261 4262 if (T->hasTrailingReturn()) { 4263 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 4264 TL.getParmArray(), 4265 TL.getNumArgs(), 4266 TL.getTypePtr()->arg_type_begin(), 4267 ParamTypes, &ParamDecls)) 4268 return QualType(); 4269 4270 { 4271 // C++11 [expr.prim.general]p3: 4272 // If a declaration declares a member function or member function 4273 // template of a class X, the expression this is a prvalue of type 4274 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq 4275 // and the end of the function-definition, member-declarator, or 4276 // declarator. 4277 Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, ThisTypeQuals); 4278 4279 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4280 if (ResultType.isNull()) 4281 return QualType(); 4282 } 4283 } 4284 else { 4285 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4286 if (ResultType.isNull()) 4287 return QualType(); 4288 4289 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 4290 TL.getParmArray(), 4291 TL.getNumArgs(), 4292 TL.getTypePtr()->arg_type_begin(), 4293 ParamTypes, &ParamDecls)) 4294 return QualType(); 4295 } 4296 4297 // FIXME: Need to transform the exception-specification too. 4298 4299 QualType Result = TL.getType(); 4300 if (getDerived().AlwaysRebuild() || 4301 ResultType != T->getResultType() || 4302 T->getNumArgs() != ParamTypes.size() || 4303 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 4304 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, 4305 T->getExtProtoInfo()); 4306 if (Result.isNull()) 4307 return QualType(); 4308 } 4309 4310 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 4311 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4312 NewTL.setLParenLoc(TL.getLParenLoc()); 4313 NewTL.setRParenLoc(TL.getRParenLoc()); 4314 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4315 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 4316 NewTL.setArg(i, ParamDecls[i]); 4317 4318 return Result; 4319} 4320 4321template<typename Derived> 4322QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 4323 TypeLocBuilder &TLB, 4324 FunctionNoProtoTypeLoc TL) { 4325 const FunctionNoProtoType *T = TL.getTypePtr(); 4326 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 4327 if (ResultType.isNull()) 4328 return QualType(); 4329 4330 QualType Result = TL.getType(); 4331 if (getDerived().AlwaysRebuild() || 4332 ResultType != T->getResultType()) 4333 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 4334 4335 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 4336 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin()); 4337 NewTL.setLParenLoc(TL.getLParenLoc()); 4338 NewTL.setRParenLoc(TL.getRParenLoc()); 4339 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd()); 4340 4341 return Result; 4342} 4343 4344template<typename Derived> QualType 4345TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 4346 UnresolvedUsingTypeLoc TL) { 4347 const UnresolvedUsingType *T = TL.getTypePtr(); 4348 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 4349 if (!D) 4350 return QualType(); 4351 4352 QualType Result = TL.getType(); 4353 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 4354 Result = getDerived().RebuildUnresolvedUsingType(D); 4355 if (Result.isNull()) 4356 return QualType(); 4357 } 4358 4359 // We might get an arbitrary type spec type back. We should at 4360 // least always get a type spec type, though. 4361 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 4362 NewTL.setNameLoc(TL.getNameLoc()); 4363 4364 return Result; 4365} 4366 4367template<typename Derived> 4368QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 4369 TypedefTypeLoc TL) { 4370 const TypedefType *T = TL.getTypePtr(); 4371 TypedefNameDecl *Typedef 4372 = cast_or_null<TypedefNameDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4373 T->getDecl())); 4374 if (!Typedef) 4375 return QualType(); 4376 4377 QualType Result = TL.getType(); 4378 if (getDerived().AlwaysRebuild() || 4379 Typedef != T->getDecl()) { 4380 Result = getDerived().RebuildTypedefType(Typedef); 4381 if (Result.isNull()) 4382 return QualType(); 4383 } 4384 4385 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 4386 NewTL.setNameLoc(TL.getNameLoc()); 4387 4388 return Result; 4389} 4390 4391template<typename Derived> 4392QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 4393 TypeOfExprTypeLoc TL) { 4394 // typeof expressions are not potentially evaluated contexts 4395 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 4396 Sema::ReuseLambdaContextDecl); 4397 4398 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 4399 if (E.isInvalid()) 4400 return QualType(); 4401 4402 E = SemaRef.HandleExprEvaluationContextForTypeof(E.get()); 4403 if (E.isInvalid()) 4404 return QualType(); 4405 4406 QualType Result = TL.getType(); 4407 if (getDerived().AlwaysRebuild() || 4408 E.get() != TL.getUnderlyingExpr()) { 4409 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 4410 if (Result.isNull()) 4411 return QualType(); 4412 } 4413 else E.take(); 4414 4415 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 4416 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4417 NewTL.setLParenLoc(TL.getLParenLoc()); 4418 NewTL.setRParenLoc(TL.getRParenLoc()); 4419 4420 return Result; 4421} 4422 4423template<typename Derived> 4424QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 4425 TypeOfTypeLoc TL) { 4426 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 4427 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 4428 if (!New_Under_TI) 4429 return QualType(); 4430 4431 QualType Result = TL.getType(); 4432 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 4433 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 4434 if (Result.isNull()) 4435 return QualType(); 4436 } 4437 4438 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 4439 NewTL.setTypeofLoc(TL.getTypeofLoc()); 4440 NewTL.setLParenLoc(TL.getLParenLoc()); 4441 NewTL.setRParenLoc(TL.getRParenLoc()); 4442 NewTL.setUnderlyingTInfo(New_Under_TI); 4443 4444 return Result; 4445} 4446 4447template<typename Derived> 4448QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 4449 DecltypeTypeLoc TL) { 4450 const DecltypeType *T = TL.getTypePtr(); 4451 4452 // decltype expressions are not potentially evaluated contexts 4453 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 0, 4454 /*IsDecltype=*/ true); 4455 4456 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 4457 if (E.isInvalid()) 4458 return QualType(); 4459 4460 E = getSema().ActOnDecltypeExpression(E.take()); 4461 if (E.isInvalid()) 4462 return QualType(); 4463 4464 QualType Result = TL.getType(); 4465 if (getDerived().AlwaysRebuild() || 4466 E.get() != T->getUnderlyingExpr()) { 4467 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 4468 if (Result.isNull()) 4469 return QualType(); 4470 } 4471 else E.take(); 4472 4473 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 4474 NewTL.setNameLoc(TL.getNameLoc()); 4475 4476 return Result; 4477} 4478 4479template<typename Derived> 4480QualType TreeTransform<Derived>::TransformUnaryTransformType( 4481 TypeLocBuilder &TLB, 4482 UnaryTransformTypeLoc TL) { 4483 QualType Result = TL.getType(); 4484 if (Result->isDependentType()) { 4485 const UnaryTransformType *T = TL.getTypePtr(); 4486 QualType NewBase = 4487 getDerived().TransformType(TL.getUnderlyingTInfo())->getType(); 4488 Result = getDerived().RebuildUnaryTransformType(NewBase, 4489 T->getUTTKind(), 4490 TL.getKWLoc()); 4491 if (Result.isNull()) 4492 return QualType(); 4493 } 4494 4495 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result); 4496 NewTL.setKWLoc(TL.getKWLoc()); 4497 NewTL.setParensRange(TL.getParensRange()); 4498 NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo()); 4499 return Result; 4500} 4501 4502template<typename Derived> 4503QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, 4504 AutoTypeLoc TL) { 4505 const AutoType *T = TL.getTypePtr(); 4506 QualType OldDeduced = T->getDeducedType(); 4507 QualType NewDeduced; 4508 if (!OldDeduced.isNull()) { 4509 NewDeduced = getDerived().TransformType(OldDeduced); 4510 if (NewDeduced.isNull()) 4511 return QualType(); 4512 } 4513 4514 QualType Result = TL.getType(); 4515 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced || 4516 T->isDependentType()) { 4517 Result = getDerived().RebuildAutoType(NewDeduced, T->isDecltypeAuto()); 4518 if (Result.isNull()) 4519 return QualType(); 4520 } 4521 4522 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 4523 NewTL.setNameLoc(TL.getNameLoc()); 4524 4525 return Result; 4526} 4527 4528template<typename Derived> 4529QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 4530 RecordTypeLoc TL) { 4531 const RecordType *T = TL.getTypePtr(); 4532 RecordDecl *Record 4533 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4534 T->getDecl())); 4535 if (!Record) 4536 return QualType(); 4537 4538 QualType Result = TL.getType(); 4539 if (getDerived().AlwaysRebuild() || 4540 Record != T->getDecl()) { 4541 Result = getDerived().RebuildRecordType(Record); 4542 if (Result.isNull()) 4543 return QualType(); 4544 } 4545 4546 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 4547 NewTL.setNameLoc(TL.getNameLoc()); 4548 4549 return Result; 4550} 4551 4552template<typename Derived> 4553QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 4554 EnumTypeLoc TL) { 4555 const EnumType *T = TL.getTypePtr(); 4556 EnumDecl *Enum 4557 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4558 T->getDecl())); 4559 if (!Enum) 4560 return QualType(); 4561 4562 QualType Result = TL.getType(); 4563 if (getDerived().AlwaysRebuild() || 4564 Enum != T->getDecl()) { 4565 Result = getDerived().RebuildEnumType(Enum); 4566 if (Result.isNull()) 4567 return QualType(); 4568 } 4569 4570 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 4571 NewTL.setNameLoc(TL.getNameLoc()); 4572 4573 return Result; 4574} 4575 4576template<typename Derived> 4577QualType TreeTransform<Derived>::TransformInjectedClassNameType( 4578 TypeLocBuilder &TLB, 4579 InjectedClassNameTypeLoc TL) { 4580 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 4581 TL.getTypePtr()->getDecl()); 4582 if (!D) return QualType(); 4583 4584 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 4585 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 4586 return T; 4587} 4588 4589template<typename Derived> 4590QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 4591 TypeLocBuilder &TLB, 4592 TemplateTypeParmTypeLoc TL) { 4593 return TransformTypeSpecType(TLB, TL); 4594} 4595 4596template<typename Derived> 4597QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 4598 TypeLocBuilder &TLB, 4599 SubstTemplateTypeParmTypeLoc TL) { 4600 const SubstTemplateTypeParmType *T = TL.getTypePtr(); 4601 4602 // Substitute into the replacement type, which itself might involve something 4603 // that needs to be transformed. This only tends to occur with default 4604 // template arguments of template template parameters. 4605 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName()); 4606 QualType Replacement = getDerived().TransformType(T->getReplacementType()); 4607 if (Replacement.isNull()) 4608 return QualType(); 4609 4610 // Always canonicalize the replacement type. 4611 Replacement = SemaRef.Context.getCanonicalType(Replacement); 4612 QualType Result 4613 = SemaRef.Context.getSubstTemplateTypeParmType(T->getReplacedParameter(), 4614 Replacement); 4615 4616 // Propagate type-source information. 4617 SubstTemplateTypeParmTypeLoc NewTL 4618 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result); 4619 NewTL.setNameLoc(TL.getNameLoc()); 4620 return Result; 4621 4622} 4623 4624template<typename Derived> 4625QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( 4626 TypeLocBuilder &TLB, 4627 SubstTemplateTypeParmPackTypeLoc TL) { 4628 return TransformTypeSpecType(TLB, TL); 4629} 4630 4631template<typename Derived> 4632QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4633 TypeLocBuilder &TLB, 4634 TemplateSpecializationTypeLoc TL) { 4635 const TemplateSpecializationType *T = TL.getTypePtr(); 4636 4637 // The nested-name-specifier never matters in a TemplateSpecializationType, 4638 // because we can't have a dependent nested-name-specifier anyway. 4639 CXXScopeSpec SS; 4640 TemplateName Template 4641 = getDerived().TransformTemplateName(SS, T->getTemplateName(), 4642 TL.getTemplateNameLoc()); 4643 if (Template.isNull()) 4644 return QualType(); 4645 4646 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 4647} 4648 4649template<typename Derived> 4650QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB, 4651 AtomicTypeLoc TL) { 4652 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc()); 4653 if (ValueType.isNull()) 4654 return QualType(); 4655 4656 QualType Result = TL.getType(); 4657 if (getDerived().AlwaysRebuild() || 4658 ValueType != TL.getValueLoc().getType()) { 4659 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc()); 4660 if (Result.isNull()) 4661 return QualType(); 4662 } 4663 4664 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(Result); 4665 NewTL.setKWLoc(TL.getKWLoc()); 4666 NewTL.setLParenLoc(TL.getLParenLoc()); 4667 NewTL.setRParenLoc(TL.getRParenLoc()); 4668 4669 return Result; 4670} 4671 4672 /// \brief Simple iterator that traverses the template arguments in a 4673 /// container that provides a \c getArgLoc() member function. 4674 /// 4675 /// This iterator is intended to be used with the iterator form of 4676 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 4677 template<typename ArgLocContainer> 4678 class TemplateArgumentLocContainerIterator { 4679 ArgLocContainer *Container; 4680 unsigned Index; 4681 4682 public: 4683 typedef TemplateArgumentLoc value_type; 4684 typedef TemplateArgumentLoc reference; 4685 typedef int difference_type; 4686 typedef std::input_iterator_tag iterator_category; 4687 4688 class pointer { 4689 TemplateArgumentLoc Arg; 4690 4691 public: 4692 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 4693 4694 const TemplateArgumentLoc *operator->() const { 4695 return &Arg; 4696 } 4697 }; 4698 4699 4700 TemplateArgumentLocContainerIterator() {} 4701 4702 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 4703 unsigned Index) 4704 : Container(&Container), Index(Index) { } 4705 4706 TemplateArgumentLocContainerIterator &operator++() { 4707 ++Index; 4708 return *this; 4709 } 4710 4711 TemplateArgumentLocContainerIterator operator++(int) { 4712 TemplateArgumentLocContainerIterator Old(*this); 4713 ++(*this); 4714 return Old; 4715 } 4716 4717 TemplateArgumentLoc operator*() const { 4718 return Container->getArgLoc(Index); 4719 } 4720 4721 pointer operator->() const { 4722 return pointer(Container->getArgLoc(Index)); 4723 } 4724 4725 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 4726 const TemplateArgumentLocContainerIterator &Y) { 4727 return X.Container == Y.Container && X.Index == Y.Index; 4728 } 4729 4730 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 4731 const TemplateArgumentLocContainerIterator &Y) { 4732 return !(X == Y); 4733 } 4734 }; 4735 4736 4737template <typename Derived> 4738QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4739 TypeLocBuilder &TLB, 4740 TemplateSpecializationTypeLoc TL, 4741 TemplateName Template) { 4742 TemplateArgumentListInfo NewTemplateArgs; 4743 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4744 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4745 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 4746 ArgIterator; 4747 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4748 ArgIterator(TL, TL.getNumArgs()), 4749 NewTemplateArgs)) 4750 return QualType(); 4751 4752 // FIXME: maybe don't rebuild if all the template arguments are the same. 4753 4754 QualType Result = 4755 getDerived().RebuildTemplateSpecializationType(Template, 4756 TL.getTemplateNameLoc(), 4757 NewTemplateArgs); 4758 4759 if (!Result.isNull()) { 4760 // Specializations of template template parameters are represented as 4761 // TemplateSpecializationTypes, and substitution of type alias templates 4762 // within a dependent context can transform them into 4763 // DependentTemplateSpecializationTypes. 4764 if (isa<DependentTemplateSpecializationType>(Result)) { 4765 DependentTemplateSpecializationTypeLoc NewTL 4766 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4767 NewTL.setElaboratedKeywordLoc(SourceLocation()); 4768 NewTL.setQualifierLoc(NestedNameSpecifierLoc()); 4769 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4770 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4771 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4772 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4773 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4774 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4775 return Result; 4776 } 4777 4778 TemplateSpecializationTypeLoc NewTL 4779 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4780 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4781 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4782 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4783 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4784 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4785 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4786 } 4787 4788 return Result; 4789} 4790 4791template <typename Derived> 4792QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( 4793 TypeLocBuilder &TLB, 4794 DependentTemplateSpecializationTypeLoc TL, 4795 TemplateName Template, 4796 CXXScopeSpec &SS) { 4797 TemplateArgumentListInfo NewTemplateArgs; 4798 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4799 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4800 typedef TemplateArgumentLocContainerIterator< 4801 DependentTemplateSpecializationTypeLoc> ArgIterator; 4802 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4803 ArgIterator(TL, TL.getNumArgs()), 4804 NewTemplateArgs)) 4805 return QualType(); 4806 4807 // FIXME: maybe don't rebuild if all the template arguments are the same. 4808 4809 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 4810 QualType Result 4811 = getSema().Context.getDependentTemplateSpecializationType( 4812 TL.getTypePtr()->getKeyword(), 4813 DTN->getQualifier(), 4814 DTN->getIdentifier(), 4815 NewTemplateArgs); 4816 4817 DependentTemplateSpecializationTypeLoc NewTL 4818 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4819 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4820 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context)); 4821 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4822 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4823 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4824 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4825 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4826 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4827 return Result; 4828 } 4829 4830 QualType Result 4831 = getDerived().RebuildTemplateSpecializationType(Template, 4832 TL.getTemplateNameLoc(), 4833 NewTemplateArgs); 4834 4835 if (!Result.isNull()) { 4836 /// FIXME: Wrap this in an elaborated-type-specifier? 4837 TemplateSpecializationTypeLoc NewTL 4838 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4839 NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 4840 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4841 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4842 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4843 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4844 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4845 } 4846 4847 return Result; 4848} 4849 4850template<typename Derived> 4851QualType 4852TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 4853 ElaboratedTypeLoc TL) { 4854 const ElaboratedType *T = TL.getTypePtr(); 4855 4856 NestedNameSpecifierLoc QualifierLoc; 4857 // NOTE: the qualifier in an ElaboratedType is optional. 4858 if (TL.getQualifierLoc()) { 4859 QualifierLoc 4860 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4861 if (!QualifierLoc) 4862 return QualType(); 4863 } 4864 4865 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 4866 if (NamedT.isNull()) 4867 return QualType(); 4868 4869 // C++0x [dcl.type.elab]p2: 4870 // If the identifier resolves to a typedef-name or the simple-template-id 4871 // resolves to an alias template specialization, the 4872 // elaborated-type-specifier is ill-formed. 4873 if (T->getKeyword() != ETK_None && T->getKeyword() != ETK_Typename) { 4874 if (const TemplateSpecializationType *TST = 4875 NamedT->getAs<TemplateSpecializationType>()) { 4876 TemplateName Template = TST->getTemplateName(); 4877 if (TypeAliasTemplateDecl *TAT = 4878 dyn_cast_or_null<TypeAliasTemplateDecl>(Template.getAsTemplateDecl())) { 4879 SemaRef.Diag(TL.getNamedTypeLoc().getBeginLoc(), 4880 diag::err_tag_reference_non_tag) << 4; 4881 SemaRef.Diag(TAT->getLocation(), diag::note_declared_at); 4882 } 4883 } 4884 } 4885 4886 QualType Result = TL.getType(); 4887 if (getDerived().AlwaysRebuild() || 4888 QualifierLoc != TL.getQualifierLoc() || 4889 NamedT != T->getNamedType()) { 4890 Result = getDerived().RebuildElaboratedType(TL.getElaboratedKeywordLoc(), 4891 T->getKeyword(), 4892 QualifierLoc, NamedT); 4893 if (Result.isNull()) 4894 return QualType(); 4895 } 4896 4897 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4898 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4899 NewTL.setQualifierLoc(QualifierLoc); 4900 return Result; 4901} 4902 4903template<typename Derived> 4904QualType TreeTransform<Derived>::TransformAttributedType( 4905 TypeLocBuilder &TLB, 4906 AttributedTypeLoc TL) { 4907 const AttributedType *oldType = TL.getTypePtr(); 4908 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); 4909 if (modifiedType.isNull()) 4910 return QualType(); 4911 4912 QualType result = TL.getType(); 4913 4914 // FIXME: dependent operand expressions? 4915 if (getDerived().AlwaysRebuild() || 4916 modifiedType != oldType->getModifiedType()) { 4917 // TODO: this is really lame; we should really be rebuilding the 4918 // equivalent type from first principles. 4919 QualType equivalentType 4920 = getDerived().TransformType(oldType->getEquivalentType()); 4921 if (equivalentType.isNull()) 4922 return QualType(); 4923 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), 4924 modifiedType, 4925 equivalentType); 4926 } 4927 4928 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); 4929 newTL.setAttrNameLoc(TL.getAttrNameLoc()); 4930 if (TL.hasAttrOperand()) 4931 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); 4932 if (TL.hasAttrExprOperand()) 4933 newTL.setAttrExprOperand(TL.getAttrExprOperand()); 4934 else if (TL.hasAttrEnumOperand()) 4935 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc()); 4936 4937 return result; 4938} 4939 4940template<typename Derived> 4941QualType 4942TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 4943 ParenTypeLoc TL) { 4944 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 4945 if (Inner.isNull()) 4946 return QualType(); 4947 4948 QualType Result = TL.getType(); 4949 if (getDerived().AlwaysRebuild() || 4950 Inner != TL.getInnerLoc().getType()) { 4951 Result = getDerived().RebuildParenType(Inner); 4952 if (Result.isNull()) 4953 return QualType(); 4954 } 4955 4956 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 4957 NewTL.setLParenLoc(TL.getLParenLoc()); 4958 NewTL.setRParenLoc(TL.getRParenLoc()); 4959 return Result; 4960} 4961 4962template<typename Derived> 4963QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 4964 DependentNameTypeLoc TL) { 4965 const DependentNameType *T = TL.getTypePtr(); 4966 4967 NestedNameSpecifierLoc QualifierLoc 4968 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4969 if (!QualifierLoc) 4970 return QualType(); 4971 4972 QualType Result 4973 = getDerived().RebuildDependentNameType(T->getKeyword(), 4974 TL.getElaboratedKeywordLoc(), 4975 QualifierLoc, 4976 T->getIdentifier(), 4977 TL.getNameLoc()); 4978 if (Result.isNull()) 4979 return QualType(); 4980 4981 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 4982 QualType NamedT = ElabT->getNamedType(); 4983 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 4984 4985 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4986 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4987 NewTL.setQualifierLoc(QualifierLoc); 4988 } else { 4989 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 4990 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 4991 NewTL.setQualifierLoc(QualifierLoc); 4992 NewTL.setNameLoc(TL.getNameLoc()); 4993 } 4994 return Result; 4995} 4996 4997template<typename Derived> 4998QualType TreeTransform<Derived>:: 4999 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5000 DependentTemplateSpecializationTypeLoc TL) { 5001 NestedNameSpecifierLoc QualifierLoc; 5002 if (TL.getQualifierLoc()) { 5003 QualifierLoc 5004 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 5005 if (!QualifierLoc) 5006 return QualType(); 5007 } 5008 5009 return getDerived() 5010 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc); 5011} 5012 5013template<typename Derived> 5014QualType TreeTransform<Derived>:: 5015TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 5016 DependentTemplateSpecializationTypeLoc TL, 5017 NestedNameSpecifierLoc QualifierLoc) { 5018 const DependentTemplateSpecializationType *T = TL.getTypePtr(); 5019 5020 TemplateArgumentListInfo NewTemplateArgs; 5021 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 5022 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 5023 5024 typedef TemplateArgumentLocContainerIterator< 5025 DependentTemplateSpecializationTypeLoc> ArgIterator; 5026 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 5027 ArgIterator(TL, TL.getNumArgs()), 5028 NewTemplateArgs)) 5029 return QualType(); 5030 5031 QualType Result 5032 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 5033 QualifierLoc, 5034 T->getIdentifier(), 5035 TL.getTemplateNameLoc(), 5036 NewTemplateArgs); 5037 if (Result.isNull()) 5038 return QualType(); 5039 5040 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 5041 QualType NamedT = ElabT->getNamedType(); 5042 5043 // Copy information relevant to the template specialization. 5044 TemplateSpecializationTypeLoc NamedTL 5045 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 5046 NamedTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5047 NamedTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5048 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 5049 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 5050 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5051 NamedTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5052 5053 // Copy information relevant to the elaborated type. 5054 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 5055 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5056 NewTL.setQualifierLoc(QualifierLoc); 5057 } else if (isa<DependentTemplateSpecializationType>(Result)) { 5058 DependentTemplateSpecializationTypeLoc SpecTL 5059 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 5060 SpecTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc()); 5061 SpecTL.setQualifierLoc(QualifierLoc); 5062 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5063 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5064 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5065 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5066 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5067 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5068 } else { 5069 TemplateSpecializationTypeLoc SpecTL 5070 = TLB.push<TemplateSpecializationTypeLoc>(Result); 5071 SpecTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc()); 5072 SpecTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 5073 SpecTL.setLAngleLoc(TL.getLAngleLoc()); 5074 SpecTL.setRAngleLoc(TL.getRAngleLoc()); 5075 for (unsigned I = 0, E = NewTemplateArgs.size(); I != E; ++I) 5076 SpecTL.setArgLocInfo(I, NewTemplateArgs[I].getLocInfo()); 5077 } 5078 return Result; 5079} 5080 5081template<typename Derived> 5082QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 5083 PackExpansionTypeLoc TL) { 5084 QualType Pattern 5085 = getDerived().TransformType(TLB, TL.getPatternLoc()); 5086 if (Pattern.isNull()) 5087 return QualType(); 5088 5089 QualType Result = TL.getType(); 5090 if (getDerived().AlwaysRebuild() || 5091 Pattern != TL.getPatternLoc().getType()) { 5092 Result = getDerived().RebuildPackExpansionType(Pattern, 5093 TL.getPatternLoc().getSourceRange(), 5094 TL.getEllipsisLoc(), 5095 TL.getTypePtr()->getNumExpansions()); 5096 if (Result.isNull()) 5097 return QualType(); 5098 } 5099 5100 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); 5101 NewT.setEllipsisLoc(TL.getEllipsisLoc()); 5102 return Result; 5103} 5104 5105template<typename Derived> 5106QualType 5107TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 5108 ObjCInterfaceTypeLoc TL) { 5109 // ObjCInterfaceType is never dependent. 5110 TLB.pushFullCopy(TL); 5111 return TL.getType(); 5112} 5113 5114template<typename Derived> 5115QualType 5116TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 5117 ObjCObjectTypeLoc TL) { 5118 // ObjCObjectType is never dependent. 5119 TLB.pushFullCopy(TL); 5120 return TL.getType(); 5121} 5122 5123template<typename Derived> 5124QualType 5125TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 5126 ObjCObjectPointerTypeLoc TL) { 5127 // ObjCObjectPointerType is never dependent. 5128 TLB.pushFullCopy(TL); 5129 return TL.getType(); 5130} 5131 5132//===----------------------------------------------------------------------===// 5133// Statement transformation 5134//===----------------------------------------------------------------------===// 5135template<typename Derived> 5136StmtResult 5137TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 5138 return SemaRef.Owned(S); 5139} 5140 5141template<typename Derived> 5142StmtResult 5143TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 5144 return getDerived().TransformCompoundStmt(S, false); 5145} 5146 5147template<typename Derived> 5148StmtResult 5149TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 5150 bool IsStmtExpr) { 5151 Sema::CompoundScopeRAII CompoundScope(getSema()); 5152 5153 bool SubStmtInvalid = false; 5154 bool SubStmtChanged = false; 5155 SmallVector<Stmt*, 8> Statements; 5156 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 5157 B != BEnd; ++B) { 5158 StmtResult Result = getDerived().TransformStmt(*B); 5159 if (Result.isInvalid()) { 5160 // Immediately fail if this was a DeclStmt, since it's very 5161 // likely that this will cause problems for future statements. 5162 if (isa<DeclStmt>(*B)) 5163 return StmtError(); 5164 5165 // Otherwise, just keep processing substatements and fail later. 5166 SubStmtInvalid = true; 5167 continue; 5168 } 5169 5170 SubStmtChanged = SubStmtChanged || Result.get() != *B; 5171 Statements.push_back(Result.takeAs<Stmt>()); 5172 } 5173 5174 if (SubStmtInvalid) 5175 return StmtError(); 5176 5177 if (!getDerived().AlwaysRebuild() && 5178 !SubStmtChanged) 5179 return SemaRef.Owned(S); 5180 5181 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 5182 Statements, 5183 S->getRBracLoc(), 5184 IsStmtExpr); 5185} 5186 5187template<typename Derived> 5188StmtResult 5189TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 5190 ExprResult LHS, RHS; 5191 { 5192 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5193 Sema::ConstantEvaluated); 5194 5195 // Transform the left-hand case value. 5196 LHS = getDerived().TransformExpr(S->getLHS()); 5197 LHS = SemaRef.ActOnConstantExpression(LHS); 5198 if (LHS.isInvalid()) 5199 return StmtError(); 5200 5201 // Transform the right-hand case value (for the GNU case-range extension). 5202 RHS = getDerived().TransformExpr(S->getRHS()); 5203 RHS = SemaRef.ActOnConstantExpression(RHS); 5204 if (RHS.isInvalid()) 5205 return StmtError(); 5206 } 5207 5208 // Build the case statement. 5209 // Case statements are always rebuilt so that they will attached to their 5210 // transformed switch statement. 5211 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 5212 LHS.get(), 5213 S->getEllipsisLoc(), 5214 RHS.get(), 5215 S->getColonLoc()); 5216 if (Case.isInvalid()) 5217 return StmtError(); 5218 5219 // Transform the statement following the case 5220 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5221 if (SubStmt.isInvalid()) 5222 return StmtError(); 5223 5224 // Attach the body to the case statement 5225 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 5226} 5227 5228template<typename Derived> 5229StmtResult 5230TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 5231 // Transform the statement following the default case 5232 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5233 if (SubStmt.isInvalid()) 5234 return StmtError(); 5235 5236 // Default statements are always rebuilt 5237 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 5238 SubStmt.get()); 5239} 5240 5241template<typename Derived> 5242StmtResult 5243TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 5244 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5245 if (SubStmt.isInvalid()) 5246 return StmtError(); 5247 5248 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), 5249 S->getDecl()); 5250 if (!LD) 5251 return StmtError(); 5252 5253 5254 // FIXME: Pass the real colon location in. 5255 return getDerived().RebuildLabelStmt(S->getIdentLoc(), 5256 cast<LabelDecl>(LD), SourceLocation(), 5257 SubStmt.get()); 5258} 5259 5260template<typename Derived> 5261StmtResult 5262TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S) { 5263 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 5264 if (SubStmt.isInvalid()) 5265 return StmtError(); 5266 5267 // TODO: transform attributes 5268 if (SubStmt.get() == S->getSubStmt() /* && attrs are the same */) 5269 return S; 5270 5271 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), 5272 S->getAttrs(), 5273 SubStmt.get()); 5274} 5275 5276template<typename Derived> 5277StmtResult 5278TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 5279 // Transform the condition 5280 ExprResult Cond; 5281 VarDecl *ConditionVar = 0; 5282 if (S->getConditionVariable()) { 5283 ConditionVar 5284 = cast_or_null<VarDecl>( 5285 getDerived().TransformDefinition( 5286 S->getConditionVariable()->getLocation(), 5287 S->getConditionVariable())); 5288 if (!ConditionVar) 5289 return StmtError(); 5290 } else { 5291 Cond = getDerived().TransformExpr(S->getCond()); 5292 5293 if (Cond.isInvalid()) 5294 return StmtError(); 5295 5296 // Convert the condition to a boolean value. 5297 if (S->getCond()) { 5298 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), 5299 Cond.get()); 5300 if (CondE.isInvalid()) 5301 return StmtError(); 5302 5303 Cond = CondE.get(); 5304 } 5305 } 5306 5307 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5308 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5309 return StmtError(); 5310 5311 // Transform the "then" branch. 5312 StmtResult Then = getDerived().TransformStmt(S->getThen()); 5313 if (Then.isInvalid()) 5314 return StmtError(); 5315 5316 // Transform the "else" branch. 5317 StmtResult Else = getDerived().TransformStmt(S->getElse()); 5318 if (Else.isInvalid()) 5319 return StmtError(); 5320 5321 if (!getDerived().AlwaysRebuild() && 5322 FullCond.get() == S->getCond() && 5323 ConditionVar == S->getConditionVariable() && 5324 Then.get() == S->getThen() && 5325 Else.get() == S->getElse()) 5326 return SemaRef.Owned(S); 5327 5328 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 5329 Then.get(), 5330 S->getElseLoc(), Else.get()); 5331} 5332 5333template<typename Derived> 5334StmtResult 5335TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 5336 // Transform the condition. 5337 ExprResult Cond; 5338 VarDecl *ConditionVar = 0; 5339 if (S->getConditionVariable()) { 5340 ConditionVar 5341 = cast_or_null<VarDecl>( 5342 getDerived().TransformDefinition( 5343 S->getConditionVariable()->getLocation(), 5344 S->getConditionVariable())); 5345 if (!ConditionVar) 5346 return StmtError(); 5347 } else { 5348 Cond = getDerived().TransformExpr(S->getCond()); 5349 5350 if (Cond.isInvalid()) 5351 return StmtError(); 5352 } 5353 5354 // Rebuild the switch statement. 5355 StmtResult Switch 5356 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 5357 ConditionVar); 5358 if (Switch.isInvalid()) 5359 return StmtError(); 5360 5361 // Transform the body of the switch statement. 5362 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5363 if (Body.isInvalid()) 5364 return StmtError(); 5365 5366 // Complete the switch statement. 5367 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 5368 Body.get()); 5369} 5370 5371template<typename Derived> 5372StmtResult 5373TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 5374 // Transform the condition 5375 ExprResult Cond; 5376 VarDecl *ConditionVar = 0; 5377 if (S->getConditionVariable()) { 5378 ConditionVar 5379 = cast_or_null<VarDecl>( 5380 getDerived().TransformDefinition( 5381 S->getConditionVariable()->getLocation(), 5382 S->getConditionVariable())); 5383 if (!ConditionVar) 5384 return StmtError(); 5385 } else { 5386 Cond = getDerived().TransformExpr(S->getCond()); 5387 5388 if (Cond.isInvalid()) 5389 return StmtError(); 5390 5391 if (S->getCond()) { 5392 // Convert the condition to a boolean value. 5393 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), 5394 Cond.get()); 5395 if (CondE.isInvalid()) 5396 return StmtError(); 5397 Cond = CondE; 5398 } 5399 } 5400 5401 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5402 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5403 return StmtError(); 5404 5405 // Transform the body 5406 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5407 if (Body.isInvalid()) 5408 return StmtError(); 5409 5410 if (!getDerived().AlwaysRebuild() && 5411 FullCond.get() == S->getCond() && 5412 ConditionVar == S->getConditionVariable() && 5413 Body.get() == S->getBody()) 5414 return Owned(S); 5415 5416 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 5417 ConditionVar, Body.get()); 5418} 5419 5420template<typename Derived> 5421StmtResult 5422TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 5423 // Transform the body 5424 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5425 if (Body.isInvalid()) 5426 return StmtError(); 5427 5428 // Transform the condition 5429 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5430 if (Cond.isInvalid()) 5431 return StmtError(); 5432 5433 if (!getDerived().AlwaysRebuild() && 5434 Cond.get() == S->getCond() && 5435 Body.get() == S->getBody()) 5436 return SemaRef.Owned(S); 5437 5438 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 5439 /*FIXME:*/S->getWhileLoc(), Cond.get(), 5440 S->getRParenLoc()); 5441} 5442 5443template<typename Derived> 5444StmtResult 5445TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 5446 // Transform the initialization statement 5447 StmtResult Init = getDerived().TransformStmt(S->getInit()); 5448 if (Init.isInvalid()) 5449 return StmtError(); 5450 5451 // Transform the condition 5452 ExprResult Cond; 5453 VarDecl *ConditionVar = 0; 5454 if (S->getConditionVariable()) { 5455 ConditionVar 5456 = cast_or_null<VarDecl>( 5457 getDerived().TransformDefinition( 5458 S->getConditionVariable()->getLocation(), 5459 S->getConditionVariable())); 5460 if (!ConditionVar) 5461 return StmtError(); 5462 } else { 5463 Cond = getDerived().TransformExpr(S->getCond()); 5464 5465 if (Cond.isInvalid()) 5466 return StmtError(); 5467 5468 if (S->getCond()) { 5469 // Convert the condition to a boolean value. 5470 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), 5471 Cond.get()); 5472 if (CondE.isInvalid()) 5473 return StmtError(); 5474 5475 Cond = CondE.get(); 5476 } 5477 } 5478 5479 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 5480 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 5481 return StmtError(); 5482 5483 // Transform the increment 5484 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5485 if (Inc.isInvalid()) 5486 return StmtError(); 5487 5488 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get())); 5489 if (S->getInc() && !FullInc.get()) 5490 return StmtError(); 5491 5492 // Transform the body 5493 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5494 if (Body.isInvalid()) 5495 return StmtError(); 5496 5497 if (!getDerived().AlwaysRebuild() && 5498 Init.get() == S->getInit() && 5499 FullCond.get() == S->getCond() && 5500 Inc.get() == S->getInc() && 5501 Body.get() == S->getBody()) 5502 return SemaRef.Owned(S); 5503 5504 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 5505 Init.get(), FullCond, ConditionVar, 5506 FullInc, S->getRParenLoc(), Body.get()); 5507} 5508 5509template<typename Derived> 5510StmtResult 5511TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 5512 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), 5513 S->getLabel()); 5514 if (!LD) 5515 return StmtError(); 5516 5517 // Goto statements must always be rebuilt, to resolve the label. 5518 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 5519 cast<LabelDecl>(LD)); 5520} 5521 5522template<typename Derived> 5523StmtResult 5524TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 5525 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 5526 if (Target.isInvalid()) 5527 return StmtError(); 5528 Target = SemaRef.MaybeCreateExprWithCleanups(Target.take()); 5529 5530 if (!getDerived().AlwaysRebuild() && 5531 Target.get() == S->getTarget()) 5532 return SemaRef.Owned(S); 5533 5534 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 5535 Target.get()); 5536} 5537 5538template<typename Derived> 5539StmtResult 5540TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 5541 return SemaRef.Owned(S); 5542} 5543 5544template<typename Derived> 5545StmtResult 5546TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 5547 return SemaRef.Owned(S); 5548} 5549 5550template<typename Derived> 5551StmtResult 5552TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 5553 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 5554 if (Result.isInvalid()) 5555 return StmtError(); 5556 5557 // FIXME: We always rebuild the return statement because there is no way 5558 // to tell whether the return type of the function has changed. 5559 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 5560} 5561 5562template<typename Derived> 5563StmtResult 5564TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 5565 bool DeclChanged = false; 5566 SmallVector<Decl *, 4> Decls; 5567 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 5568 D != DEnd; ++D) { 5569 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 5570 *D); 5571 if (!Transformed) 5572 return StmtError(); 5573 5574 if (Transformed != *D) 5575 DeclChanged = true; 5576 5577 Decls.push_back(Transformed); 5578 } 5579 5580 if (!getDerived().AlwaysRebuild() && !DeclChanged) 5581 return SemaRef.Owned(S); 5582 5583 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 5584 S->getStartLoc(), S->getEndLoc()); 5585} 5586 5587template<typename Derived> 5588StmtResult 5589TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) { 5590 5591 SmallVector<Expr*, 8> Constraints; 5592 SmallVector<Expr*, 8> Exprs; 5593 SmallVector<IdentifierInfo *, 4> Names; 5594 5595 ExprResult AsmString; 5596 SmallVector<Expr*, 8> Clobbers; 5597 5598 bool ExprsChanged = false; 5599 5600 // Go through the outputs. 5601 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 5602 Names.push_back(S->getOutputIdentifier(I)); 5603 5604 // No need to transform the constraint literal. 5605 Constraints.push_back(S->getOutputConstraintLiteral(I)); 5606 5607 // Transform the output expr. 5608 Expr *OutputExpr = S->getOutputExpr(I); 5609 ExprResult Result = getDerived().TransformExpr(OutputExpr); 5610 if (Result.isInvalid()) 5611 return StmtError(); 5612 5613 ExprsChanged |= Result.get() != OutputExpr; 5614 5615 Exprs.push_back(Result.get()); 5616 } 5617 5618 // Go through the inputs. 5619 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 5620 Names.push_back(S->getInputIdentifier(I)); 5621 5622 // No need to transform the constraint literal. 5623 Constraints.push_back(S->getInputConstraintLiteral(I)); 5624 5625 // Transform the input expr. 5626 Expr *InputExpr = S->getInputExpr(I); 5627 ExprResult Result = getDerived().TransformExpr(InputExpr); 5628 if (Result.isInvalid()) 5629 return StmtError(); 5630 5631 ExprsChanged |= Result.get() != InputExpr; 5632 5633 Exprs.push_back(Result.get()); 5634 } 5635 5636 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 5637 return SemaRef.Owned(S); 5638 5639 // Go through the clobbers. 5640 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 5641 Clobbers.push_back(S->getClobberStringLiteral(I)); 5642 5643 // No need to transform the asm string literal. 5644 AsmString = SemaRef.Owned(S->getAsmString()); 5645 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(), 5646 S->isVolatile(), S->getNumOutputs(), 5647 S->getNumInputs(), Names.data(), 5648 Constraints, Exprs, AsmString.get(), 5649 Clobbers, S->getRParenLoc()); 5650} 5651 5652template<typename Derived> 5653StmtResult 5654TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) { 5655 ArrayRef<Token> AsmToks = 5656 llvm::makeArrayRef(S->getAsmToks(), S->getNumAsmToks()); 5657 5658 bool HadError = false, HadChange = false; 5659 5660 ArrayRef<Expr*> SrcExprs = S->getAllExprs(); 5661 SmallVector<Expr*, 8> TransformedExprs; 5662 TransformedExprs.reserve(SrcExprs.size()); 5663 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) { 5664 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]); 5665 if (!Result.isUsable()) { 5666 HadError = true; 5667 } else { 5668 HadChange |= (Result.get() != SrcExprs[i]); 5669 TransformedExprs.push_back(Result.take()); 5670 } 5671 } 5672 5673 if (HadError) return StmtError(); 5674 if (!HadChange && !getDerived().AlwaysRebuild()) 5675 return Owned(S); 5676 5677 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(), 5678 AsmToks, S->getAsmString(), 5679 S->getNumOutputs(), S->getNumInputs(), 5680 S->getAllConstraints(), S->getClobbers(), 5681 TransformedExprs, S->getEndLoc()); 5682} 5683 5684template<typename Derived> 5685StmtResult 5686TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 5687 // Transform the body of the @try. 5688 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 5689 if (TryBody.isInvalid()) 5690 return StmtError(); 5691 5692 // Transform the @catch statements (if present). 5693 bool AnyCatchChanged = false; 5694 SmallVector<Stmt*, 8> CatchStmts; 5695 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 5696 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 5697 if (Catch.isInvalid()) 5698 return StmtError(); 5699 if (Catch.get() != S->getCatchStmt(I)) 5700 AnyCatchChanged = true; 5701 CatchStmts.push_back(Catch.release()); 5702 } 5703 5704 // Transform the @finally statement (if present). 5705 StmtResult Finally; 5706 if (S->getFinallyStmt()) { 5707 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 5708 if (Finally.isInvalid()) 5709 return StmtError(); 5710 } 5711 5712 // If nothing changed, just retain this statement. 5713 if (!getDerived().AlwaysRebuild() && 5714 TryBody.get() == S->getTryBody() && 5715 !AnyCatchChanged && 5716 Finally.get() == S->getFinallyStmt()) 5717 return SemaRef.Owned(S); 5718 5719 // Build a new statement. 5720 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 5721 CatchStmts, Finally.get()); 5722} 5723 5724template<typename Derived> 5725StmtResult 5726TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 5727 // Transform the @catch parameter, if there is one. 5728 VarDecl *Var = 0; 5729 if (VarDecl *FromVar = S->getCatchParamDecl()) { 5730 TypeSourceInfo *TSInfo = 0; 5731 if (FromVar->getTypeSourceInfo()) { 5732 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 5733 if (!TSInfo) 5734 return StmtError(); 5735 } 5736 5737 QualType T; 5738 if (TSInfo) 5739 T = TSInfo->getType(); 5740 else { 5741 T = getDerived().TransformType(FromVar->getType()); 5742 if (T.isNull()) 5743 return StmtError(); 5744 } 5745 5746 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 5747 if (!Var) 5748 return StmtError(); 5749 } 5750 5751 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 5752 if (Body.isInvalid()) 5753 return StmtError(); 5754 5755 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 5756 S->getRParenLoc(), 5757 Var, Body.get()); 5758} 5759 5760template<typename Derived> 5761StmtResult 5762TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 5763 // Transform the body. 5764 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 5765 if (Body.isInvalid()) 5766 return StmtError(); 5767 5768 // If nothing changed, just retain this statement. 5769 if (!getDerived().AlwaysRebuild() && 5770 Body.get() == S->getFinallyBody()) 5771 return SemaRef.Owned(S); 5772 5773 // Build a new statement. 5774 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 5775 Body.get()); 5776} 5777 5778template<typename Derived> 5779StmtResult 5780TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5781 ExprResult Operand; 5782 if (S->getThrowExpr()) { 5783 Operand = getDerived().TransformExpr(S->getThrowExpr()); 5784 if (Operand.isInvalid()) 5785 return StmtError(); 5786 } 5787 5788 if (!getDerived().AlwaysRebuild() && 5789 Operand.get() == S->getThrowExpr()) 5790 return getSema().Owned(S); 5791 5792 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 5793} 5794 5795template<typename Derived> 5796StmtResult 5797TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 5798 ObjCAtSynchronizedStmt *S) { 5799 // Transform the object we are locking. 5800 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 5801 if (Object.isInvalid()) 5802 return StmtError(); 5803 Object = 5804 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(), 5805 Object.get()); 5806 if (Object.isInvalid()) 5807 return StmtError(); 5808 5809 // Transform the body. 5810 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 5811 if (Body.isInvalid()) 5812 return StmtError(); 5813 5814 // If nothing change, just retain the current statement. 5815 if (!getDerived().AlwaysRebuild() && 5816 Object.get() == S->getSynchExpr() && 5817 Body.get() == S->getSynchBody()) 5818 return SemaRef.Owned(S); 5819 5820 // Build a new statement. 5821 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 5822 Object.get(), Body.get()); 5823} 5824 5825template<typename Derived> 5826StmtResult 5827TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt( 5828 ObjCAutoreleasePoolStmt *S) { 5829 // Transform the body. 5830 StmtResult Body = getDerived().TransformStmt(S->getSubStmt()); 5831 if (Body.isInvalid()) 5832 return StmtError(); 5833 5834 // If nothing changed, just retain this statement. 5835 if (!getDerived().AlwaysRebuild() && 5836 Body.get() == S->getSubStmt()) 5837 return SemaRef.Owned(S); 5838 5839 // Build a new statement. 5840 return getDerived().RebuildObjCAutoreleasePoolStmt( 5841 S->getAtLoc(), Body.get()); 5842} 5843 5844template<typename Derived> 5845StmtResult 5846TreeTransform<Derived>::TransformObjCForCollectionStmt( 5847 ObjCForCollectionStmt *S) { 5848 // Transform the element statement. 5849 StmtResult Element = getDerived().TransformStmt(S->getElement()); 5850 if (Element.isInvalid()) 5851 return StmtError(); 5852 5853 // Transform the collection expression. 5854 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 5855 if (Collection.isInvalid()) 5856 return StmtError(); 5857 5858 // Transform the body. 5859 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5860 if (Body.isInvalid()) 5861 return StmtError(); 5862 5863 // If nothing changed, just retain this statement. 5864 if (!getDerived().AlwaysRebuild() && 5865 Element.get() == S->getElement() && 5866 Collection.get() == S->getCollection() && 5867 Body.get() == S->getBody()) 5868 return SemaRef.Owned(S); 5869 5870 // Build a new statement. 5871 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 5872 Element.get(), 5873 Collection.get(), 5874 S->getRParenLoc(), 5875 Body.get()); 5876} 5877 5878 5879template<typename Derived> 5880StmtResult 5881TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 5882 // Transform the exception declaration, if any. 5883 VarDecl *Var = 0; 5884 if (S->getExceptionDecl()) { 5885 VarDecl *ExceptionDecl = S->getExceptionDecl(); 5886 TypeSourceInfo *T = getDerived().TransformType( 5887 ExceptionDecl->getTypeSourceInfo()); 5888 if (!T) 5889 return StmtError(); 5890 5891 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, 5892 ExceptionDecl->getInnerLocStart(), 5893 ExceptionDecl->getLocation(), 5894 ExceptionDecl->getIdentifier()); 5895 if (!Var || Var->isInvalidDecl()) 5896 return StmtError(); 5897 } 5898 5899 // Transform the actual exception handler. 5900 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 5901 if (Handler.isInvalid()) 5902 return StmtError(); 5903 5904 if (!getDerived().AlwaysRebuild() && 5905 !Var && 5906 Handler.get() == S->getHandlerBlock()) 5907 return SemaRef.Owned(S); 5908 5909 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 5910 Var, 5911 Handler.get()); 5912} 5913 5914template<typename Derived> 5915StmtResult 5916TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 5917 // Transform the try block itself. 5918 StmtResult TryBlock 5919 = getDerived().TransformCompoundStmt(S->getTryBlock()); 5920 if (TryBlock.isInvalid()) 5921 return StmtError(); 5922 5923 // Transform the handlers. 5924 bool HandlerChanged = false; 5925 SmallVector<Stmt*, 8> Handlers; 5926 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 5927 StmtResult Handler 5928 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 5929 if (Handler.isInvalid()) 5930 return StmtError(); 5931 5932 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 5933 Handlers.push_back(Handler.takeAs<Stmt>()); 5934 } 5935 5936 if (!getDerived().AlwaysRebuild() && 5937 TryBlock.get() == S->getTryBlock() && 5938 !HandlerChanged) 5939 return SemaRef.Owned(S); 5940 5941 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 5942 Handlers); 5943} 5944 5945template<typename Derived> 5946StmtResult 5947TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) { 5948 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt()); 5949 if (Range.isInvalid()) 5950 return StmtError(); 5951 5952 StmtResult BeginEnd = getDerived().TransformStmt(S->getBeginEndStmt()); 5953 if (BeginEnd.isInvalid()) 5954 return StmtError(); 5955 5956 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 5957 if (Cond.isInvalid()) 5958 return StmtError(); 5959 if (Cond.get()) 5960 Cond = SemaRef.CheckBooleanCondition(Cond.take(), S->getColonLoc()); 5961 if (Cond.isInvalid()) 5962 return StmtError(); 5963 if (Cond.get()) 5964 Cond = SemaRef.MaybeCreateExprWithCleanups(Cond.take()); 5965 5966 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 5967 if (Inc.isInvalid()) 5968 return StmtError(); 5969 if (Inc.get()) 5970 Inc = SemaRef.MaybeCreateExprWithCleanups(Inc.take()); 5971 5972 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt()); 5973 if (LoopVar.isInvalid()) 5974 return StmtError(); 5975 5976 StmtResult NewStmt = S; 5977 if (getDerived().AlwaysRebuild() || 5978 Range.get() != S->getRangeStmt() || 5979 BeginEnd.get() != S->getBeginEndStmt() || 5980 Cond.get() != S->getCond() || 5981 Inc.get() != S->getInc() || 5982 LoopVar.get() != S->getLoopVarStmt()) { 5983 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 5984 S->getColonLoc(), Range.get(), 5985 BeginEnd.get(), Cond.get(), 5986 Inc.get(), LoopVar.get(), 5987 S->getRParenLoc()); 5988 if (NewStmt.isInvalid()) 5989 return StmtError(); 5990 } 5991 5992 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5993 if (Body.isInvalid()) 5994 return StmtError(); 5995 5996 // Body has changed but we didn't rebuild the for-range statement. Rebuild 5997 // it now so we have a new statement to attach the body to. 5998 if (Body.get() != S->getBody() && NewStmt.get() == S) { 5999 NewStmt = getDerived().RebuildCXXForRangeStmt(S->getForLoc(), 6000 S->getColonLoc(), Range.get(), 6001 BeginEnd.get(), Cond.get(), 6002 Inc.get(), LoopVar.get(), 6003 S->getRParenLoc()); 6004 if (NewStmt.isInvalid()) 6005 return StmtError(); 6006 } 6007 6008 if (NewStmt.get() == S) 6009 return SemaRef.Owned(S); 6010 6011 return FinishCXXForRangeStmt(NewStmt.get(), Body.get()); 6012} 6013 6014template<typename Derived> 6015StmtResult 6016TreeTransform<Derived>::TransformMSDependentExistsStmt( 6017 MSDependentExistsStmt *S) { 6018 // Transform the nested-name-specifier, if any. 6019 NestedNameSpecifierLoc QualifierLoc; 6020 if (S->getQualifierLoc()) { 6021 QualifierLoc 6022 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc()); 6023 if (!QualifierLoc) 6024 return StmtError(); 6025 } 6026 6027 // Transform the declaration name. 6028 DeclarationNameInfo NameInfo = S->getNameInfo(); 6029 if (NameInfo.getName()) { 6030 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6031 if (!NameInfo.getName()) 6032 return StmtError(); 6033 } 6034 6035 // Check whether anything changed. 6036 if (!getDerived().AlwaysRebuild() && 6037 QualifierLoc == S->getQualifierLoc() && 6038 NameInfo.getName() == S->getNameInfo().getName()) 6039 return S; 6040 6041 // Determine whether this name exists, if we can. 6042 CXXScopeSpec SS; 6043 SS.Adopt(QualifierLoc); 6044 bool Dependent = false; 6045 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/0, SS, NameInfo)) { 6046 case Sema::IER_Exists: 6047 if (S->isIfExists()) 6048 break; 6049 6050 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6051 6052 case Sema::IER_DoesNotExist: 6053 if (S->isIfNotExists()) 6054 break; 6055 6056 return new (getSema().Context) NullStmt(S->getKeywordLoc()); 6057 6058 case Sema::IER_Dependent: 6059 Dependent = true; 6060 break; 6061 6062 case Sema::IER_Error: 6063 return StmtError(); 6064 } 6065 6066 // We need to continue with the instantiation, so do so now. 6067 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt()); 6068 if (SubStmt.isInvalid()) 6069 return StmtError(); 6070 6071 // If we have resolved the name, just transform to the substatement. 6072 if (!Dependent) 6073 return SubStmt; 6074 6075 // The name is still dependent, so build a dependent expression again. 6076 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(), 6077 S->isIfExists(), 6078 QualifierLoc, 6079 NameInfo, 6080 SubStmt.get()); 6081} 6082 6083template<typename Derived> 6084ExprResult 6085TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) { 6086 NestedNameSpecifierLoc QualifierLoc; 6087 if (E->getQualifierLoc()) { 6088 QualifierLoc 6089 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6090 if (!QualifierLoc) 6091 return ExprError(); 6092 } 6093 6094 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>( 6095 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl())); 6096 if (!PD) 6097 return ExprError(); 6098 6099 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 6100 if (Base.isInvalid()) 6101 return ExprError(); 6102 6103 return new (SemaRef.getASTContext()) 6104 MSPropertyRefExpr(Base.get(), PD, E->isArrow(), 6105 SemaRef.getASTContext().PseudoObjectTy, VK_LValue, 6106 QualifierLoc, E->getMemberLoc()); 6107} 6108 6109template<typename Derived> 6110StmtResult 6111TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) { 6112 StmtResult TryBlock; // = getDerived().TransformCompoundStmt(S->getTryBlock()); 6113 if(TryBlock.isInvalid()) return StmtError(); 6114 6115 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler()); 6116 if(!getDerived().AlwaysRebuild() && 6117 TryBlock.get() == S->getTryBlock() && 6118 Handler.get() == S->getHandler()) 6119 return SemaRef.Owned(S); 6120 6121 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), 6122 S->getTryLoc(), 6123 TryBlock.take(), 6124 Handler.take()); 6125} 6126 6127template<typename Derived> 6128StmtResult 6129TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) { 6130 StmtResult Block; // = getDerived().TransformCompoundStatement(S->getBlock()); 6131 if(Block.isInvalid()) return StmtError(); 6132 6133 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), 6134 Block.take()); 6135} 6136 6137template<typename Derived> 6138StmtResult 6139TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) { 6140 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr()); 6141 if(FilterExpr.isInvalid()) return StmtError(); 6142 6143 StmtResult Block; // = getDerived().TransformCompoundStatement(S->getBlock()); 6144 if(Block.isInvalid()) return StmtError(); 6145 6146 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), 6147 FilterExpr.take(), 6148 Block.take()); 6149} 6150 6151template<typename Derived> 6152StmtResult 6153TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) { 6154 if(isa<SEHFinallyStmt>(Handler)) 6155 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Handler)); 6156 else 6157 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Handler)); 6158} 6159 6160//===----------------------------------------------------------------------===// 6161// Expression transformation 6162//===----------------------------------------------------------------------===// 6163template<typename Derived> 6164ExprResult 6165TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 6166 return SemaRef.Owned(E); 6167} 6168 6169template<typename Derived> 6170ExprResult 6171TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 6172 NestedNameSpecifierLoc QualifierLoc; 6173 if (E->getQualifierLoc()) { 6174 QualifierLoc 6175 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6176 if (!QualifierLoc) 6177 return ExprError(); 6178 } 6179 6180 ValueDecl *ND 6181 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 6182 E->getDecl())); 6183 if (!ND) 6184 return ExprError(); 6185 6186 DeclarationNameInfo NameInfo = E->getNameInfo(); 6187 if (NameInfo.getName()) { 6188 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 6189 if (!NameInfo.getName()) 6190 return ExprError(); 6191 } 6192 6193 if (!getDerived().AlwaysRebuild() && 6194 QualifierLoc == E->getQualifierLoc() && 6195 ND == E->getDecl() && 6196 NameInfo.getName() == E->getDecl()->getDeclName() && 6197 !E->hasExplicitTemplateArgs()) { 6198 6199 // Mark it referenced in the new context regardless. 6200 // FIXME: this is a bit instantiation-specific. 6201 SemaRef.MarkDeclRefReferenced(E); 6202 6203 return SemaRef.Owned(E); 6204 } 6205 6206 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 6207 if (E->hasExplicitTemplateArgs()) { 6208 TemplateArgs = &TransArgs; 6209 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6210 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6211 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6212 E->getNumTemplateArgs(), 6213 TransArgs)) 6214 return ExprError(); 6215 } 6216 6217 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, 6218 TemplateArgs); 6219} 6220 6221template<typename Derived> 6222ExprResult 6223TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 6224 return SemaRef.Owned(E); 6225} 6226 6227template<typename Derived> 6228ExprResult 6229TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 6230 return SemaRef.Owned(E); 6231} 6232 6233template<typename Derived> 6234ExprResult 6235TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 6236 return SemaRef.Owned(E); 6237} 6238 6239template<typename Derived> 6240ExprResult 6241TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 6242 return SemaRef.Owned(E); 6243} 6244 6245template<typename Derived> 6246ExprResult 6247TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 6248 return SemaRef.Owned(E); 6249} 6250 6251template<typename Derived> 6252ExprResult 6253TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) { 6254 if (FunctionDecl *FD = E->getDirectCallee()) 6255 SemaRef.MarkFunctionReferenced(E->getLocStart(), FD); 6256 return SemaRef.MaybeBindToTemporary(E); 6257} 6258 6259template<typename Derived> 6260ExprResult 6261TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) { 6262 ExprResult ControllingExpr = 6263 getDerived().TransformExpr(E->getControllingExpr()); 6264 if (ControllingExpr.isInvalid()) 6265 return ExprError(); 6266 6267 SmallVector<Expr *, 4> AssocExprs; 6268 SmallVector<TypeSourceInfo *, 4> AssocTypes; 6269 for (unsigned i = 0; i != E->getNumAssocs(); ++i) { 6270 TypeSourceInfo *TS = E->getAssocTypeSourceInfo(i); 6271 if (TS) { 6272 TypeSourceInfo *AssocType = getDerived().TransformType(TS); 6273 if (!AssocType) 6274 return ExprError(); 6275 AssocTypes.push_back(AssocType); 6276 } else { 6277 AssocTypes.push_back(0); 6278 } 6279 6280 ExprResult AssocExpr = getDerived().TransformExpr(E->getAssocExpr(i)); 6281 if (AssocExpr.isInvalid()) 6282 return ExprError(); 6283 AssocExprs.push_back(AssocExpr.release()); 6284 } 6285 6286 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(), 6287 E->getDefaultLoc(), 6288 E->getRParenLoc(), 6289 ControllingExpr.release(), 6290 AssocTypes, 6291 AssocExprs); 6292} 6293 6294template<typename Derived> 6295ExprResult 6296TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 6297 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6298 if (SubExpr.isInvalid()) 6299 return ExprError(); 6300 6301 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6302 return SemaRef.Owned(E); 6303 6304 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 6305 E->getRParen()); 6306} 6307 6308/// \brief The operand of a unary address-of operator has special rules: it's 6309/// allowed to refer to a non-static member of a class even if there's no 'this' 6310/// object available. 6311template<typename Derived> 6312ExprResult 6313TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) { 6314 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(E)) 6315 return getDerived().TransformDependentScopeDeclRefExpr(DRE, true); 6316 else 6317 return getDerived().TransformExpr(E); 6318} 6319 6320template<typename Derived> 6321ExprResult 6322TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 6323 ExprResult SubExpr = TransformAddressOfOperand(E->getSubExpr()); 6324 if (SubExpr.isInvalid()) 6325 return ExprError(); 6326 6327 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 6328 return SemaRef.Owned(E); 6329 6330 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 6331 E->getOpcode(), 6332 SubExpr.get()); 6333} 6334 6335template<typename Derived> 6336ExprResult 6337TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 6338 // Transform the type. 6339 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 6340 if (!Type) 6341 return ExprError(); 6342 6343 // Transform all of the components into components similar to what the 6344 // parser uses. 6345 // FIXME: It would be slightly more efficient in the non-dependent case to 6346 // just map FieldDecls, rather than requiring the rebuilder to look for 6347 // the fields again. However, __builtin_offsetof is rare enough in 6348 // template code that we don't care. 6349 bool ExprChanged = false; 6350 typedef Sema::OffsetOfComponent Component; 6351 typedef OffsetOfExpr::OffsetOfNode Node; 6352 SmallVector<Component, 4> Components; 6353 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 6354 const Node &ON = E->getComponent(I); 6355 Component Comp; 6356 Comp.isBrackets = true; 6357 Comp.LocStart = ON.getSourceRange().getBegin(); 6358 Comp.LocEnd = ON.getSourceRange().getEnd(); 6359 switch (ON.getKind()) { 6360 case Node::Array: { 6361 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 6362 ExprResult Index = getDerived().TransformExpr(FromIndex); 6363 if (Index.isInvalid()) 6364 return ExprError(); 6365 6366 ExprChanged = ExprChanged || Index.get() != FromIndex; 6367 Comp.isBrackets = true; 6368 Comp.U.E = Index.get(); 6369 break; 6370 } 6371 6372 case Node::Field: 6373 case Node::Identifier: 6374 Comp.isBrackets = false; 6375 Comp.U.IdentInfo = ON.getFieldName(); 6376 if (!Comp.U.IdentInfo) 6377 continue; 6378 6379 break; 6380 6381 case Node::Base: 6382 // Will be recomputed during the rebuild. 6383 continue; 6384 } 6385 6386 Components.push_back(Comp); 6387 } 6388 6389 // If nothing changed, retain the existing expression. 6390 if (!getDerived().AlwaysRebuild() && 6391 Type == E->getTypeSourceInfo() && 6392 !ExprChanged) 6393 return SemaRef.Owned(E); 6394 6395 // Build a new offsetof expression. 6396 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 6397 Components.data(), Components.size(), 6398 E->getRParenLoc()); 6399} 6400 6401template<typename Derived> 6402ExprResult 6403TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 6404 assert(getDerived().AlreadyTransformed(E->getType()) && 6405 "opaque value expression requires transformation"); 6406 return SemaRef.Owned(E); 6407} 6408 6409template<typename Derived> 6410ExprResult 6411TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) { 6412 // Rebuild the syntactic form. The original syntactic form has 6413 // opaque-value expressions in it, so strip those away and rebuild 6414 // the result. This is a really awful way of doing this, but the 6415 // better solution (rebuilding the semantic expressions and 6416 // rebinding OVEs as necessary) doesn't work; we'd need 6417 // TreeTransform to not strip away implicit conversions. 6418 Expr *newSyntacticForm = SemaRef.recreateSyntacticForm(E); 6419 ExprResult result = getDerived().TransformExpr(newSyntacticForm); 6420 if (result.isInvalid()) return ExprError(); 6421 6422 // If that gives us a pseudo-object result back, the pseudo-object 6423 // expression must have been an lvalue-to-rvalue conversion which we 6424 // should reapply. 6425 if (result.get()->hasPlaceholderType(BuiltinType::PseudoObject)) 6426 result = SemaRef.checkPseudoObjectRValue(result.take()); 6427 6428 return result; 6429} 6430 6431template<typename Derived> 6432ExprResult 6433TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr( 6434 UnaryExprOrTypeTraitExpr *E) { 6435 if (E->isArgumentType()) { 6436 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 6437 6438 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 6439 if (!NewT) 6440 return ExprError(); 6441 6442 if (!getDerived().AlwaysRebuild() && OldT == NewT) 6443 return SemaRef.Owned(E); 6444 6445 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(), 6446 E->getKind(), 6447 E->getSourceRange()); 6448 } 6449 6450 // C++0x [expr.sizeof]p1: 6451 // The operand is either an expression, which is an unevaluated operand 6452 // [...] 6453 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 6454 Sema::ReuseLambdaContextDecl); 6455 6456 ExprResult SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 6457 if (SubExpr.isInvalid()) 6458 return ExprError(); 6459 6460 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 6461 return SemaRef.Owned(E); 6462 6463 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(), 6464 E->getOperatorLoc(), 6465 E->getKind(), 6466 E->getSourceRange()); 6467} 6468 6469template<typename Derived> 6470ExprResult 6471TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 6472 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6473 if (LHS.isInvalid()) 6474 return ExprError(); 6475 6476 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6477 if (RHS.isInvalid()) 6478 return ExprError(); 6479 6480 6481 if (!getDerived().AlwaysRebuild() && 6482 LHS.get() == E->getLHS() && 6483 RHS.get() == E->getRHS()) 6484 return SemaRef.Owned(E); 6485 6486 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 6487 /*FIXME:*/E->getLHS()->getLocStart(), 6488 RHS.get(), 6489 E->getRBracketLoc()); 6490} 6491 6492template<typename Derived> 6493ExprResult 6494TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 6495 // Transform the callee. 6496 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6497 if (Callee.isInvalid()) 6498 return ExprError(); 6499 6500 // Transform arguments. 6501 bool ArgChanged = false; 6502 SmallVector<Expr*, 8> Args; 6503 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6504 &ArgChanged)) 6505 return ExprError(); 6506 6507 if (!getDerived().AlwaysRebuild() && 6508 Callee.get() == E->getCallee() && 6509 !ArgChanged) 6510 return SemaRef.MaybeBindToTemporary(E); 6511 6512 // FIXME: Wrong source location information for the '('. 6513 SourceLocation FakeLParenLoc 6514 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 6515 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 6516 Args, 6517 E->getRParenLoc()); 6518} 6519 6520template<typename Derived> 6521ExprResult 6522TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 6523 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6524 if (Base.isInvalid()) 6525 return ExprError(); 6526 6527 NestedNameSpecifierLoc QualifierLoc; 6528 if (E->hasQualifier()) { 6529 QualifierLoc 6530 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6531 6532 if (!QualifierLoc) 6533 return ExprError(); 6534 } 6535 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 6536 6537 ValueDecl *Member 6538 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 6539 E->getMemberDecl())); 6540 if (!Member) 6541 return ExprError(); 6542 6543 NamedDecl *FoundDecl = E->getFoundDecl(); 6544 if (FoundDecl == E->getMemberDecl()) { 6545 FoundDecl = Member; 6546 } else { 6547 FoundDecl = cast_or_null<NamedDecl>( 6548 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 6549 if (!FoundDecl) 6550 return ExprError(); 6551 } 6552 6553 if (!getDerived().AlwaysRebuild() && 6554 Base.get() == E->getBase() && 6555 QualifierLoc == E->getQualifierLoc() && 6556 Member == E->getMemberDecl() && 6557 FoundDecl == E->getFoundDecl() && 6558 !E->hasExplicitTemplateArgs()) { 6559 6560 // Mark it referenced in the new context regardless. 6561 // FIXME: this is a bit instantiation-specific. 6562 SemaRef.MarkMemberReferenced(E); 6563 6564 return SemaRef.Owned(E); 6565 } 6566 6567 TemplateArgumentListInfo TransArgs; 6568 if (E->hasExplicitTemplateArgs()) { 6569 TransArgs.setLAngleLoc(E->getLAngleLoc()); 6570 TransArgs.setRAngleLoc(E->getRAngleLoc()); 6571 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6572 E->getNumTemplateArgs(), 6573 TransArgs)) 6574 return ExprError(); 6575 } 6576 6577 // FIXME: Bogus source location for the operator 6578 SourceLocation FakeOperatorLoc 6579 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 6580 6581 // FIXME: to do this check properly, we will need to preserve the 6582 // first-qualifier-in-scope here, just in case we had a dependent 6583 // base (and therefore couldn't do the check) and a 6584 // nested-name-qualifier (and therefore could do the lookup). 6585 NamedDecl *FirstQualifierInScope = 0; 6586 6587 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 6588 E->isArrow(), 6589 QualifierLoc, 6590 TemplateKWLoc, 6591 E->getMemberNameInfo(), 6592 Member, 6593 FoundDecl, 6594 (E->hasExplicitTemplateArgs() 6595 ? &TransArgs : 0), 6596 FirstQualifierInScope); 6597} 6598 6599template<typename Derived> 6600ExprResult 6601TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 6602 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6603 if (LHS.isInvalid()) 6604 return ExprError(); 6605 6606 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6607 if (RHS.isInvalid()) 6608 return ExprError(); 6609 6610 if (!getDerived().AlwaysRebuild() && 6611 LHS.get() == E->getLHS() && 6612 RHS.get() == E->getRHS()) 6613 return SemaRef.Owned(E); 6614 6615 Sema::FPContractStateRAII FPContractState(getSema()); 6616 getSema().FPFeatures.fp_contract = E->isFPContractable(); 6617 6618 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 6619 LHS.get(), RHS.get()); 6620} 6621 6622template<typename Derived> 6623ExprResult 6624TreeTransform<Derived>::TransformCompoundAssignOperator( 6625 CompoundAssignOperator *E) { 6626 return getDerived().TransformBinaryOperator(E); 6627} 6628 6629template<typename Derived> 6630ExprResult TreeTransform<Derived>:: 6631TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { 6632 // Just rebuild the common and RHS expressions and see whether we 6633 // get any changes. 6634 6635 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); 6636 if (commonExpr.isInvalid()) 6637 return ExprError(); 6638 6639 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); 6640 if (rhs.isInvalid()) 6641 return ExprError(); 6642 6643 if (!getDerived().AlwaysRebuild() && 6644 commonExpr.get() == e->getCommon() && 6645 rhs.get() == e->getFalseExpr()) 6646 return SemaRef.Owned(e); 6647 6648 return getDerived().RebuildConditionalOperator(commonExpr.take(), 6649 e->getQuestionLoc(), 6650 0, 6651 e->getColonLoc(), 6652 rhs.get()); 6653} 6654 6655template<typename Derived> 6656ExprResult 6657TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 6658 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 6659 if (Cond.isInvalid()) 6660 return ExprError(); 6661 6662 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6663 if (LHS.isInvalid()) 6664 return ExprError(); 6665 6666 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6667 if (RHS.isInvalid()) 6668 return ExprError(); 6669 6670 if (!getDerived().AlwaysRebuild() && 6671 Cond.get() == E->getCond() && 6672 LHS.get() == E->getLHS() && 6673 RHS.get() == E->getRHS()) 6674 return SemaRef.Owned(E); 6675 6676 return getDerived().RebuildConditionalOperator(Cond.get(), 6677 E->getQuestionLoc(), 6678 LHS.get(), 6679 E->getColonLoc(), 6680 RHS.get()); 6681} 6682 6683template<typename Derived> 6684ExprResult 6685TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 6686 // Implicit casts are eliminated during transformation, since they 6687 // will be recomputed by semantic analysis after transformation. 6688 return getDerived().TransformExpr(E->getSubExprAsWritten()); 6689} 6690 6691template<typename Derived> 6692ExprResult 6693TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 6694 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 6695 if (!Type) 6696 return ExprError(); 6697 6698 ExprResult SubExpr 6699 = getDerived().TransformExpr(E->getSubExprAsWritten()); 6700 if (SubExpr.isInvalid()) 6701 return ExprError(); 6702 6703 if (!getDerived().AlwaysRebuild() && 6704 Type == E->getTypeInfoAsWritten() && 6705 SubExpr.get() == E->getSubExpr()) 6706 return SemaRef.Owned(E); 6707 6708 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 6709 Type, 6710 E->getRParenLoc(), 6711 SubExpr.get()); 6712} 6713 6714template<typename Derived> 6715ExprResult 6716TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 6717 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 6718 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 6719 if (!NewT) 6720 return ExprError(); 6721 6722 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 6723 if (Init.isInvalid()) 6724 return ExprError(); 6725 6726 if (!getDerived().AlwaysRebuild() && 6727 OldT == NewT && 6728 Init.get() == E->getInitializer()) 6729 return SemaRef.MaybeBindToTemporary(E); 6730 6731 // Note: the expression type doesn't necessarily match the 6732 // type-as-written, but that's okay, because it should always be 6733 // derivable from the initializer. 6734 6735 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 6736 /*FIXME:*/E->getInitializer()->getLocEnd(), 6737 Init.get()); 6738} 6739 6740template<typename Derived> 6741ExprResult 6742TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 6743 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6744 if (Base.isInvalid()) 6745 return ExprError(); 6746 6747 if (!getDerived().AlwaysRebuild() && 6748 Base.get() == E->getBase()) 6749 return SemaRef.Owned(E); 6750 6751 // FIXME: Bad source location 6752 SourceLocation FakeOperatorLoc 6753 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 6754 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 6755 E->getAccessorLoc(), 6756 E->getAccessor()); 6757} 6758 6759template<typename Derived> 6760ExprResult 6761TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 6762 bool InitChanged = false; 6763 6764 SmallVector<Expr*, 4> Inits; 6765 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 6766 Inits, &InitChanged)) 6767 return ExprError(); 6768 6769 if (!getDerived().AlwaysRebuild() && !InitChanged) 6770 return SemaRef.Owned(E); 6771 6772 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits, 6773 E->getRBraceLoc(), E->getType()); 6774} 6775 6776template<typename Derived> 6777ExprResult 6778TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 6779 Designation Desig; 6780 6781 // transform the initializer value 6782 ExprResult Init = getDerived().TransformExpr(E->getInit()); 6783 if (Init.isInvalid()) 6784 return ExprError(); 6785 6786 // transform the designators. 6787 SmallVector<Expr*, 4> ArrayExprs; 6788 bool ExprChanged = false; 6789 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 6790 DEnd = E->designators_end(); 6791 D != DEnd; ++D) { 6792 if (D->isFieldDesignator()) { 6793 Desig.AddDesignator(Designator::getField(D->getFieldName(), 6794 D->getDotLoc(), 6795 D->getFieldLoc())); 6796 continue; 6797 } 6798 6799 if (D->isArrayDesignator()) { 6800 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 6801 if (Index.isInvalid()) 6802 return ExprError(); 6803 6804 Desig.AddDesignator(Designator::getArray(Index.get(), 6805 D->getLBracketLoc())); 6806 6807 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 6808 ArrayExprs.push_back(Index.release()); 6809 continue; 6810 } 6811 6812 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 6813 ExprResult Start 6814 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 6815 if (Start.isInvalid()) 6816 return ExprError(); 6817 6818 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 6819 if (End.isInvalid()) 6820 return ExprError(); 6821 6822 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 6823 End.get(), 6824 D->getLBracketLoc(), 6825 D->getEllipsisLoc())); 6826 6827 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 6828 End.get() != E->getArrayRangeEnd(*D); 6829 6830 ArrayExprs.push_back(Start.release()); 6831 ArrayExprs.push_back(End.release()); 6832 } 6833 6834 if (!getDerived().AlwaysRebuild() && 6835 Init.get() == E->getInit() && 6836 !ExprChanged) 6837 return SemaRef.Owned(E); 6838 6839 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs, 6840 E->getEqualOrColonLoc(), 6841 E->usesGNUSyntax(), Init.get()); 6842} 6843 6844template<typename Derived> 6845ExprResult 6846TreeTransform<Derived>::TransformImplicitValueInitExpr( 6847 ImplicitValueInitExpr *E) { 6848 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 6849 6850 // FIXME: Will we ever have proper type location here? Will we actually 6851 // need to transform the type? 6852 QualType T = getDerived().TransformType(E->getType()); 6853 if (T.isNull()) 6854 return ExprError(); 6855 6856 if (!getDerived().AlwaysRebuild() && 6857 T == E->getType()) 6858 return SemaRef.Owned(E); 6859 6860 return getDerived().RebuildImplicitValueInitExpr(T); 6861} 6862 6863template<typename Derived> 6864ExprResult 6865TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 6866 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 6867 if (!TInfo) 6868 return ExprError(); 6869 6870 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6871 if (SubExpr.isInvalid()) 6872 return ExprError(); 6873 6874 if (!getDerived().AlwaysRebuild() && 6875 TInfo == E->getWrittenTypeInfo() && 6876 SubExpr.get() == E->getSubExpr()) 6877 return SemaRef.Owned(E); 6878 6879 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 6880 TInfo, E->getRParenLoc()); 6881} 6882 6883template<typename Derived> 6884ExprResult 6885TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 6886 bool ArgumentChanged = false; 6887 SmallVector<Expr*, 4> Inits; 6888 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 6889 &ArgumentChanged)) 6890 return ExprError(); 6891 6892 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 6893 Inits, 6894 E->getRParenLoc()); 6895} 6896 6897/// \brief Transform an address-of-label expression. 6898/// 6899/// By default, the transformation of an address-of-label expression always 6900/// rebuilds the expression, so that the label identifier can be resolved to 6901/// the corresponding label statement by semantic analysis. 6902template<typename Derived> 6903ExprResult 6904TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 6905 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), 6906 E->getLabel()); 6907 if (!LD) 6908 return ExprError(); 6909 6910 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 6911 cast<LabelDecl>(LD)); 6912} 6913 6914template<typename Derived> 6915ExprResult 6916TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 6917 SemaRef.ActOnStartStmtExpr(); 6918 StmtResult SubStmt 6919 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 6920 if (SubStmt.isInvalid()) { 6921 SemaRef.ActOnStmtExprError(); 6922 return ExprError(); 6923 } 6924 6925 if (!getDerived().AlwaysRebuild() && 6926 SubStmt.get() == E->getSubStmt()) { 6927 // Calling this an 'error' is unintuitive, but it does the right thing. 6928 SemaRef.ActOnStmtExprError(); 6929 return SemaRef.MaybeBindToTemporary(E); 6930 } 6931 6932 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 6933 SubStmt.get(), 6934 E->getRParenLoc()); 6935} 6936 6937template<typename Derived> 6938ExprResult 6939TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 6940 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 6941 if (Cond.isInvalid()) 6942 return ExprError(); 6943 6944 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 6945 if (LHS.isInvalid()) 6946 return ExprError(); 6947 6948 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 6949 if (RHS.isInvalid()) 6950 return ExprError(); 6951 6952 if (!getDerived().AlwaysRebuild() && 6953 Cond.get() == E->getCond() && 6954 LHS.get() == E->getLHS() && 6955 RHS.get() == E->getRHS()) 6956 return SemaRef.Owned(E); 6957 6958 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 6959 Cond.get(), LHS.get(), RHS.get(), 6960 E->getRParenLoc()); 6961} 6962 6963template<typename Derived> 6964ExprResult 6965TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 6966 return SemaRef.Owned(E); 6967} 6968 6969template<typename Derived> 6970ExprResult 6971TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 6972 switch (E->getOperator()) { 6973 case OO_New: 6974 case OO_Delete: 6975 case OO_Array_New: 6976 case OO_Array_Delete: 6977 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 6978 6979 case OO_Call: { 6980 // This is a call to an object's operator(). 6981 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 6982 6983 // Transform the object itself. 6984 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 6985 if (Object.isInvalid()) 6986 return ExprError(); 6987 6988 // FIXME: Poor location information 6989 SourceLocation FakeLParenLoc 6990 = SemaRef.PP.getLocForEndOfToken( 6991 static_cast<Expr *>(Object.get())->getLocEnd()); 6992 6993 // Transform the call arguments. 6994 SmallVector<Expr*, 8> Args; 6995 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 6996 Args)) 6997 return ExprError(); 6998 6999 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 7000 Args, 7001 E->getLocEnd()); 7002 } 7003 7004#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 7005 case OO_##Name: 7006#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 7007#include "clang/Basic/OperatorKinds.def" 7008 case OO_Subscript: 7009 // Handled below. 7010 break; 7011 7012 case OO_Conditional: 7013 llvm_unreachable("conditional operator is not actually overloadable"); 7014 7015 case OO_None: 7016 case NUM_OVERLOADED_OPERATORS: 7017 llvm_unreachable("not an overloaded operator?"); 7018 } 7019 7020 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 7021 if (Callee.isInvalid()) 7022 return ExprError(); 7023 7024 ExprResult First; 7025 if (E->getOperator() == OO_Amp) 7026 First = getDerived().TransformAddressOfOperand(E->getArg(0)); 7027 else 7028 First = getDerived().TransformExpr(E->getArg(0)); 7029 if (First.isInvalid()) 7030 return ExprError(); 7031 7032 ExprResult Second; 7033 if (E->getNumArgs() == 2) { 7034 Second = getDerived().TransformExpr(E->getArg(1)); 7035 if (Second.isInvalid()) 7036 return ExprError(); 7037 } 7038 7039 if (!getDerived().AlwaysRebuild() && 7040 Callee.get() == E->getCallee() && 7041 First.get() == E->getArg(0) && 7042 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 7043 return SemaRef.MaybeBindToTemporary(E); 7044 7045 Sema::FPContractStateRAII FPContractState(getSema()); 7046 getSema().FPFeatures.fp_contract = E->isFPContractable(); 7047 7048 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 7049 E->getOperatorLoc(), 7050 Callee.get(), 7051 First.get(), 7052 Second.get()); 7053} 7054 7055template<typename Derived> 7056ExprResult 7057TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 7058 return getDerived().TransformCallExpr(E); 7059} 7060 7061template<typename Derived> 7062ExprResult 7063TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 7064 // Transform the callee. 7065 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 7066 if (Callee.isInvalid()) 7067 return ExprError(); 7068 7069 // Transform exec config. 7070 ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); 7071 if (EC.isInvalid()) 7072 return ExprError(); 7073 7074 // Transform arguments. 7075 bool ArgChanged = false; 7076 SmallVector<Expr*, 8> Args; 7077 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7078 &ArgChanged)) 7079 return ExprError(); 7080 7081 if (!getDerived().AlwaysRebuild() && 7082 Callee.get() == E->getCallee() && 7083 !ArgChanged) 7084 return SemaRef.MaybeBindToTemporary(E); 7085 7086 // FIXME: Wrong source location information for the '('. 7087 SourceLocation FakeLParenLoc 7088 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 7089 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 7090 Args, 7091 E->getRParenLoc(), EC.get()); 7092} 7093 7094template<typename Derived> 7095ExprResult 7096TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 7097 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7098 if (!Type) 7099 return ExprError(); 7100 7101 ExprResult SubExpr 7102 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7103 if (SubExpr.isInvalid()) 7104 return ExprError(); 7105 7106 if (!getDerived().AlwaysRebuild() && 7107 Type == E->getTypeInfoAsWritten() && 7108 SubExpr.get() == E->getSubExpr()) 7109 return SemaRef.Owned(E); 7110 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 7111 E->getStmtClass(), 7112 E->getAngleBrackets().getBegin(), 7113 Type, 7114 E->getAngleBrackets().getEnd(), 7115 // FIXME. this should be '(' location 7116 E->getAngleBrackets().getEnd(), 7117 SubExpr.get(), 7118 E->getRParenLoc()); 7119} 7120 7121template<typename Derived> 7122ExprResult 7123TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 7124 return getDerived().TransformCXXNamedCastExpr(E); 7125} 7126 7127template<typename Derived> 7128ExprResult 7129TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 7130 return getDerived().TransformCXXNamedCastExpr(E); 7131} 7132 7133template<typename Derived> 7134ExprResult 7135TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 7136 CXXReinterpretCastExpr *E) { 7137 return getDerived().TransformCXXNamedCastExpr(E); 7138} 7139 7140template<typename Derived> 7141ExprResult 7142TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 7143 return getDerived().TransformCXXNamedCastExpr(E); 7144} 7145 7146template<typename Derived> 7147ExprResult 7148TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 7149 CXXFunctionalCastExpr *E) { 7150 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 7151 if (!Type) 7152 return ExprError(); 7153 7154 ExprResult SubExpr 7155 = getDerived().TransformExpr(E->getSubExprAsWritten()); 7156 if (SubExpr.isInvalid()) 7157 return ExprError(); 7158 7159 if (!getDerived().AlwaysRebuild() && 7160 Type == E->getTypeInfoAsWritten() && 7161 SubExpr.get() == E->getSubExpr()) 7162 return SemaRef.Owned(E); 7163 7164 return getDerived().RebuildCXXFunctionalCastExpr(Type, 7165 /*FIXME:*/E->getSubExpr()->getLocStart(), 7166 SubExpr.get(), 7167 E->getRParenLoc()); 7168} 7169 7170template<typename Derived> 7171ExprResult 7172TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 7173 if (E->isTypeOperand()) { 7174 TypeSourceInfo *TInfo 7175 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 7176 if (!TInfo) 7177 return ExprError(); 7178 7179 if (!getDerived().AlwaysRebuild() && 7180 TInfo == E->getTypeOperandSourceInfo()) 7181 return SemaRef.Owned(E); 7182 7183 return getDerived().RebuildCXXTypeidExpr(E->getType(), 7184 E->getLocStart(), 7185 TInfo, 7186 E->getLocEnd()); 7187 } 7188 7189 // We don't know whether the subexpression is potentially evaluated until 7190 // after we perform semantic analysis. We speculatively assume it is 7191 // unevaluated; it will get fixed later if the subexpression is in fact 7192 // potentially evaluated. 7193 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 7194 Sema::ReuseLambdaContextDecl); 7195 7196 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 7197 if (SubExpr.isInvalid()) 7198 return ExprError(); 7199 7200 if (!getDerived().AlwaysRebuild() && 7201 SubExpr.get() == E->getExprOperand()) 7202 return SemaRef.Owned(E); 7203 7204 return getDerived().RebuildCXXTypeidExpr(E->getType(), 7205 E->getLocStart(), 7206 SubExpr.get(), 7207 E->getLocEnd()); 7208} 7209 7210template<typename Derived> 7211ExprResult 7212TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 7213 if (E->isTypeOperand()) { 7214 TypeSourceInfo *TInfo 7215 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 7216 if (!TInfo) 7217 return ExprError(); 7218 7219 if (!getDerived().AlwaysRebuild() && 7220 TInfo == E->getTypeOperandSourceInfo()) 7221 return SemaRef.Owned(E); 7222 7223 return getDerived().RebuildCXXUuidofExpr(E->getType(), 7224 E->getLocStart(), 7225 TInfo, 7226 E->getLocEnd()); 7227 } 7228 7229 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7230 7231 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 7232 if (SubExpr.isInvalid()) 7233 return ExprError(); 7234 7235 if (!getDerived().AlwaysRebuild() && 7236 SubExpr.get() == E->getExprOperand()) 7237 return SemaRef.Owned(E); 7238 7239 return getDerived().RebuildCXXUuidofExpr(E->getType(), 7240 E->getLocStart(), 7241 SubExpr.get(), 7242 E->getLocEnd()); 7243} 7244 7245template<typename Derived> 7246ExprResult 7247TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 7248 return SemaRef.Owned(E); 7249} 7250 7251template<typename Derived> 7252ExprResult 7253TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 7254 CXXNullPtrLiteralExpr *E) { 7255 return SemaRef.Owned(E); 7256} 7257 7258template<typename Derived> 7259ExprResult 7260TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 7261 DeclContext *DC = getSema().getFunctionLevelDeclContext(); 7262 QualType T; 7263 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) 7264 T = MD->getThisType(getSema().Context); 7265 else if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) { 7266 T = getSema().Context.getPointerType( 7267 getSema().Context.getRecordType(Record)); 7268 } else { 7269 assert(SemaRef.Context.getDiagnostics().hasErrorOccurred() && 7270 "this in the wrong scope?"); 7271 return ExprError(); 7272 } 7273 7274 if (!getDerived().AlwaysRebuild() && T == E->getType()) { 7275 // Make sure that we capture 'this'. 7276 getSema().CheckCXXThisCapture(E->getLocStart()); 7277 return SemaRef.Owned(E); 7278 } 7279 7280 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 7281} 7282 7283template<typename Derived> 7284ExprResult 7285TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 7286 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 7287 if (SubExpr.isInvalid()) 7288 return ExprError(); 7289 7290 if (!getDerived().AlwaysRebuild() && 7291 SubExpr.get() == E->getSubExpr()) 7292 return SemaRef.Owned(E); 7293 7294 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(), 7295 E->isThrownVariableInScope()); 7296} 7297 7298template<typename Derived> 7299ExprResult 7300TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 7301 ParmVarDecl *Param 7302 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 7303 E->getParam())); 7304 if (!Param) 7305 return ExprError(); 7306 7307 if (!getDerived().AlwaysRebuild() && 7308 Param == E->getParam()) 7309 return SemaRef.Owned(E); 7310 7311 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 7312} 7313 7314template<typename Derived> 7315ExprResult 7316TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 7317 FieldDecl *Field 7318 = cast_or_null<FieldDecl>(getDerived().TransformDecl(E->getLocStart(), 7319 E->getField())); 7320 if (!Field) 7321 return ExprError(); 7322 7323 if (!getDerived().AlwaysRebuild() && Field == E->getField()) 7324 return SemaRef.Owned(E); 7325 7326 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field); 7327} 7328 7329template<typename Derived> 7330ExprResult 7331TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 7332 CXXScalarValueInitExpr *E) { 7333 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 7334 if (!T) 7335 return ExprError(); 7336 7337 if (!getDerived().AlwaysRebuild() && 7338 T == E->getTypeSourceInfo()) 7339 return SemaRef.Owned(E); 7340 7341 return getDerived().RebuildCXXScalarValueInitExpr(T, 7342 /*FIXME:*/T->getTypeLoc().getEndLoc(), 7343 E->getRParenLoc()); 7344} 7345 7346template<typename Derived> 7347ExprResult 7348TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 7349 // Transform the type that we're allocating 7350 TypeSourceInfo *AllocTypeInfo 7351 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 7352 if (!AllocTypeInfo) 7353 return ExprError(); 7354 7355 // Transform the size of the array we're allocating (if any). 7356 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 7357 if (ArraySize.isInvalid()) 7358 return ExprError(); 7359 7360 // Transform the placement arguments (if any). 7361 bool ArgumentChanged = false; 7362 SmallVector<Expr*, 8> PlacementArgs; 7363 if (getDerived().TransformExprs(E->getPlacementArgs(), 7364 E->getNumPlacementArgs(), true, 7365 PlacementArgs, &ArgumentChanged)) 7366 return ExprError(); 7367 7368 // Transform the initializer (if any). 7369 Expr *OldInit = E->getInitializer(); 7370 ExprResult NewInit; 7371 if (OldInit) 7372 NewInit = getDerived().TransformExpr(OldInit); 7373 if (NewInit.isInvalid()) 7374 return ExprError(); 7375 7376 // Transform new operator and delete operator. 7377 FunctionDecl *OperatorNew = 0; 7378 if (E->getOperatorNew()) { 7379 OperatorNew = cast_or_null<FunctionDecl>( 7380 getDerived().TransformDecl(E->getLocStart(), 7381 E->getOperatorNew())); 7382 if (!OperatorNew) 7383 return ExprError(); 7384 } 7385 7386 FunctionDecl *OperatorDelete = 0; 7387 if (E->getOperatorDelete()) { 7388 OperatorDelete = cast_or_null<FunctionDecl>( 7389 getDerived().TransformDecl(E->getLocStart(), 7390 E->getOperatorDelete())); 7391 if (!OperatorDelete) 7392 return ExprError(); 7393 } 7394 7395 if (!getDerived().AlwaysRebuild() && 7396 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 7397 ArraySize.get() == E->getArraySize() && 7398 NewInit.get() == OldInit && 7399 OperatorNew == E->getOperatorNew() && 7400 OperatorDelete == E->getOperatorDelete() && 7401 !ArgumentChanged) { 7402 // Mark any declarations we need as referenced. 7403 // FIXME: instantiation-specific. 7404 if (OperatorNew) 7405 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorNew); 7406 if (OperatorDelete) 7407 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 7408 7409 if (E->isArray() && !E->getAllocatedType()->isDependentType()) { 7410 QualType ElementType 7411 = SemaRef.Context.getBaseElementType(E->getAllocatedType()); 7412 if (const RecordType *RecordT = ElementType->getAs<RecordType>()) { 7413 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordT->getDecl()); 7414 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Record)) { 7415 SemaRef.MarkFunctionReferenced(E->getLocStart(), Destructor); 7416 } 7417 } 7418 } 7419 7420 return SemaRef.Owned(E); 7421 } 7422 7423 QualType AllocType = AllocTypeInfo->getType(); 7424 if (!ArraySize.get()) { 7425 // If no array size was specified, but the new expression was 7426 // instantiated with an array type (e.g., "new T" where T is 7427 // instantiated with "int[4]"), extract the outer bound from the 7428 // array type as our array size. We do this with constant and 7429 // dependently-sized array types. 7430 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 7431 if (!ArrayT) { 7432 // Do nothing 7433 } else if (const ConstantArrayType *ConsArrayT 7434 = dyn_cast<ConstantArrayType>(ArrayT)) { 7435 ArraySize 7436 = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, 7437 ConsArrayT->getSize(), 7438 SemaRef.Context.getSizeType(), 7439 /*FIXME:*/E->getLocStart())); 7440 AllocType = ConsArrayT->getElementType(); 7441 } else if (const DependentSizedArrayType *DepArrayT 7442 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 7443 if (DepArrayT->getSizeExpr()) { 7444 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); 7445 AllocType = DepArrayT->getElementType(); 7446 } 7447 } 7448 } 7449 7450 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 7451 E->isGlobalNew(), 7452 /*FIXME:*/E->getLocStart(), 7453 PlacementArgs, 7454 /*FIXME:*/E->getLocStart(), 7455 E->getTypeIdParens(), 7456 AllocType, 7457 AllocTypeInfo, 7458 ArraySize.get(), 7459 E->getDirectInitRange(), 7460 NewInit.take()); 7461} 7462 7463template<typename Derived> 7464ExprResult 7465TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 7466 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 7467 if (Operand.isInvalid()) 7468 return ExprError(); 7469 7470 // Transform the delete operator, if known. 7471 FunctionDecl *OperatorDelete = 0; 7472 if (E->getOperatorDelete()) { 7473 OperatorDelete = cast_or_null<FunctionDecl>( 7474 getDerived().TransformDecl(E->getLocStart(), 7475 E->getOperatorDelete())); 7476 if (!OperatorDelete) 7477 return ExprError(); 7478 } 7479 7480 if (!getDerived().AlwaysRebuild() && 7481 Operand.get() == E->getArgument() && 7482 OperatorDelete == E->getOperatorDelete()) { 7483 // Mark any declarations we need as referenced. 7484 // FIXME: instantiation-specific. 7485 if (OperatorDelete) 7486 SemaRef.MarkFunctionReferenced(E->getLocStart(), OperatorDelete); 7487 7488 if (!E->getArgument()->isTypeDependent()) { 7489 QualType Destroyed = SemaRef.Context.getBaseElementType( 7490 E->getDestroyedType()); 7491 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 7492 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 7493 SemaRef.MarkFunctionReferenced(E->getLocStart(), 7494 SemaRef.LookupDestructor(Record)); 7495 } 7496 } 7497 7498 return SemaRef.Owned(E); 7499 } 7500 7501 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 7502 E->isGlobalDelete(), 7503 E->isArrayForm(), 7504 Operand.get()); 7505} 7506 7507template<typename Derived> 7508ExprResult 7509TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 7510 CXXPseudoDestructorExpr *E) { 7511 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7512 if (Base.isInvalid()) 7513 return ExprError(); 7514 7515 ParsedType ObjectTypePtr; 7516 bool MayBePseudoDestructor = false; 7517 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 7518 E->getOperatorLoc(), 7519 E->isArrow()? tok::arrow : tok::period, 7520 ObjectTypePtr, 7521 MayBePseudoDestructor); 7522 if (Base.isInvalid()) 7523 return ExprError(); 7524 7525 QualType ObjectType = ObjectTypePtr.get(); 7526 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc(); 7527 if (QualifierLoc) { 7528 QualifierLoc 7529 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType); 7530 if (!QualifierLoc) 7531 return ExprError(); 7532 } 7533 CXXScopeSpec SS; 7534 SS.Adopt(QualifierLoc); 7535 7536 PseudoDestructorTypeStorage Destroyed; 7537 if (E->getDestroyedTypeInfo()) { 7538 TypeSourceInfo *DestroyedTypeInfo 7539 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 7540 ObjectType, 0, SS); 7541 if (!DestroyedTypeInfo) 7542 return ExprError(); 7543 Destroyed = DestroyedTypeInfo; 7544 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) { 7545 // We aren't likely to be able to resolve the identifier down to a type 7546 // now anyway, so just retain the identifier. 7547 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 7548 E->getDestroyedTypeLoc()); 7549 } else { 7550 // Look for a destructor known with the given name. 7551 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 7552 *E->getDestroyedTypeIdentifier(), 7553 E->getDestroyedTypeLoc(), 7554 /*Scope=*/0, 7555 SS, ObjectTypePtr, 7556 false); 7557 if (!T) 7558 return ExprError(); 7559 7560 Destroyed 7561 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 7562 E->getDestroyedTypeLoc()); 7563 } 7564 7565 TypeSourceInfo *ScopeTypeInfo = 0; 7566 if (E->getScopeTypeInfo()) { 7567 CXXScopeSpec EmptySS; 7568 ScopeTypeInfo = getDerived().TransformTypeInObjectScope( 7569 E->getScopeTypeInfo(), ObjectType, 0, EmptySS); 7570 if (!ScopeTypeInfo) 7571 return ExprError(); 7572 } 7573 7574 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 7575 E->getOperatorLoc(), 7576 E->isArrow(), 7577 SS, 7578 ScopeTypeInfo, 7579 E->getColonColonLoc(), 7580 E->getTildeLoc(), 7581 Destroyed); 7582} 7583 7584template<typename Derived> 7585ExprResult 7586TreeTransform<Derived>::TransformUnresolvedLookupExpr( 7587 UnresolvedLookupExpr *Old) { 7588 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 7589 Sema::LookupOrdinaryName); 7590 7591 // Transform all the decls. 7592 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 7593 E = Old->decls_end(); I != E; ++I) { 7594 NamedDecl *InstD = static_cast<NamedDecl*>( 7595 getDerived().TransformDecl(Old->getNameLoc(), 7596 *I)); 7597 if (!InstD) { 7598 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 7599 // This can happen because of dependent hiding. 7600 if (isa<UsingShadowDecl>(*I)) 7601 continue; 7602 else 7603 return ExprError(); 7604 } 7605 7606 // Expand using declarations. 7607 if (isa<UsingDecl>(InstD)) { 7608 UsingDecl *UD = cast<UsingDecl>(InstD); 7609 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 7610 E = UD->shadow_end(); I != E; ++I) 7611 R.addDecl(*I); 7612 continue; 7613 } 7614 7615 R.addDecl(InstD); 7616 } 7617 7618 // Resolve a kind, but don't do any further analysis. If it's 7619 // ambiguous, the callee needs to deal with it. 7620 R.resolveKind(); 7621 7622 // Rebuild the nested-name qualifier, if present. 7623 CXXScopeSpec SS; 7624 if (Old->getQualifierLoc()) { 7625 NestedNameSpecifierLoc QualifierLoc 7626 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 7627 if (!QualifierLoc) 7628 return ExprError(); 7629 7630 SS.Adopt(QualifierLoc); 7631 } 7632 7633 if (Old->getNamingClass()) { 7634 CXXRecordDecl *NamingClass 7635 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 7636 Old->getNameLoc(), 7637 Old->getNamingClass())); 7638 if (!NamingClass) 7639 return ExprError(); 7640 7641 R.setNamingClass(NamingClass); 7642 } 7643 7644 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 7645 7646 // If we have neither explicit template arguments, nor the template keyword, 7647 // it's a normal declaration name. 7648 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid()) 7649 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 7650 7651 // If we have template arguments, rebuild them, then rebuild the 7652 // templateid expression. 7653 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 7654 if (Old->hasExplicitTemplateArgs() && 7655 getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 7656 Old->getNumTemplateArgs(), 7657 TransArgs)) 7658 return ExprError(); 7659 7660 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R, 7661 Old->requiresADL(), &TransArgs); 7662} 7663 7664template<typename Derived> 7665ExprResult 7666TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 7667 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 7668 if (!T) 7669 return ExprError(); 7670 7671 if (!getDerived().AlwaysRebuild() && 7672 T == E->getQueriedTypeSourceInfo()) 7673 return SemaRef.Owned(E); 7674 7675 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 7676 E->getLocStart(), 7677 T, 7678 E->getLocEnd()); 7679} 7680 7681template<typename Derived> 7682ExprResult 7683TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 7684 TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); 7685 if (!LhsT) 7686 return ExprError(); 7687 7688 TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); 7689 if (!RhsT) 7690 return ExprError(); 7691 7692 if (!getDerived().AlwaysRebuild() && 7693 LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) 7694 return SemaRef.Owned(E); 7695 7696 return getDerived().RebuildBinaryTypeTrait(E->getTrait(), 7697 E->getLocStart(), 7698 LhsT, RhsT, 7699 E->getLocEnd()); 7700} 7701 7702template<typename Derived> 7703ExprResult 7704TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { 7705 bool ArgChanged = false; 7706 SmallVector<TypeSourceInfo *, 4> Args; 7707 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 7708 TypeSourceInfo *From = E->getArg(I); 7709 TypeLoc FromTL = From->getTypeLoc(); 7710 if (!FromTL.getAs<PackExpansionTypeLoc>()) { 7711 TypeLocBuilder TLB; 7712 TLB.reserve(FromTL.getFullDataSize()); 7713 QualType To = getDerived().TransformType(TLB, FromTL); 7714 if (To.isNull()) 7715 return ExprError(); 7716 7717 if (To == From->getType()) 7718 Args.push_back(From); 7719 else { 7720 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7721 ArgChanged = true; 7722 } 7723 continue; 7724 } 7725 7726 ArgChanged = true; 7727 7728 // We have a pack expansion. Instantiate it. 7729 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>(); 7730 TypeLoc PatternTL = ExpansionTL.getPatternLoc(); 7731 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 7732 SemaRef.collectUnexpandedParameterPacks(PatternTL, Unexpanded); 7733 7734 // Determine whether the set of unexpanded parameter packs can and should 7735 // be expanded. 7736 bool Expand = true; 7737 bool RetainExpansion = false; 7738 Optional<unsigned> OrigNumExpansions = 7739 ExpansionTL.getTypePtr()->getNumExpansions(); 7740 Optional<unsigned> NumExpansions = OrigNumExpansions; 7741 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 7742 PatternTL.getSourceRange(), 7743 Unexpanded, 7744 Expand, RetainExpansion, 7745 NumExpansions)) 7746 return ExprError(); 7747 7748 if (!Expand) { 7749 // The transform has determined that we should perform a simple 7750 // transformation on the pack expansion, producing another pack 7751 // expansion. 7752 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 7753 7754 TypeLocBuilder TLB; 7755 TLB.reserve(From->getTypeLoc().getFullDataSize()); 7756 7757 QualType To = getDerived().TransformType(TLB, PatternTL); 7758 if (To.isNull()) 7759 return ExprError(); 7760 7761 To = getDerived().RebuildPackExpansionType(To, 7762 PatternTL.getSourceRange(), 7763 ExpansionTL.getEllipsisLoc(), 7764 NumExpansions); 7765 if (To.isNull()) 7766 return ExprError(); 7767 7768 PackExpansionTypeLoc ToExpansionTL 7769 = TLB.push<PackExpansionTypeLoc>(To); 7770 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 7771 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7772 continue; 7773 } 7774 7775 // Expand the pack expansion by substituting for each argument in the 7776 // pack(s). 7777 for (unsigned I = 0; I != *NumExpansions; ++I) { 7778 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I); 7779 TypeLocBuilder TLB; 7780 TLB.reserve(PatternTL.getFullDataSize()); 7781 QualType To = getDerived().TransformType(TLB, PatternTL); 7782 if (To.isNull()) 7783 return ExprError(); 7784 7785 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7786 } 7787 7788 if (!RetainExpansion) 7789 continue; 7790 7791 // If we're supposed to retain a pack expansion, do so by temporarily 7792 // forgetting the partially-substituted parameter pack. 7793 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 7794 7795 TypeLocBuilder TLB; 7796 TLB.reserve(From->getTypeLoc().getFullDataSize()); 7797 7798 QualType To = getDerived().TransformType(TLB, PatternTL); 7799 if (To.isNull()) 7800 return ExprError(); 7801 7802 To = getDerived().RebuildPackExpansionType(To, 7803 PatternTL.getSourceRange(), 7804 ExpansionTL.getEllipsisLoc(), 7805 NumExpansions); 7806 if (To.isNull()) 7807 return ExprError(); 7808 7809 PackExpansionTypeLoc ToExpansionTL 7810 = TLB.push<PackExpansionTypeLoc>(To); 7811 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc()); 7812 Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To)); 7813 } 7814 7815 if (!getDerived().AlwaysRebuild() && !ArgChanged) 7816 return SemaRef.Owned(E); 7817 7818 return getDerived().RebuildTypeTrait(E->getTrait(), 7819 E->getLocStart(), 7820 Args, 7821 E->getLocEnd()); 7822} 7823 7824template<typename Derived> 7825ExprResult 7826TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 7827 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 7828 if (!T) 7829 return ExprError(); 7830 7831 if (!getDerived().AlwaysRebuild() && 7832 T == E->getQueriedTypeSourceInfo()) 7833 return SemaRef.Owned(E); 7834 7835 ExprResult SubExpr; 7836 { 7837 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7838 SubExpr = getDerived().TransformExpr(E->getDimensionExpression()); 7839 if (SubExpr.isInvalid()) 7840 return ExprError(); 7841 7842 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getDimensionExpression()) 7843 return SemaRef.Owned(E); 7844 } 7845 7846 return getDerived().RebuildArrayTypeTrait(E->getTrait(), 7847 E->getLocStart(), 7848 T, 7849 SubExpr.get(), 7850 E->getLocEnd()); 7851} 7852 7853template<typename Derived> 7854ExprResult 7855TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) { 7856 ExprResult SubExpr; 7857 { 7858 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7859 SubExpr = getDerived().TransformExpr(E->getQueriedExpression()); 7860 if (SubExpr.isInvalid()) 7861 return ExprError(); 7862 7863 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression()) 7864 return SemaRef.Owned(E); 7865 } 7866 7867 return getDerived().RebuildExpressionTrait( 7868 E->getTrait(), E->getLocStart(), SubExpr.get(), E->getLocEnd()); 7869} 7870 7871template<typename Derived> 7872ExprResult 7873TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 7874 DependentScopeDeclRefExpr *E) { 7875 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand*/false); 7876} 7877 7878template<typename Derived> 7879ExprResult 7880TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 7881 DependentScopeDeclRefExpr *E, 7882 bool IsAddressOfOperand) { 7883 NestedNameSpecifierLoc QualifierLoc 7884 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 7885 if (!QualifierLoc) 7886 return ExprError(); 7887 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 7888 7889 // TODO: If this is a conversion-function-id, verify that the 7890 // destination type name (if present) resolves the same way after 7891 // instantiation as it did in the local scope. 7892 7893 DeclarationNameInfo NameInfo 7894 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 7895 if (!NameInfo.getName()) 7896 return ExprError(); 7897 7898 if (!E->hasExplicitTemplateArgs()) { 7899 if (!getDerived().AlwaysRebuild() && 7900 QualifierLoc == E->getQualifierLoc() && 7901 // Note: it is sufficient to compare the Name component of NameInfo: 7902 // if name has not changed, DNLoc has not changed either. 7903 NameInfo.getName() == E->getDeclName()) 7904 return SemaRef.Owned(E); 7905 7906 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 7907 TemplateKWLoc, 7908 NameInfo, 7909 /*TemplateArgs*/ 0, 7910 IsAddressOfOperand); 7911 } 7912 7913 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 7914 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 7915 E->getNumTemplateArgs(), 7916 TransArgs)) 7917 return ExprError(); 7918 7919 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 7920 TemplateKWLoc, 7921 NameInfo, 7922 &TransArgs, 7923 IsAddressOfOperand); 7924} 7925 7926template<typename Derived> 7927ExprResult 7928TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 7929 // CXXConstructExprs other than for list-initialization and 7930 // CXXTemporaryObjectExpr are always implicit, so when we have 7931 // a 1-argument construction we just transform that argument. 7932 if ((E->getNumArgs() == 1 || 7933 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) && 7934 (!getDerived().DropCallArgument(E->getArg(0))) && 7935 !E->isListInitialization()) 7936 return getDerived().TransformExpr(E->getArg(0)); 7937 7938 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 7939 7940 QualType T = getDerived().TransformType(E->getType()); 7941 if (T.isNull()) 7942 return ExprError(); 7943 7944 CXXConstructorDecl *Constructor 7945 = cast_or_null<CXXConstructorDecl>( 7946 getDerived().TransformDecl(E->getLocStart(), 7947 E->getConstructor())); 7948 if (!Constructor) 7949 return ExprError(); 7950 7951 bool ArgumentChanged = false; 7952 SmallVector<Expr*, 8> Args; 7953 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7954 &ArgumentChanged)) 7955 return ExprError(); 7956 7957 if (!getDerived().AlwaysRebuild() && 7958 T == E->getType() && 7959 Constructor == E->getConstructor() && 7960 !ArgumentChanged) { 7961 // Mark the constructor as referenced. 7962 // FIXME: Instantiation-specific 7963 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 7964 return SemaRef.Owned(E); 7965 } 7966 7967 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 7968 Constructor, E->isElidable(), 7969 Args, 7970 E->hadMultipleCandidates(), 7971 E->isListInitialization(), 7972 E->requiresZeroInitialization(), 7973 E->getConstructionKind(), 7974 E->getParenRange()); 7975} 7976 7977/// \brief Transform a C++ temporary-binding expression. 7978/// 7979/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 7980/// transform the subexpression and return that. 7981template<typename Derived> 7982ExprResult 7983TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 7984 return getDerived().TransformExpr(E->getSubExpr()); 7985} 7986 7987/// \brief Transform a C++ expression that contains cleanups that should 7988/// be run after the expression is evaluated. 7989/// 7990/// Since ExprWithCleanups nodes are implicitly generated, we 7991/// just transform the subexpression and return that. 7992template<typename Derived> 7993ExprResult 7994TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 7995 return getDerived().TransformExpr(E->getSubExpr()); 7996} 7997 7998template<typename Derived> 7999ExprResult 8000TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 8001 CXXTemporaryObjectExpr *E) { 8002 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8003 if (!T) 8004 return ExprError(); 8005 8006 CXXConstructorDecl *Constructor 8007 = cast_or_null<CXXConstructorDecl>( 8008 getDerived().TransformDecl(E->getLocStart(), 8009 E->getConstructor())); 8010 if (!Constructor) 8011 return ExprError(); 8012 8013 bool ArgumentChanged = false; 8014 SmallVector<Expr*, 8> Args; 8015 Args.reserve(E->getNumArgs()); 8016 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 8017 &ArgumentChanged)) 8018 return ExprError(); 8019 8020 if (!getDerived().AlwaysRebuild() && 8021 T == E->getTypeSourceInfo() && 8022 Constructor == E->getConstructor() && 8023 !ArgumentChanged) { 8024 // FIXME: Instantiation-specific 8025 SemaRef.MarkFunctionReferenced(E->getLocStart(), Constructor); 8026 return SemaRef.MaybeBindToTemporary(E); 8027 } 8028 8029 // FIXME: Pass in E->isListInitialization(). 8030 return getDerived().RebuildCXXTemporaryObjectExpr(T, 8031 /*FIXME:*/T->getTypeLoc().getEndLoc(), 8032 Args, 8033 E->getLocEnd()); 8034} 8035 8036template<typename Derived> 8037ExprResult 8038TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) { 8039 // Transform the type of the lambda parameters and start the definition of 8040 // the lambda itself. 8041 TypeSourceInfo *MethodTy 8042 = TransformType(E->getCallOperator()->getTypeSourceInfo()); 8043 if (!MethodTy) 8044 return ExprError(); 8045 8046 // Create the local class that will describe the lambda. 8047 CXXRecordDecl *Class 8048 = getSema().createLambdaClosureType(E->getIntroducerRange(), 8049 MethodTy, 8050 /*KnownDependent=*/false); 8051 getDerived().transformedLocalDecl(E->getLambdaClass(), Class); 8052 8053 // Transform lambda parameters. 8054 SmallVector<QualType, 4> ParamTypes; 8055 SmallVector<ParmVarDecl *, 4> Params; 8056 if (getDerived().TransformFunctionTypeParams(E->getLocStart(), 8057 E->getCallOperator()->param_begin(), 8058 E->getCallOperator()->param_size(), 8059 0, ParamTypes, &Params)) 8060 return ExprError(); 8061 8062 // Build the call operator. 8063 CXXMethodDecl *CallOperator 8064 = getSema().startLambdaDefinition(Class, E->getIntroducerRange(), 8065 MethodTy, 8066 E->getCallOperator()->getLocEnd(), 8067 Params); 8068 getDerived().transformAttrs(E->getCallOperator(), CallOperator); 8069 8070 return getDerived().TransformLambdaScope(E, CallOperator); 8071} 8072 8073template<typename Derived> 8074ExprResult 8075TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, 8076 CXXMethodDecl *CallOperator) { 8077 bool Invalid = false; 8078 8079 // Transform any init-capture expressions before entering the scope of the 8080 // lambda. 8081 llvm::SmallVector<ExprResult, 8> InitCaptureExprs; 8082 InitCaptureExprs.resize(E->explicit_capture_end() - 8083 E->explicit_capture_begin()); 8084 for (LambdaExpr::capture_iterator C = E->capture_begin(), 8085 CEnd = E->capture_end(); 8086 C != CEnd; ++C) { 8087 if (!C->isInitCapture()) 8088 continue; 8089 InitCaptureExprs[C - E->capture_begin()] = 8090 getDerived().TransformExpr(E->getInitCaptureInit(C)); 8091 } 8092 8093 // Introduce the context of the call operator. 8094 Sema::ContextRAII SavedContext(getSema(), CallOperator); 8095 8096 // Enter the scope of the lambda. 8097 sema::LambdaScopeInfo *LSI 8098 = getSema().enterLambdaScope(CallOperator, E->getIntroducerRange(), 8099 E->getCaptureDefault(), 8100 E->hasExplicitParameters(), 8101 E->hasExplicitResultType(), 8102 E->isMutable()); 8103 8104 // Transform captures. 8105 bool FinishedExplicitCaptures = false; 8106 for (LambdaExpr::capture_iterator C = E->capture_begin(), 8107 CEnd = E->capture_end(); 8108 C != CEnd; ++C) { 8109 // When we hit the first implicit capture, tell Sema that we've finished 8110 // the list of explicit captures. 8111 if (!FinishedExplicitCaptures && C->isImplicit()) { 8112 getSema().finishLambdaExplicitCaptures(LSI); 8113 FinishedExplicitCaptures = true; 8114 } 8115 8116 // Capturing 'this' is trivial. 8117 if (C->capturesThis()) { 8118 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit()); 8119 continue; 8120 } 8121 8122 // Rebuild init-captures, including the implied field declaration. 8123 if (C->isInitCapture()) { 8124 ExprResult Init = InitCaptureExprs[C - E->capture_begin()]; 8125 if (Init.isInvalid()) { 8126 Invalid = true; 8127 continue; 8128 } 8129 FieldDecl *OldFD = C->getInitCaptureField(); 8130 FieldDecl *NewFD = getSema().checkInitCapture( 8131 C->getLocation(), OldFD->getType()->isReferenceType(), 8132 OldFD->getIdentifier(), Init.take()); 8133 if (!NewFD) 8134 Invalid = true; 8135 else 8136 getDerived().transformedLocalDecl(OldFD, NewFD); 8137 continue; 8138 } 8139 8140 assert(C->capturesVariable() && "unexpected kind of lambda capture"); 8141 8142 // Determine the capture kind for Sema. 8143 Sema::TryCaptureKind Kind 8144 = C->isImplicit()? Sema::TryCapture_Implicit 8145 : C->getCaptureKind() == LCK_ByCopy 8146 ? Sema::TryCapture_ExplicitByVal 8147 : Sema::TryCapture_ExplicitByRef; 8148 SourceLocation EllipsisLoc; 8149 if (C->isPackExpansion()) { 8150 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); 8151 bool ShouldExpand = false; 8152 bool RetainExpansion = false; 8153 Optional<unsigned> NumExpansions; 8154 if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), 8155 C->getLocation(), 8156 Unexpanded, 8157 ShouldExpand, RetainExpansion, 8158 NumExpansions)) { 8159 Invalid = true; 8160 continue; 8161 } 8162 8163 if (ShouldExpand) { 8164 // The transform has determined that we should perform an expansion; 8165 // transform and capture each of the arguments. 8166 // expansion of the pattern. Do so. 8167 VarDecl *Pack = C->getCapturedVar(); 8168 for (unsigned I = 0; I != *NumExpansions; ++I) { 8169 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 8170 VarDecl *CapturedVar 8171 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8172 Pack)); 8173 if (!CapturedVar) { 8174 Invalid = true; 8175 continue; 8176 } 8177 8178 // Capture the transformed variable. 8179 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8180 } 8181 continue; 8182 } 8183 8184 EllipsisLoc = C->getEllipsisLoc(); 8185 } 8186 8187 // Transform the captured variable. 8188 VarDecl *CapturedVar 8189 = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(), 8190 C->getCapturedVar())); 8191 if (!CapturedVar) { 8192 Invalid = true; 8193 continue; 8194 } 8195 8196 // Capture the transformed variable. 8197 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind); 8198 } 8199 if (!FinishedExplicitCaptures) 8200 getSema().finishLambdaExplicitCaptures(LSI); 8201 8202 8203 // Enter a new evaluation context to insulate the lambda from any 8204 // cleanups from the enclosing full-expression. 8205 getSema().PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 8206 8207 if (Invalid) { 8208 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, 8209 /*IsInstantiation=*/true); 8210 return ExprError(); 8211 } 8212 8213 // Instantiate the body of the lambda expression. 8214 StmtResult Body = getDerived().TransformStmt(E->getBody()); 8215 if (Body.isInvalid()) { 8216 getSema().ActOnLambdaError(E->getLocStart(), /*CurScope=*/0, 8217 /*IsInstantiation=*/true); 8218 return ExprError(); 8219 } 8220 8221 return getSema().ActOnLambdaExpr(E->getLocStart(), Body.take(), 8222 /*CurScope=*/0, /*IsInstantiation=*/true); 8223} 8224 8225template<typename Derived> 8226ExprResult 8227TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 8228 CXXUnresolvedConstructExpr *E) { 8229 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 8230 if (!T) 8231 return ExprError(); 8232 8233 bool ArgumentChanged = false; 8234 SmallVector<Expr*, 8> Args; 8235 Args.reserve(E->arg_size()); 8236 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 8237 &ArgumentChanged)) 8238 return ExprError(); 8239 8240 if (!getDerived().AlwaysRebuild() && 8241 T == E->getTypeSourceInfo() && 8242 !ArgumentChanged) 8243 return SemaRef.Owned(E); 8244 8245 // FIXME: we're faking the locations of the commas 8246 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 8247 E->getLParenLoc(), 8248 Args, 8249 E->getRParenLoc()); 8250} 8251 8252template<typename Derived> 8253ExprResult 8254TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 8255 CXXDependentScopeMemberExpr *E) { 8256 // Transform the base of the expression. 8257 ExprResult Base((Expr*) 0); 8258 Expr *OldBase; 8259 QualType BaseType; 8260 QualType ObjectType; 8261 if (!E->isImplicitAccess()) { 8262 OldBase = E->getBase(); 8263 Base = getDerived().TransformExpr(OldBase); 8264 if (Base.isInvalid()) 8265 return ExprError(); 8266 8267 // Start the member reference and compute the object's type. 8268 ParsedType ObjectTy; 8269 bool MayBePseudoDestructor = false; 8270 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 8271 E->getOperatorLoc(), 8272 E->isArrow()? tok::arrow : tok::period, 8273 ObjectTy, 8274 MayBePseudoDestructor); 8275 if (Base.isInvalid()) 8276 return ExprError(); 8277 8278 ObjectType = ObjectTy.get(); 8279 BaseType = ((Expr*) Base.get())->getType(); 8280 } else { 8281 OldBase = 0; 8282 BaseType = getDerived().TransformType(E->getBaseType()); 8283 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 8284 } 8285 8286 // Transform the first part of the nested-name-specifier that qualifies 8287 // the member name. 8288 NamedDecl *FirstQualifierInScope 8289 = getDerived().TransformFirstQualifierInScope( 8290 E->getFirstQualifierFoundInScope(), 8291 E->getQualifierLoc().getBeginLoc()); 8292 8293 NestedNameSpecifierLoc QualifierLoc; 8294 if (E->getQualifier()) { 8295 QualifierLoc 8296 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 8297 ObjectType, 8298 FirstQualifierInScope); 8299 if (!QualifierLoc) 8300 return ExprError(); 8301 } 8302 8303 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc(); 8304 8305 // TODO: If this is a conversion-function-id, verify that the 8306 // destination type name (if present) resolves the same way after 8307 // instantiation as it did in the local scope. 8308 8309 DeclarationNameInfo NameInfo 8310 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 8311 if (!NameInfo.getName()) 8312 return ExprError(); 8313 8314 if (!E->hasExplicitTemplateArgs()) { 8315 // This is a reference to a member without an explicitly-specified 8316 // template argument list. Optimize for this common case. 8317 if (!getDerived().AlwaysRebuild() && 8318 Base.get() == OldBase && 8319 BaseType == E->getBaseType() && 8320 QualifierLoc == E->getQualifierLoc() && 8321 NameInfo.getName() == E->getMember() && 8322 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 8323 return SemaRef.Owned(E); 8324 8325 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8326 BaseType, 8327 E->isArrow(), 8328 E->getOperatorLoc(), 8329 QualifierLoc, 8330 TemplateKWLoc, 8331 FirstQualifierInScope, 8332 NameInfo, 8333 /*TemplateArgs*/ 0); 8334 } 8335 8336 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 8337 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 8338 E->getNumTemplateArgs(), 8339 TransArgs)) 8340 return ExprError(); 8341 8342 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 8343 BaseType, 8344 E->isArrow(), 8345 E->getOperatorLoc(), 8346 QualifierLoc, 8347 TemplateKWLoc, 8348 FirstQualifierInScope, 8349 NameInfo, 8350 &TransArgs); 8351} 8352 8353template<typename Derived> 8354ExprResult 8355TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 8356 // Transform the base of the expression. 8357 ExprResult Base((Expr*) 0); 8358 QualType BaseType; 8359 if (!Old->isImplicitAccess()) { 8360 Base = getDerived().TransformExpr(Old->getBase()); 8361 if (Base.isInvalid()) 8362 return ExprError(); 8363 Base = getSema().PerformMemberExprBaseConversion(Base.take(), 8364 Old->isArrow()); 8365 if (Base.isInvalid()) 8366 return ExprError(); 8367 BaseType = Base.get()->getType(); 8368 } else { 8369 BaseType = getDerived().TransformType(Old->getBaseType()); 8370 } 8371 8372 NestedNameSpecifierLoc QualifierLoc; 8373 if (Old->getQualifierLoc()) { 8374 QualifierLoc 8375 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 8376 if (!QualifierLoc) 8377 return ExprError(); 8378 } 8379 8380 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc(); 8381 8382 LookupResult R(SemaRef, Old->getMemberNameInfo(), 8383 Sema::LookupOrdinaryName); 8384 8385 // Transform all the decls. 8386 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 8387 E = Old->decls_end(); I != E; ++I) { 8388 NamedDecl *InstD = static_cast<NamedDecl*>( 8389 getDerived().TransformDecl(Old->getMemberLoc(), 8390 *I)); 8391 if (!InstD) { 8392 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 8393 // This can happen because of dependent hiding. 8394 if (isa<UsingShadowDecl>(*I)) 8395 continue; 8396 else { 8397 R.clear(); 8398 return ExprError(); 8399 } 8400 } 8401 8402 // Expand using declarations. 8403 if (isa<UsingDecl>(InstD)) { 8404 UsingDecl *UD = cast<UsingDecl>(InstD); 8405 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 8406 E = UD->shadow_end(); I != E; ++I) 8407 R.addDecl(*I); 8408 continue; 8409 } 8410 8411 R.addDecl(InstD); 8412 } 8413 8414 R.resolveKind(); 8415 8416 // Determine the naming class. 8417 if (Old->getNamingClass()) { 8418 CXXRecordDecl *NamingClass 8419 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 8420 Old->getMemberLoc(), 8421 Old->getNamingClass())); 8422 if (!NamingClass) 8423 return ExprError(); 8424 8425 R.setNamingClass(NamingClass); 8426 } 8427 8428 TemplateArgumentListInfo TransArgs; 8429 if (Old->hasExplicitTemplateArgs()) { 8430 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 8431 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 8432 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 8433 Old->getNumTemplateArgs(), 8434 TransArgs)) 8435 return ExprError(); 8436 } 8437 8438 // FIXME: to do this check properly, we will need to preserve the 8439 // first-qualifier-in-scope here, just in case we had a dependent 8440 // base (and therefore couldn't do the check) and a 8441 // nested-name-qualifier (and therefore could do the lookup). 8442 NamedDecl *FirstQualifierInScope = 0; 8443 8444 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 8445 BaseType, 8446 Old->getOperatorLoc(), 8447 Old->isArrow(), 8448 QualifierLoc, 8449 TemplateKWLoc, 8450 FirstQualifierInScope, 8451 R, 8452 (Old->hasExplicitTemplateArgs() 8453 ? &TransArgs : 0)); 8454} 8455 8456template<typename Derived> 8457ExprResult 8458TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 8459 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 8460 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 8461 if (SubExpr.isInvalid()) 8462 return ExprError(); 8463 8464 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 8465 return SemaRef.Owned(E); 8466 8467 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 8468} 8469 8470template<typename Derived> 8471ExprResult 8472TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 8473 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 8474 if (Pattern.isInvalid()) 8475 return ExprError(); 8476 8477 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 8478 return SemaRef.Owned(E); 8479 8480 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 8481 E->getNumExpansions()); 8482} 8483 8484template<typename Derived> 8485ExprResult 8486TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 8487 // If E is not value-dependent, then nothing will change when we transform it. 8488 // Note: This is an instantiation-centric view. 8489 if (!E->isValueDependent()) 8490 return SemaRef.Owned(E); 8491 8492 // Note: None of the implementations of TryExpandParameterPacks can ever 8493 // produce a diagnostic when given only a single unexpanded parameter pack, 8494 // so 8495 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 8496 bool ShouldExpand = false; 8497 bool RetainExpansion = false; 8498 Optional<unsigned> NumExpansions; 8499 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 8500 Unexpanded, 8501 ShouldExpand, RetainExpansion, 8502 NumExpansions)) 8503 return ExprError(); 8504 8505 if (RetainExpansion) 8506 return SemaRef.Owned(E); 8507 8508 NamedDecl *Pack = E->getPack(); 8509 if (!ShouldExpand) { 8510 Pack = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getPackLoc(), 8511 Pack)); 8512 if (!Pack) 8513 return ExprError(); 8514 } 8515 8516 8517 // We now know the length of the parameter pack, so build a new expression 8518 // that stores that length. 8519 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), Pack, 8520 E->getPackLoc(), E->getRParenLoc(), 8521 NumExpansions); 8522} 8523 8524template<typename Derived> 8525ExprResult 8526TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 8527 SubstNonTypeTemplateParmPackExpr *E) { 8528 // Default behavior is to do nothing with this transformation. 8529 return SemaRef.Owned(E); 8530} 8531 8532template<typename Derived> 8533ExprResult 8534TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( 8535 SubstNonTypeTemplateParmExpr *E) { 8536 // Default behavior is to do nothing with this transformation. 8537 return SemaRef.Owned(E); 8538} 8539 8540template<typename Derived> 8541ExprResult 8542TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) { 8543 // Default behavior is to do nothing with this transformation. 8544 return SemaRef.Owned(E); 8545} 8546 8547template<typename Derived> 8548ExprResult 8549TreeTransform<Derived>::TransformMaterializeTemporaryExpr( 8550 MaterializeTemporaryExpr *E) { 8551 return getDerived().TransformExpr(E->GetTemporaryExpr()); 8552} 8553 8554template<typename Derived> 8555ExprResult 8556TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 8557 return SemaRef.MaybeBindToTemporary(E); 8558} 8559 8560template<typename Derived> 8561ExprResult 8562TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) { 8563 return SemaRef.Owned(E); 8564} 8565 8566template<typename Derived> 8567ExprResult 8568TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) { 8569 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 8570 if (SubExpr.isInvalid()) 8571 return ExprError(); 8572 8573 if (!getDerived().AlwaysRebuild() && 8574 SubExpr.get() == E->getSubExpr()) 8575 return SemaRef.Owned(E); 8576 8577 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get()); 8578} 8579 8580template<typename Derived> 8581ExprResult 8582TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) { 8583 // Transform each of the elements. 8584 SmallVector<Expr *, 8> Elements; 8585 bool ArgChanged = false; 8586 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(), 8587 /*IsCall=*/false, Elements, &ArgChanged)) 8588 return ExprError(); 8589 8590 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8591 return SemaRef.MaybeBindToTemporary(E); 8592 8593 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(), 8594 Elements.data(), 8595 Elements.size()); 8596} 8597 8598template<typename Derived> 8599ExprResult 8600TreeTransform<Derived>::TransformObjCDictionaryLiteral( 8601 ObjCDictionaryLiteral *E) { 8602 // Transform each of the elements. 8603 SmallVector<ObjCDictionaryElement, 8> Elements; 8604 bool ArgChanged = false; 8605 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 8606 ObjCDictionaryElement OrigElement = E->getKeyValueElement(I); 8607 8608 if (OrigElement.isPackExpansion()) { 8609 // This key/value element is a pack expansion. 8610 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 8611 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded); 8612 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded); 8613 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 8614 8615 // Determine whether the set of unexpanded parameter packs can 8616 // and should be expanded. 8617 bool Expand = true; 8618 bool RetainExpansion = false; 8619 Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; 8620 Optional<unsigned> NumExpansions = OrigNumExpansions; 8621 SourceRange PatternRange(OrigElement.Key->getLocStart(), 8622 OrigElement.Value->getLocEnd()); 8623 if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, 8624 PatternRange, 8625 Unexpanded, 8626 Expand, RetainExpansion, 8627 NumExpansions)) 8628 return ExprError(); 8629 8630 if (!Expand) { 8631 // The transform has determined that we should perform a simple 8632 // transformation on the pack expansion, producing another pack 8633 // expansion. 8634 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 8635 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8636 if (Key.isInvalid()) 8637 return ExprError(); 8638 8639 if (Key.get() != OrigElement.Key) 8640 ArgChanged = true; 8641 8642 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 8643 if (Value.isInvalid()) 8644 return ExprError(); 8645 8646 if (Value.get() != OrigElement.Value) 8647 ArgChanged = true; 8648 8649 ObjCDictionaryElement Expansion = { 8650 Key.get(), Value.get(), OrigElement.EllipsisLoc, NumExpansions 8651 }; 8652 Elements.push_back(Expansion); 8653 continue; 8654 } 8655 8656 // Record right away that the argument was changed. This needs 8657 // to happen even if the array expands to nothing. 8658 ArgChanged = true; 8659 8660 // The transform has determined that we should perform an elementwise 8661 // expansion of the pattern. Do so. 8662 for (unsigned I = 0; I != *NumExpansions; ++I) { 8663 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 8664 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8665 if (Key.isInvalid()) 8666 return ExprError(); 8667 8668 ExprResult Value = getDerived().TransformExpr(OrigElement.Value); 8669 if (Value.isInvalid()) 8670 return ExprError(); 8671 8672 ObjCDictionaryElement Element = { 8673 Key.get(), Value.get(), SourceLocation(), NumExpansions 8674 }; 8675 8676 // If any unexpanded parameter packs remain, we still have a 8677 // pack expansion. 8678 if (Key.get()->containsUnexpandedParameterPack() || 8679 Value.get()->containsUnexpandedParameterPack()) 8680 Element.EllipsisLoc = OrigElement.EllipsisLoc; 8681 8682 Elements.push_back(Element); 8683 } 8684 8685 // We've finished with this pack expansion. 8686 continue; 8687 } 8688 8689 // Transform and check key. 8690 ExprResult Key = getDerived().TransformExpr(OrigElement.Key); 8691 if (Key.isInvalid()) 8692 return ExprError(); 8693 8694 if (Key.get() != OrigElement.Key) 8695 ArgChanged = true; 8696 8697 // Transform and check value. 8698 ExprResult Value 8699 = getDerived().TransformExpr(OrigElement.Value); 8700 if (Value.isInvalid()) 8701 return ExprError(); 8702 8703 if (Value.get() != OrigElement.Value) 8704 ArgChanged = true; 8705 8706 ObjCDictionaryElement Element = { 8707 Key.get(), Value.get(), SourceLocation(), None 8708 }; 8709 Elements.push_back(Element); 8710 } 8711 8712 if (!getDerived().AlwaysRebuild() && !ArgChanged) 8713 return SemaRef.MaybeBindToTemporary(E); 8714 8715 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(), 8716 Elements.data(), 8717 Elements.size()); 8718} 8719 8720template<typename Derived> 8721ExprResult 8722TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 8723 TypeSourceInfo *EncodedTypeInfo 8724 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 8725 if (!EncodedTypeInfo) 8726 return ExprError(); 8727 8728 if (!getDerived().AlwaysRebuild() && 8729 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 8730 return SemaRef.Owned(E); 8731 8732 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 8733 EncodedTypeInfo, 8734 E->getRParenLoc()); 8735} 8736 8737template<typename Derived> 8738ExprResult TreeTransform<Derived>:: 8739TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 8740 // This is a kind of implicit conversion, and it needs to get dropped 8741 // and recomputed for the same general reasons that ImplicitCastExprs 8742 // do, as well a more specific one: this expression is only valid when 8743 // it appears *immediately* as an argument expression. 8744 return getDerived().TransformExpr(E->getSubExpr()); 8745} 8746 8747template<typename Derived> 8748ExprResult TreeTransform<Derived>:: 8749TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 8750 TypeSourceInfo *TSInfo 8751 = getDerived().TransformType(E->getTypeInfoAsWritten()); 8752 if (!TSInfo) 8753 return ExprError(); 8754 8755 ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); 8756 if (Result.isInvalid()) 8757 return ExprError(); 8758 8759 if (!getDerived().AlwaysRebuild() && 8760 TSInfo == E->getTypeInfoAsWritten() && 8761 Result.get() == E->getSubExpr()) 8762 return SemaRef.Owned(E); 8763 8764 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), 8765 E->getBridgeKeywordLoc(), TSInfo, 8766 Result.get()); 8767} 8768 8769template<typename Derived> 8770ExprResult 8771TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 8772 // Transform arguments. 8773 bool ArgChanged = false; 8774 SmallVector<Expr*, 8> Args; 8775 Args.reserve(E->getNumArgs()); 8776 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 8777 &ArgChanged)) 8778 return ExprError(); 8779 8780 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 8781 // Class message: transform the receiver type. 8782 TypeSourceInfo *ReceiverTypeInfo 8783 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 8784 if (!ReceiverTypeInfo) 8785 return ExprError(); 8786 8787 // If nothing changed, just retain the existing message send. 8788 if (!getDerived().AlwaysRebuild() && 8789 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 8790 return SemaRef.MaybeBindToTemporary(E); 8791 8792 // Build a new class message send. 8793 SmallVector<SourceLocation, 16> SelLocs; 8794 E->getSelectorLocs(SelLocs); 8795 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 8796 E->getSelector(), 8797 SelLocs, 8798 E->getMethodDecl(), 8799 E->getLeftLoc(), 8800 Args, 8801 E->getRightLoc()); 8802 } 8803 8804 // Instance message: transform the receiver 8805 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 8806 "Only class and instance messages may be instantiated"); 8807 ExprResult Receiver 8808 = getDerived().TransformExpr(E->getInstanceReceiver()); 8809 if (Receiver.isInvalid()) 8810 return ExprError(); 8811 8812 // If nothing changed, just retain the existing message send. 8813 if (!getDerived().AlwaysRebuild() && 8814 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 8815 return SemaRef.MaybeBindToTemporary(E); 8816 8817 // Build a new instance message send. 8818 SmallVector<SourceLocation, 16> SelLocs; 8819 E->getSelectorLocs(SelLocs); 8820 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 8821 E->getSelector(), 8822 SelLocs, 8823 E->getMethodDecl(), 8824 E->getLeftLoc(), 8825 Args, 8826 E->getRightLoc()); 8827} 8828 8829template<typename Derived> 8830ExprResult 8831TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 8832 return SemaRef.Owned(E); 8833} 8834 8835template<typename Derived> 8836ExprResult 8837TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 8838 return SemaRef.Owned(E); 8839} 8840 8841template<typename Derived> 8842ExprResult 8843TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 8844 // Transform the base expression. 8845 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8846 if (Base.isInvalid()) 8847 return ExprError(); 8848 8849 // We don't need to transform the ivar; it will never change. 8850 8851 // If nothing changed, just retain the existing expression. 8852 if (!getDerived().AlwaysRebuild() && 8853 Base.get() == E->getBase()) 8854 return SemaRef.Owned(E); 8855 8856 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 8857 E->getLocation(), 8858 E->isArrow(), E->isFreeIvar()); 8859} 8860 8861template<typename Derived> 8862ExprResult 8863TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 8864 // 'super' and types never change. Property never changes. Just 8865 // retain the existing expression. 8866 if (!E->isObjectReceiver()) 8867 return SemaRef.Owned(E); 8868 8869 // Transform the base expression. 8870 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8871 if (Base.isInvalid()) 8872 return ExprError(); 8873 8874 // We don't need to transform the property; it will never change. 8875 8876 // If nothing changed, just retain the existing expression. 8877 if (!getDerived().AlwaysRebuild() && 8878 Base.get() == E->getBase()) 8879 return SemaRef.Owned(E); 8880 8881 if (E->isExplicitProperty()) 8882 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 8883 E->getExplicitProperty(), 8884 E->getLocation()); 8885 8886 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 8887 SemaRef.Context.PseudoObjectTy, 8888 E->getImplicitPropertyGetter(), 8889 E->getImplicitPropertySetter(), 8890 E->getLocation()); 8891} 8892 8893template<typename Derived> 8894ExprResult 8895TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) { 8896 // Transform the base expression. 8897 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr()); 8898 if (Base.isInvalid()) 8899 return ExprError(); 8900 8901 // Transform the key expression. 8902 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr()); 8903 if (Key.isInvalid()) 8904 return ExprError(); 8905 8906 // If nothing changed, just retain the existing expression. 8907 if (!getDerived().AlwaysRebuild() && 8908 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr()) 8909 return SemaRef.Owned(E); 8910 8911 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(), 8912 Base.get(), Key.get(), 8913 E->getAtIndexMethodDecl(), 8914 E->setAtIndexMethodDecl()); 8915} 8916 8917template<typename Derived> 8918ExprResult 8919TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 8920 // Transform the base expression. 8921 ExprResult Base = getDerived().TransformExpr(E->getBase()); 8922 if (Base.isInvalid()) 8923 return ExprError(); 8924 8925 // If nothing changed, just retain the existing expression. 8926 if (!getDerived().AlwaysRebuild() && 8927 Base.get() == E->getBase()) 8928 return SemaRef.Owned(E); 8929 8930 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 8931 E->getOpLoc(), 8932 E->isArrow()); 8933} 8934 8935template<typename Derived> 8936ExprResult 8937TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 8938 bool ArgumentChanged = false; 8939 SmallVector<Expr*, 8> SubExprs; 8940 SubExprs.reserve(E->getNumSubExprs()); 8941 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 8942 SubExprs, &ArgumentChanged)) 8943 return ExprError(); 8944 8945 if (!getDerived().AlwaysRebuild() && 8946 !ArgumentChanged) 8947 return SemaRef.Owned(E); 8948 8949 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 8950 SubExprs, 8951 E->getRParenLoc()); 8952} 8953 8954template<typename Derived> 8955ExprResult 8956TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 8957 BlockDecl *oldBlock = E->getBlockDecl(); 8958 8959 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/0); 8960 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 8961 8962 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 8963 blockScope->TheDecl->setBlockMissingReturnType( 8964 oldBlock->blockMissingReturnType()); 8965 8966 SmallVector<ParmVarDecl*, 4> params; 8967 SmallVector<QualType, 4> paramTypes; 8968 8969 // Parameter substitution. 8970 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 8971 oldBlock->param_begin(), 8972 oldBlock->param_size(), 8973 0, paramTypes, ¶ms)) { 8974 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 8975 return ExprError(); 8976 } 8977 8978 const FunctionProtoType *exprFunctionType = E->getFunctionType(); 8979 QualType exprResultType = 8980 getDerived().TransformType(exprFunctionType->getResultType()); 8981 8982 // Don't allow returning a objc interface by value. 8983 if (exprResultType->isObjCObjectType()) { 8984 getSema().Diag(E->getCaretLocation(), 8985 diag::err_object_cannot_be_passed_returned_by_value) 8986 << 0 << exprResultType; 8987 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 8988 return ExprError(); 8989 } 8990 8991 QualType functionType = 8992 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, 8993 exprFunctionType->getExtProtoInfo()); 8994 blockScope->FunctionType = functionType; 8995 8996 // Set the parameters on the block decl. 8997 if (!params.empty()) 8998 blockScope->TheDecl->setParams(params); 8999 9000 if (!oldBlock->blockMissingReturnType()) { 9001 blockScope->HasImplicitReturnType = false; 9002 blockScope->ReturnType = exprResultType; 9003 } 9004 9005 // Transform the body 9006 StmtResult body = getDerived().TransformStmt(E->getBody()); 9007 if (body.isInvalid()) { 9008 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/0); 9009 return ExprError(); 9010 } 9011 9012#ifndef NDEBUG 9013 // In builds with assertions, make sure that we captured everything we 9014 // captured before. 9015 if (!SemaRef.getDiagnostics().hasErrorOccurred()) { 9016 for (BlockDecl::capture_iterator i = oldBlock->capture_begin(), 9017 e = oldBlock->capture_end(); i != e; ++i) { 9018 VarDecl *oldCapture = i->getVariable(); 9019 9020 // Ignore parameter packs. 9021 if (isa<ParmVarDecl>(oldCapture) && 9022 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 9023 continue; 9024 9025 VarDecl *newCapture = 9026 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 9027 oldCapture)); 9028 assert(blockScope->CaptureMap.count(newCapture)); 9029 } 9030 assert(oldBlock->capturesCXXThis() == blockScope->isCXXThisCaptured()); 9031 } 9032#endif 9033 9034 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 9035 /*Scope=*/0); 9036} 9037 9038template<typename Derived> 9039ExprResult 9040TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { 9041 llvm_unreachable("Cannot transform asType expressions yet"); 9042} 9043 9044template<typename Derived> 9045ExprResult 9046TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) { 9047 QualType RetTy = getDerived().TransformType(E->getType()); 9048 bool ArgumentChanged = false; 9049 SmallVector<Expr*, 8> SubExprs; 9050 SubExprs.reserve(E->getNumSubExprs()); 9051 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 9052 SubExprs, &ArgumentChanged)) 9053 return ExprError(); 9054 9055 if (!getDerived().AlwaysRebuild() && 9056 !ArgumentChanged) 9057 return SemaRef.Owned(E); 9058 9059 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs, 9060 RetTy, E->getOp(), E->getRParenLoc()); 9061} 9062 9063//===----------------------------------------------------------------------===// 9064// Type reconstruction 9065//===----------------------------------------------------------------------===// 9066 9067template<typename Derived> 9068QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 9069 SourceLocation Star) { 9070 return SemaRef.BuildPointerType(PointeeType, Star, 9071 getDerived().getBaseEntity()); 9072} 9073 9074template<typename Derived> 9075QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 9076 SourceLocation Star) { 9077 return SemaRef.BuildBlockPointerType(PointeeType, Star, 9078 getDerived().getBaseEntity()); 9079} 9080 9081template<typename Derived> 9082QualType 9083TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 9084 bool WrittenAsLValue, 9085 SourceLocation Sigil) { 9086 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 9087 Sigil, getDerived().getBaseEntity()); 9088} 9089 9090template<typename Derived> 9091QualType 9092TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 9093 QualType ClassType, 9094 SourceLocation Sigil) { 9095 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 9096 Sigil, getDerived().getBaseEntity()); 9097} 9098 9099template<typename Derived> 9100QualType 9101TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 9102 ArrayType::ArraySizeModifier SizeMod, 9103 const llvm::APInt *Size, 9104 Expr *SizeExpr, 9105 unsigned IndexTypeQuals, 9106 SourceRange BracketsRange) { 9107 if (SizeExpr || !Size) 9108 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 9109 IndexTypeQuals, BracketsRange, 9110 getDerived().getBaseEntity()); 9111 9112 QualType Types[] = { 9113 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 9114 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 9115 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 9116 }; 9117 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 9118 QualType SizeType; 9119 for (unsigned I = 0; I != NumTypes; ++I) 9120 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 9121 SizeType = Types[I]; 9122 break; 9123 } 9124 9125 // Note that we can return a VariableArrayType here in the case where 9126 // the element type was a dependent VariableArrayType. 9127 IntegerLiteral *ArraySize 9128 = IntegerLiteral::Create(SemaRef.Context, *Size, SizeType, 9129 /*FIXME*/BracketsRange.getBegin()); 9130 return SemaRef.BuildArrayType(ElementType, SizeMod, ArraySize, 9131 IndexTypeQuals, BracketsRange, 9132 getDerived().getBaseEntity()); 9133} 9134 9135template<typename Derived> 9136QualType 9137TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 9138 ArrayType::ArraySizeModifier SizeMod, 9139 const llvm::APInt &Size, 9140 unsigned IndexTypeQuals, 9141 SourceRange BracketsRange) { 9142 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 9143 IndexTypeQuals, BracketsRange); 9144} 9145 9146template<typename Derived> 9147QualType 9148TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 9149 ArrayType::ArraySizeModifier SizeMod, 9150 unsigned IndexTypeQuals, 9151 SourceRange BracketsRange) { 9152 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 9153 IndexTypeQuals, BracketsRange); 9154} 9155 9156template<typename Derived> 9157QualType 9158TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 9159 ArrayType::ArraySizeModifier SizeMod, 9160 Expr *SizeExpr, 9161 unsigned IndexTypeQuals, 9162 SourceRange BracketsRange) { 9163 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 9164 SizeExpr, 9165 IndexTypeQuals, BracketsRange); 9166} 9167 9168template<typename Derived> 9169QualType 9170TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 9171 ArrayType::ArraySizeModifier SizeMod, 9172 Expr *SizeExpr, 9173 unsigned IndexTypeQuals, 9174 SourceRange BracketsRange) { 9175 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 9176 SizeExpr, 9177 IndexTypeQuals, BracketsRange); 9178} 9179 9180template<typename Derived> 9181QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 9182 unsigned NumElements, 9183 VectorType::VectorKind VecKind) { 9184 // FIXME: semantic checking! 9185 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 9186} 9187 9188template<typename Derived> 9189QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 9190 unsigned NumElements, 9191 SourceLocation AttributeLoc) { 9192 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 9193 NumElements, true); 9194 IntegerLiteral *VectorSize 9195 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 9196 AttributeLoc); 9197 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 9198} 9199 9200template<typename Derived> 9201QualType 9202TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 9203 Expr *SizeExpr, 9204 SourceLocation AttributeLoc) { 9205 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 9206} 9207 9208template<typename Derived> 9209QualType TreeTransform<Derived>::RebuildFunctionProtoType( 9210 QualType T, 9211 llvm::MutableArrayRef<QualType> ParamTypes, 9212 const FunctionProtoType::ExtProtoInfo &EPI) { 9213 return SemaRef.BuildFunctionType(T, ParamTypes, 9214 getDerived().getBaseLocation(), 9215 getDerived().getBaseEntity(), 9216 EPI); 9217} 9218 9219template<typename Derived> 9220QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 9221 return SemaRef.Context.getFunctionNoProtoType(T); 9222} 9223 9224template<typename Derived> 9225QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 9226 assert(D && "no decl found"); 9227 if (D->isInvalidDecl()) return QualType(); 9228 9229 // FIXME: Doesn't account for ObjCInterfaceDecl! 9230 TypeDecl *Ty; 9231 if (isa<UsingDecl>(D)) { 9232 UsingDecl *Using = cast<UsingDecl>(D); 9233 assert(Using->isTypeName() && 9234 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 9235 9236 // A valid resolved using typename decl points to exactly one type decl. 9237 assert(++Using->shadow_begin() == Using->shadow_end()); 9238 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 9239 9240 } else { 9241 assert(isa<UnresolvedUsingTypenameDecl>(D) && 9242 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 9243 Ty = cast<UnresolvedUsingTypenameDecl>(D); 9244 } 9245 9246 return SemaRef.Context.getTypeDeclType(Ty); 9247} 9248 9249template<typename Derived> 9250QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 9251 SourceLocation Loc) { 9252 return SemaRef.BuildTypeofExprType(E, Loc); 9253} 9254 9255template<typename Derived> 9256QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 9257 return SemaRef.Context.getTypeOfType(Underlying); 9258} 9259 9260template<typename Derived> 9261QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 9262 SourceLocation Loc) { 9263 return SemaRef.BuildDecltypeType(E, Loc); 9264} 9265 9266template<typename Derived> 9267QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, 9268 UnaryTransformType::UTTKind UKind, 9269 SourceLocation Loc) { 9270 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); 9271} 9272 9273template<typename Derived> 9274QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 9275 TemplateName Template, 9276 SourceLocation TemplateNameLoc, 9277 TemplateArgumentListInfo &TemplateArgs) { 9278 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 9279} 9280 9281template<typename Derived> 9282QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType, 9283 SourceLocation KWLoc) { 9284 return SemaRef.BuildAtomicType(ValueType, KWLoc); 9285} 9286 9287template<typename Derived> 9288TemplateName 9289TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9290 bool TemplateKW, 9291 TemplateDecl *Template) { 9292 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 9293 Template); 9294} 9295 9296template<typename Derived> 9297TemplateName 9298TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9299 const IdentifierInfo &Name, 9300 SourceLocation NameLoc, 9301 QualType ObjectType, 9302 NamedDecl *FirstQualifierInScope) { 9303 UnqualifiedId TemplateName; 9304 TemplateName.setIdentifier(&Name, NameLoc); 9305 Sema::TemplateTy Template; 9306 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9307 getSema().ActOnDependentTemplateName(/*Scope=*/0, 9308 SS, TemplateKWLoc, TemplateName, 9309 ParsedType::make(ObjectType), 9310 /*EnteringContext=*/false, 9311 Template); 9312 return Template.get(); 9313} 9314 9315template<typename Derived> 9316TemplateName 9317TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 9318 OverloadedOperatorKind Operator, 9319 SourceLocation NameLoc, 9320 QualType ObjectType) { 9321 UnqualifiedId Name; 9322 // FIXME: Bogus location information. 9323 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 9324 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 9325 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9326 Sema::TemplateTy Template; 9327 getSema().ActOnDependentTemplateName(/*Scope=*/0, 9328 SS, TemplateKWLoc, Name, 9329 ParsedType::make(ObjectType), 9330 /*EnteringContext=*/false, 9331 Template); 9332 return Template.template getAsVal<TemplateName>(); 9333} 9334 9335template<typename Derived> 9336ExprResult 9337TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 9338 SourceLocation OpLoc, 9339 Expr *OrigCallee, 9340 Expr *First, 9341 Expr *Second) { 9342 Expr *Callee = OrigCallee->IgnoreParenCasts(); 9343 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 9344 9345 // Determine whether this should be a builtin operation. 9346 if (Op == OO_Subscript) { 9347 if (!First->getType()->isOverloadableType() && 9348 !Second->getType()->isOverloadableType()) 9349 return getSema().CreateBuiltinArraySubscriptExpr(First, 9350 Callee->getLocStart(), 9351 Second, OpLoc); 9352 } else if (Op == OO_Arrow) { 9353 // -> is never a builtin operation. 9354 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 9355 } else if (Second == 0 || isPostIncDec) { 9356 if (!First->getType()->isOverloadableType()) { 9357 // The argument is not of overloadable type, so try to create a 9358 // built-in unary operation. 9359 UnaryOperatorKind Opc 9360 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9361 9362 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 9363 } 9364 } else { 9365 if (!First->getType()->isOverloadableType() && 9366 !Second->getType()->isOverloadableType()) { 9367 // Neither of the arguments is an overloadable type, so try to 9368 // create a built-in binary operation. 9369 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9370 ExprResult Result 9371 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 9372 if (Result.isInvalid()) 9373 return ExprError(); 9374 9375 return Result; 9376 } 9377 } 9378 9379 // Compute the transformed set of functions (and function templates) to be 9380 // used during overload resolution. 9381 UnresolvedSet<16> Functions; 9382 9383 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 9384 assert(ULE->requiresADL()); 9385 9386 // FIXME: Do we have to check 9387 // IsAcceptableNonMemberOperatorCandidate for each of these? 9388 Functions.append(ULE->decls_begin(), ULE->decls_end()); 9389 } else { 9390 // If we've resolved this to a particular non-member function, just call 9391 // that function. If we resolved it to a member function, 9392 // CreateOverloaded* will find that function for us. 9393 NamedDecl *ND = cast<DeclRefExpr>(Callee)->getDecl(); 9394 if (!isa<CXXMethodDecl>(ND)) 9395 Functions.addDecl(ND); 9396 } 9397 9398 // Add any functions found via argument-dependent lookup. 9399 Expr *Args[2] = { First, Second }; 9400 unsigned NumArgs = 1 + (Second != 0); 9401 9402 // Create the overloaded operator invocation for unary operators. 9403 if (NumArgs == 1 || isPostIncDec) { 9404 UnaryOperatorKind Opc 9405 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 9406 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 9407 } 9408 9409 if (Op == OO_Subscript) { 9410 SourceLocation LBrace; 9411 SourceLocation RBrace; 9412 9413 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { 9414 DeclarationNameLoc &NameLoc = DRE->getNameInfo().getInfo(); 9415 LBrace = SourceLocation::getFromRawEncoding( 9416 NameLoc.CXXOperatorName.BeginOpNameLoc); 9417 RBrace = SourceLocation::getFromRawEncoding( 9418 NameLoc.CXXOperatorName.EndOpNameLoc); 9419 } else { 9420 LBrace = Callee->getLocStart(); 9421 RBrace = OpLoc; 9422 } 9423 9424 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, 9425 First, Second); 9426 } 9427 9428 // Create the overloaded operator invocation for binary operators. 9429 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 9430 ExprResult Result 9431 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 9432 if (Result.isInvalid()) 9433 return ExprError(); 9434 9435 return Result; 9436} 9437 9438template<typename Derived> 9439ExprResult 9440TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 9441 SourceLocation OperatorLoc, 9442 bool isArrow, 9443 CXXScopeSpec &SS, 9444 TypeSourceInfo *ScopeType, 9445 SourceLocation CCLoc, 9446 SourceLocation TildeLoc, 9447 PseudoDestructorTypeStorage Destroyed) { 9448 QualType BaseType = Base->getType(); 9449 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 9450 (!isArrow && !BaseType->getAs<RecordType>()) || 9451 (isArrow && BaseType->getAs<PointerType>() && 9452 !BaseType->getAs<PointerType>()->getPointeeType() 9453 ->template getAs<RecordType>())){ 9454 // This pseudo-destructor expression is still a pseudo-destructor. 9455 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 9456 isArrow? tok::arrow : tok::period, 9457 SS, ScopeType, CCLoc, TildeLoc, 9458 Destroyed, 9459 /*FIXME?*/true); 9460 } 9461 9462 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 9463 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 9464 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 9465 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 9466 NameInfo.setNamedTypeInfo(DestroyedType); 9467 9468 // The scope type is now known to be a valid nested name specifier 9469 // component. Tack it on to the end of the nested name specifier. 9470 if (ScopeType) 9471 SS.Extend(SemaRef.Context, SourceLocation(), 9472 ScopeType->getTypeLoc(), CCLoc); 9473 9474 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller. 9475 return getSema().BuildMemberReferenceExpr(Base, BaseType, 9476 OperatorLoc, isArrow, 9477 SS, TemplateKWLoc, 9478 /*FIXME: FirstQualifier*/ 0, 9479 NameInfo, 9480 /*TemplateArgs*/ 0); 9481} 9482 9483template<typename Derived> 9484StmtResult 9485TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) { 9486 SourceLocation Loc = S->getLocStart(); 9487 unsigned NumParams = S->getCapturedDecl()->getNumParams(); 9488 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/0, 9489 S->getCapturedRegionKind(), NumParams); 9490 StmtResult Body = getDerived().TransformStmt(S->getCapturedStmt()); 9491 9492 if (Body.isInvalid()) { 9493 getSema().ActOnCapturedRegionError(); 9494 return StmtError(); 9495 } 9496 9497 return getSema().ActOnCapturedRegionEnd(Body.take()); 9498} 9499 9500} // end namespace clang 9501 9502#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 9503