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