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