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