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