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