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