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