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