TreeTransform.h revision 087eb5a2d3c7988eb7c440cd86cc7479e57d5dc0
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 const MemberPointerType *T = TL.getTypePtr(); 3312 3313 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3314 if (PointeeType.isNull()) 3315 return QualType(); 3316 3317 // TODO: preserve source information for this. 3318 QualType ClassType 3319 = getDerived().TransformType(QualType(T->getClass(), 0)); 3320 if (ClassType.isNull()) 3321 return QualType(); 3322 3323 QualType Result = TL.getType(); 3324 if (getDerived().AlwaysRebuild() || 3325 PointeeType != T->getPointeeType() || 3326 ClassType != QualType(T->getClass(), 0)) { 3327 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType, 3328 TL.getStarLoc()); 3329 if (Result.isNull()) 3330 return QualType(); 3331 } 3332 3333 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 3334 NewTL.setSigilLoc(TL.getSigilLoc()); 3335 3336 return Result; 3337} 3338 3339template<typename Derived> 3340QualType 3341TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 3342 ConstantArrayTypeLoc TL) { 3343 const ConstantArrayType *T = TL.getTypePtr(); 3344 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3345 if (ElementType.isNull()) 3346 return QualType(); 3347 3348 QualType Result = TL.getType(); 3349 if (getDerived().AlwaysRebuild() || 3350 ElementType != T->getElementType()) { 3351 Result = getDerived().RebuildConstantArrayType(ElementType, 3352 T->getSizeModifier(), 3353 T->getSize(), 3354 T->getIndexTypeCVRQualifiers(), 3355 TL.getBracketsRange()); 3356 if (Result.isNull()) 3357 return QualType(); 3358 } 3359 3360 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 3361 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3362 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3363 3364 Expr *Size = TL.getSizeExpr(); 3365 if (Size) { 3366 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3367 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 3368 } 3369 NewTL.setSizeExpr(Size); 3370 3371 return Result; 3372} 3373 3374template<typename Derived> 3375QualType TreeTransform<Derived>::TransformIncompleteArrayType( 3376 TypeLocBuilder &TLB, 3377 IncompleteArrayTypeLoc TL) { 3378 const IncompleteArrayType *T = TL.getTypePtr(); 3379 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3380 if (ElementType.isNull()) 3381 return QualType(); 3382 3383 QualType Result = TL.getType(); 3384 if (getDerived().AlwaysRebuild() || 3385 ElementType != T->getElementType()) { 3386 Result = getDerived().RebuildIncompleteArrayType(ElementType, 3387 T->getSizeModifier(), 3388 T->getIndexTypeCVRQualifiers(), 3389 TL.getBracketsRange()); 3390 if (Result.isNull()) 3391 return QualType(); 3392 } 3393 3394 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 3395 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3396 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3397 NewTL.setSizeExpr(0); 3398 3399 return Result; 3400} 3401 3402template<typename Derived> 3403QualType 3404TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 3405 VariableArrayTypeLoc TL) { 3406 const VariableArrayType *T = TL.getTypePtr(); 3407 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3408 if (ElementType.isNull()) 3409 return QualType(); 3410 3411 // Array bounds are not potentially evaluated contexts 3412 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3413 3414 ExprResult SizeResult 3415 = getDerived().TransformExpr(T->getSizeExpr()); 3416 if (SizeResult.isInvalid()) 3417 return QualType(); 3418 3419 Expr *Size = SizeResult.take(); 3420 3421 QualType Result = TL.getType(); 3422 if (getDerived().AlwaysRebuild() || 3423 ElementType != T->getElementType() || 3424 Size != T->getSizeExpr()) { 3425 Result = getDerived().RebuildVariableArrayType(ElementType, 3426 T->getSizeModifier(), 3427 Size, 3428 T->getIndexTypeCVRQualifiers(), 3429 TL.getBracketsRange()); 3430 if (Result.isNull()) 3431 return QualType(); 3432 } 3433 3434 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 3435 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3436 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3437 NewTL.setSizeExpr(Size); 3438 3439 return Result; 3440} 3441 3442template<typename Derived> 3443QualType 3444TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 3445 DependentSizedArrayTypeLoc TL) { 3446 const DependentSizedArrayType *T = TL.getTypePtr(); 3447 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3448 if (ElementType.isNull()) 3449 return QualType(); 3450 3451 // Array bounds are not potentially evaluated contexts 3452 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3453 3454 // Prefer the expression from the TypeLoc; the other may have been uniqued. 3455 Expr *origSize = TL.getSizeExpr(); 3456 if (!origSize) origSize = T->getSizeExpr(); 3457 3458 ExprResult sizeResult 3459 = getDerived().TransformExpr(origSize); 3460 if (sizeResult.isInvalid()) 3461 return QualType(); 3462 3463 Expr *size = sizeResult.get(); 3464 3465 QualType Result = TL.getType(); 3466 if (getDerived().AlwaysRebuild() || 3467 ElementType != T->getElementType() || 3468 size != origSize) { 3469 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 3470 T->getSizeModifier(), 3471 size, 3472 T->getIndexTypeCVRQualifiers(), 3473 TL.getBracketsRange()); 3474 if (Result.isNull()) 3475 return QualType(); 3476 } 3477 3478 // We might have any sort of array type now, but fortunately they 3479 // all have the same location layout. 3480 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3481 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3482 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3483 NewTL.setSizeExpr(size); 3484 3485 return Result; 3486} 3487 3488template<typename Derived> 3489QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 3490 TypeLocBuilder &TLB, 3491 DependentSizedExtVectorTypeLoc TL) { 3492 const DependentSizedExtVectorType *T = TL.getTypePtr(); 3493 3494 // FIXME: ext vector locs should be nested 3495 QualType ElementType = getDerived().TransformType(T->getElementType()); 3496 if (ElementType.isNull()) 3497 return QualType(); 3498 3499 // Vector sizes are not potentially evaluated contexts 3500 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3501 3502 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 3503 if (Size.isInvalid()) 3504 return QualType(); 3505 3506 QualType Result = TL.getType(); 3507 if (getDerived().AlwaysRebuild() || 3508 ElementType != T->getElementType() || 3509 Size.get() != T->getSizeExpr()) { 3510 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 3511 Size.take(), 3512 T->getAttributeLoc()); 3513 if (Result.isNull()) 3514 return QualType(); 3515 } 3516 3517 // Result might be dependent or not. 3518 if (isa<DependentSizedExtVectorType>(Result)) { 3519 DependentSizedExtVectorTypeLoc NewTL 3520 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 3521 NewTL.setNameLoc(TL.getNameLoc()); 3522 } else { 3523 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3524 NewTL.setNameLoc(TL.getNameLoc()); 3525 } 3526 3527 return Result; 3528} 3529 3530template<typename Derived> 3531QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 3532 VectorTypeLoc TL) { 3533 const VectorType *T = TL.getTypePtr(); 3534 QualType ElementType = getDerived().TransformType(T->getElementType()); 3535 if (ElementType.isNull()) 3536 return QualType(); 3537 3538 QualType Result = TL.getType(); 3539 if (getDerived().AlwaysRebuild() || 3540 ElementType != T->getElementType()) { 3541 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 3542 T->getVectorKind()); 3543 if (Result.isNull()) 3544 return QualType(); 3545 } 3546 3547 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 3548 NewTL.setNameLoc(TL.getNameLoc()); 3549 3550 return Result; 3551} 3552 3553template<typename Derived> 3554QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 3555 ExtVectorTypeLoc TL) { 3556 const VectorType *T = TL.getTypePtr(); 3557 QualType ElementType = getDerived().TransformType(T->getElementType()); 3558 if (ElementType.isNull()) 3559 return QualType(); 3560 3561 QualType Result = TL.getType(); 3562 if (getDerived().AlwaysRebuild() || 3563 ElementType != T->getElementType()) { 3564 Result = getDerived().RebuildExtVectorType(ElementType, 3565 T->getNumElements(), 3566 /*FIXME*/ SourceLocation()); 3567 if (Result.isNull()) 3568 return QualType(); 3569 } 3570 3571 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3572 NewTL.setNameLoc(TL.getNameLoc()); 3573 3574 return Result; 3575} 3576 3577template<typename Derived> 3578ParmVarDecl * 3579TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm, 3580 llvm::Optional<unsigned> NumExpansions) { 3581 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 3582 TypeSourceInfo *NewDI = 0; 3583 3584 if (NumExpansions && isa<PackExpansionType>(OldDI->getType())) { 3585 // If we're substituting into a pack expansion type and we know the 3586 TypeLoc OldTL = OldDI->getTypeLoc(); 3587 PackExpansionTypeLoc OldExpansionTL = cast<PackExpansionTypeLoc>(OldTL); 3588 3589 TypeLocBuilder TLB; 3590 TypeLoc NewTL = OldDI->getTypeLoc(); 3591 TLB.reserve(NewTL.getFullDataSize()); 3592 3593 QualType Result = getDerived().TransformType(TLB, 3594 OldExpansionTL.getPatternLoc()); 3595 if (Result.isNull()) 3596 return 0; 3597 3598 Result = RebuildPackExpansionType(Result, 3599 OldExpansionTL.getPatternLoc().getSourceRange(), 3600 OldExpansionTL.getEllipsisLoc(), 3601 NumExpansions); 3602 if (Result.isNull()) 3603 return 0; 3604 3605 PackExpansionTypeLoc NewExpansionTL 3606 = TLB.push<PackExpansionTypeLoc>(Result); 3607 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc()); 3608 NewDI = TLB.getTypeSourceInfo(SemaRef.Context, Result); 3609 } else 3610 NewDI = getDerived().TransformType(OldDI); 3611 if (!NewDI) 3612 return 0; 3613 3614 if (NewDI == OldDI) 3615 return OldParm; 3616 else 3617 return ParmVarDecl::Create(SemaRef.Context, 3618 OldParm->getDeclContext(), 3619 OldParm->getLocation(), 3620 OldParm->getIdentifier(), 3621 NewDI->getType(), 3622 NewDI, 3623 OldParm->getStorageClass(), 3624 OldParm->getStorageClassAsWritten(), 3625 /* DefArg */ NULL); 3626} 3627 3628template<typename Derived> 3629bool TreeTransform<Derived>:: 3630 TransformFunctionTypeParams(SourceLocation Loc, 3631 ParmVarDecl **Params, unsigned NumParams, 3632 const QualType *ParamTypes, 3633 llvm::SmallVectorImpl<QualType> &OutParamTypes, 3634 llvm::SmallVectorImpl<ParmVarDecl*> *PVars) { 3635 for (unsigned i = 0; i != NumParams; ++i) { 3636 if (ParmVarDecl *OldParm = Params[i]) { 3637 llvm::Optional<unsigned> NumExpansions; 3638 ParmVarDecl *NewParm = 0; 3639 if (OldParm->isParameterPack()) { 3640 // We have a function parameter pack that may need to be expanded. 3641 llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3642 3643 // Find the parameter packs that could be expanded. 3644 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc(); 3645 PackExpansionTypeLoc ExpansionTL = cast<PackExpansionTypeLoc>(TL); 3646 TypeLoc Pattern = ExpansionTL.getPatternLoc(); 3647 SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded); 3648 assert(Unexpanded.size() > 0 && "Could not find parameter packs!"); 3649 3650 // Determine whether we should expand the parameter packs. 3651 bool ShouldExpand = false; 3652 bool RetainExpansion = false; 3653 llvm::Optional<unsigned> OrigNumExpansions 3654 = ExpansionTL.getTypePtr()->getNumExpansions(); 3655 NumExpansions = OrigNumExpansions; 3656 if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), 3657 Pattern.getSourceRange(), 3658 Unexpanded.data(), 3659 Unexpanded.size(), 3660 ShouldExpand, 3661 RetainExpansion, 3662 NumExpansions)) { 3663 return true; 3664 } 3665 3666 if (ShouldExpand) { 3667 // Expand the function parameter pack into multiple, separate 3668 // parameters. 3669 getDerived().ExpandingFunctionParameterPack(OldParm); 3670 for (unsigned I = 0; I != *NumExpansions; ++I) { 3671 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3672 ParmVarDecl *NewParm 3673 = getDerived().TransformFunctionTypeParam(OldParm, 3674 OrigNumExpansions); 3675 if (!NewParm) 3676 return true; 3677 3678 OutParamTypes.push_back(NewParm->getType()); 3679 if (PVars) 3680 PVars->push_back(NewParm); 3681 } 3682 3683 // If we're supposed to retain a pack expansion, do so by temporarily 3684 // forgetting the partially-substituted parameter pack. 3685 if (RetainExpansion) { 3686 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3687 ParmVarDecl *NewParm 3688 = getDerived().TransformFunctionTypeParam(OldParm, 3689 OrigNumExpansions); 3690 if (!NewParm) 3691 return true; 3692 3693 OutParamTypes.push_back(NewParm->getType()); 3694 if (PVars) 3695 PVars->push_back(NewParm); 3696 } 3697 3698 // We're done with the pack expansion. 3699 continue; 3700 } 3701 3702 // We'll substitute the parameter now without expanding the pack 3703 // expansion. 3704 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3705 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 3706 NumExpansions); 3707 } else { 3708 NewParm = getDerived().TransformFunctionTypeParam(OldParm, 3709 llvm::Optional<unsigned>()); 3710 } 3711 3712 if (!NewParm) 3713 return true; 3714 3715 OutParamTypes.push_back(NewParm->getType()); 3716 if (PVars) 3717 PVars->push_back(NewParm); 3718 continue; 3719 } 3720 3721 // Deal with the possibility that we don't have a parameter 3722 // declaration for this parameter. 3723 QualType OldType = ParamTypes[i]; 3724 bool IsPackExpansion = false; 3725 llvm::Optional<unsigned> NumExpansions; 3726 QualType NewType; 3727 if (const PackExpansionType *Expansion 3728 = dyn_cast<PackExpansionType>(OldType)) { 3729 // We have a function parameter pack that may need to be expanded. 3730 QualType Pattern = Expansion->getPattern(); 3731 llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 3732 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 3733 3734 // Determine whether we should expand the parameter packs. 3735 bool ShouldExpand = false; 3736 bool RetainExpansion = false; 3737 if (getDerived().TryExpandParameterPacks(Loc, SourceRange(), 3738 Unexpanded.data(), 3739 Unexpanded.size(), 3740 ShouldExpand, 3741 RetainExpansion, 3742 NumExpansions)) { 3743 return true; 3744 } 3745 3746 if (ShouldExpand) { 3747 // Expand the function parameter pack into multiple, separate 3748 // parameters. 3749 for (unsigned I = 0; I != *NumExpansions; ++I) { 3750 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 3751 QualType NewType = getDerived().TransformType(Pattern); 3752 if (NewType.isNull()) 3753 return true; 3754 3755 OutParamTypes.push_back(NewType); 3756 if (PVars) 3757 PVars->push_back(0); 3758 } 3759 3760 // We're done with the pack expansion. 3761 continue; 3762 } 3763 3764 // If we're supposed to retain a pack expansion, do so by temporarily 3765 // forgetting the partially-substituted parameter pack. 3766 if (RetainExpansion) { 3767 ForgetPartiallySubstitutedPackRAII Forget(getDerived()); 3768 QualType NewType = getDerived().TransformType(Pattern); 3769 if (NewType.isNull()) 3770 return true; 3771 3772 OutParamTypes.push_back(NewType); 3773 if (PVars) 3774 PVars->push_back(0); 3775 } 3776 3777 // We'll substitute the parameter now without expanding the pack 3778 // expansion. 3779 OldType = Expansion->getPattern(); 3780 IsPackExpansion = true; 3781 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 3782 NewType = getDerived().TransformType(OldType); 3783 } else { 3784 NewType = getDerived().TransformType(OldType); 3785 } 3786 3787 if (NewType.isNull()) 3788 return true; 3789 3790 if (IsPackExpansion) 3791 NewType = getSema().Context.getPackExpansionType(NewType, 3792 NumExpansions); 3793 3794 OutParamTypes.push_back(NewType); 3795 if (PVars) 3796 PVars->push_back(0); 3797 } 3798 3799 return false; 3800 } 3801 3802template<typename Derived> 3803QualType 3804TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 3805 FunctionProtoTypeLoc TL) { 3806 // Transform the parameters and return type. 3807 // 3808 // We instantiate in source order, with the return type first followed by 3809 // the parameters, because users tend to expect this (even if they shouldn't 3810 // rely on it!). 3811 // 3812 // When the function has a trailing return type, we instantiate the 3813 // parameters before the return type, since the return type can then refer 3814 // to the parameters themselves (via decltype, sizeof, etc.). 3815 // 3816 llvm::SmallVector<QualType, 4> ParamTypes; 3817 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 3818 const FunctionProtoType *T = TL.getTypePtr(); 3819 3820 QualType ResultType; 3821 3822 if (TL.getTrailingReturn()) { 3823 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 3824 TL.getParmArray(), 3825 TL.getNumArgs(), 3826 TL.getTypePtr()->arg_type_begin(), 3827 ParamTypes, &ParamDecls)) 3828 return QualType(); 3829 3830 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3831 if (ResultType.isNull()) 3832 return QualType(); 3833 } 3834 else { 3835 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3836 if (ResultType.isNull()) 3837 return QualType(); 3838 3839 if (getDerived().TransformFunctionTypeParams(TL.getBeginLoc(), 3840 TL.getParmArray(), 3841 TL.getNumArgs(), 3842 TL.getTypePtr()->arg_type_begin(), 3843 ParamTypes, &ParamDecls)) 3844 return QualType(); 3845 } 3846 3847 QualType Result = TL.getType(); 3848 if (getDerived().AlwaysRebuild() || 3849 ResultType != T->getResultType() || 3850 T->getNumArgs() != ParamTypes.size() || 3851 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 3852 Result = getDerived().RebuildFunctionProtoType(ResultType, 3853 ParamTypes.data(), 3854 ParamTypes.size(), 3855 T->isVariadic(), 3856 T->getTypeQuals(), 3857 T->getRefQualifier(), 3858 T->getExtInfo()); 3859 if (Result.isNull()) 3860 return QualType(); 3861 } 3862 3863 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 3864 NewTL.setLParenLoc(TL.getLParenLoc()); 3865 NewTL.setRParenLoc(TL.getRParenLoc()); 3866 NewTL.setTrailingReturn(TL.getTrailingReturn()); 3867 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 3868 NewTL.setArg(i, ParamDecls[i]); 3869 3870 return Result; 3871} 3872 3873template<typename Derived> 3874QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 3875 TypeLocBuilder &TLB, 3876 FunctionNoProtoTypeLoc TL) { 3877 const FunctionNoProtoType *T = TL.getTypePtr(); 3878 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3879 if (ResultType.isNull()) 3880 return QualType(); 3881 3882 QualType Result = TL.getType(); 3883 if (getDerived().AlwaysRebuild() || 3884 ResultType != T->getResultType()) 3885 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 3886 3887 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 3888 NewTL.setLParenLoc(TL.getLParenLoc()); 3889 NewTL.setRParenLoc(TL.getRParenLoc()); 3890 NewTL.setTrailingReturn(false); 3891 3892 return Result; 3893} 3894 3895template<typename Derived> QualType 3896TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 3897 UnresolvedUsingTypeLoc TL) { 3898 const UnresolvedUsingType *T = TL.getTypePtr(); 3899 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 3900 if (!D) 3901 return QualType(); 3902 3903 QualType Result = TL.getType(); 3904 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 3905 Result = getDerived().RebuildUnresolvedUsingType(D); 3906 if (Result.isNull()) 3907 return QualType(); 3908 } 3909 3910 // We might get an arbitrary type spec type back. We should at 3911 // least always get a type spec type, though. 3912 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 3913 NewTL.setNameLoc(TL.getNameLoc()); 3914 3915 return Result; 3916} 3917 3918template<typename Derived> 3919QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 3920 TypedefTypeLoc TL) { 3921 const TypedefType *T = TL.getTypePtr(); 3922 TypedefDecl *Typedef 3923 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3924 T->getDecl())); 3925 if (!Typedef) 3926 return QualType(); 3927 3928 QualType Result = TL.getType(); 3929 if (getDerived().AlwaysRebuild() || 3930 Typedef != T->getDecl()) { 3931 Result = getDerived().RebuildTypedefType(Typedef); 3932 if (Result.isNull()) 3933 return QualType(); 3934 } 3935 3936 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 3937 NewTL.setNameLoc(TL.getNameLoc()); 3938 3939 return Result; 3940} 3941 3942template<typename Derived> 3943QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 3944 TypeOfExprTypeLoc TL) { 3945 // typeof expressions are not potentially evaluated contexts 3946 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3947 3948 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 3949 if (E.isInvalid()) 3950 return QualType(); 3951 3952 QualType Result = TL.getType(); 3953 if (getDerived().AlwaysRebuild() || 3954 E.get() != TL.getUnderlyingExpr()) { 3955 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 3956 if (Result.isNull()) 3957 return QualType(); 3958 } 3959 else E.take(); 3960 3961 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 3962 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3963 NewTL.setLParenLoc(TL.getLParenLoc()); 3964 NewTL.setRParenLoc(TL.getRParenLoc()); 3965 3966 return Result; 3967} 3968 3969template<typename Derived> 3970QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 3971 TypeOfTypeLoc TL) { 3972 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 3973 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 3974 if (!New_Under_TI) 3975 return QualType(); 3976 3977 QualType Result = TL.getType(); 3978 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 3979 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 3980 if (Result.isNull()) 3981 return QualType(); 3982 } 3983 3984 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 3985 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3986 NewTL.setLParenLoc(TL.getLParenLoc()); 3987 NewTL.setRParenLoc(TL.getRParenLoc()); 3988 NewTL.setUnderlyingTInfo(New_Under_TI); 3989 3990 return Result; 3991} 3992 3993template<typename Derived> 3994QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 3995 DecltypeTypeLoc TL) { 3996 const DecltypeType *T = TL.getTypePtr(); 3997 3998 // decltype expressions are not potentially evaluated contexts 3999 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4000 4001 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 4002 if (E.isInvalid()) 4003 return QualType(); 4004 4005 QualType Result = TL.getType(); 4006 if (getDerived().AlwaysRebuild() || 4007 E.get() != T->getUnderlyingExpr()) { 4008 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 4009 if (Result.isNull()) 4010 return QualType(); 4011 } 4012 else E.take(); 4013 4014 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 4015 NewTL.setNameLoc(TL.getNameLoc()); 4016 4017 return Result; 4018} 4019 4020template<typename Derived> 4021QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB, 4022 AutoTypeLoc TL) { 4023 const AutoType *T = TL.getTypePtr(); 4024 QualType OldDeduced = T->getDeducedType(); 4025 QualType NewDeduced; 4026 if (!OldDeduced.isNull()) { 4027 NewDeduced = getDerived().TransformType(OldDeduced); 4028 if (NewDeduced.isNull()) 4029 return QualType(); 4030 } 4031 4032 QualType Result = TL.getType(); 4033 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced) { 4034 Result = getDerived().RebuildAutoType(NewDeduced); 4035 if (Result.isNull()) 4036 return QualType(); 4037 } 4038 4039 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result); 4040 NewTL.setNameLoc(TL.getNameLoc()); 4041 4042 return Result; 4043} 4044 4045template<typename Derived> 4046QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 4047 RecordTypeLoc TL) { 4048 const RecordType *T = TL.getTypePtr(); 4049 RecordDecl *Record 4050 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4051 T->getDecl())); 4052 if (!Record) 4053 return QualType(); 4054 4055 QualType Result = TL.getType(); 4056 if (getDerived().AlwaysRebuild() || 4057 Record != T->getDecl()) { 4058 Result = getDerived().RebuildRecordType(Record); 4059 if (Result.isNull()) 4060 return QualType(); 4061 } 4062 4063 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 4064 NewTL.setNameLoc(TL.getNameLoc()); 4065 4066 return Result; 4067} 4068 4069template<typename Derived> 4070QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 4071 EnumTypeLoc TL) { 4072 const EnumType *T = TL.getTypePtr(); 4073 EnumDecl *Enum 4074 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 4075 T->getDecl())); 4076 if (!Enum) 4077 return QualType(); 4078 4079 QualType Result = TL.getType(); 4080 if (getDerived().AlwaysRebuild() || 4081 Enum != T->getDecl()) { 4082 Result = getDerived().RebuildEnumType(Enum); 4083 if (Result.isNull()) 4084 return QualType(); 4085 } 4086 4087 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 4088 NewTL.setNameLoc(TL.getNameLoc()); 4089 4090 return Result; 4091} 4092 4093template<typename Derived> 4094QualType TreeTransform<Derived>::TransformInjectedClassNameType( 4095 TypeLocBuilder &TLB, 4096 InjectedClassNameTypeLoc TL) { 4097 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 4098 TL.getTypePtr()->getDecl()); 4099 if (!D) return QualType(); 4100 4101 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 4102 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 4103 return T; 4104} 4105 4106template<typename Derived> 4107QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 4108 TypeLocBuilder &TLB, 4109 TemplateTypeParmTypeLoc TL) { 4110 return TransformTypeSpecType(TLB, TL); 4111} 4112 4113template<typename Derived> 4114QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 4115 TypeLocBuilder &TLB, 4116 SubstTemplateTypeParmTypeLoc TL) { 4117 return TransformTypeSpecType(TLB, TL); 4118} 4119 4120template<typename Derived> 4121QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType( 4122 TypeLocBuilder &TLB, 4123 SubstTemplateTypeParmPackTypeLoc TL) { 4124 return TransformTypeSpecType(TLB, TL); 4125} 4126 4127template<typename Derived> 4128QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4129 TypeLocBuilder &TLB, 4130 TemplateSpecializationTypeLoc TL) { 4131 const TemplateSpecializationType *T = TL.getTypePtr(); 4132 4133 // The nested-name-specifier never matters in a TemplateSpecializationType, 4134 // because we can't have a dependent nested-name-specifier anyway. 4135 CXXScopeSpec SS; 4136 TemplateName Template 4137 = getDerived().TransformTemplateName(SS, T->getTemplateName(), 4138 TL.getTemplateNameLoc()); 4139 if (Template.isNull()) 4140 return QualType(); 4141 4142 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 4143} 4144 4145namespace { 4146 /// \brief Simple iterator that traverses the template arguments in a 4147 /// container that provides a \c getArgLoc() member function. 4148 /// 4149 /// This iterator is intended to be used with the iterator form of 4150 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 4151 template<typename ArgLocContainer> 4152 class TemplateArgumentLocContainerIterator { 4153 ArgLocContainer *Container; 4154 unsigned Index; 4155 4156 public: 4157 typedef TemplateArgumentLoc value_type; 4158 typedef TemplateArgumentLoc reference; 4159 typedef int difference_type; 4160 typedef std::input_iterator_tag iterator_category; 4161 4162 class pointer { 4163 TemplateArgumentLoc Arg; 4164 4165 public: 4166 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 4167 4168 const TemplateArgumentLoc *operator->() const { 4169 return &Arg; 4170 } 4171 }; 4172 4173 4174 TemplateArgumentLocContainerIterator() {} 4175 4176 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 4177 unsigned Index) 4178 : Container(&Container), Index(Index) { } 4179 4180 TemplateArgumentLocContainerIterator &operator++() { 4181 ++Index; 4182 return *this; 4183 } 4184 4185 TemplateArgumentLocContainerIterator operator++(int) { 4186 TemplateArgumentLocContainerIterator Old(*this); 4187 ++(*this); 4188 return Old; 4189 } 4190 4191 TemplateArgumentLoc operator*() const { 4192 return Container->getArgLoc(Index); 4193 } 4194 4195 pointer operator->() const { 4196 return pointer(Container->getArgLoc(Index)); 4197 } 4198 4199 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 4200 const TemplateArgumentLocContainerIterator &Y) { 4201 return X.Container == Y.Container && X.Index == Y.Index; 4202 } 4203 4204 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 4205 const TemplateArgumentLocContainerIterator &Y) { 4206 return !(X == Y); 4207 } 4208 }; 4209} 4210 4211 4212template <typename Derived> 4213QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 4214 TypeLocBuilder &TLB, 4215 TemplateSpecializationTypeLoc TL, 4216 TemplateName Template) { 4217 TemplateArgumentListInfo NewTemplateArgs; 4218 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4219 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4220 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 4221 ArgIterator; 4222 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4223 ArgIterator(TL, TL.getNumArgs()), 4224 NewTemplateArgs)) 4225 return QualType(); 4226 4227 // FIXME: maybe don't rebuild if all the template arguments are the same. 4228 4229 QualType Result = 4230 getDerived().RebuildTemplateSpecializationType(Template, 4231 TL.getTemplateNameLoc(), 4232 NewTemplateArgs); 4233 4234 if (!Result.isNull()) { 4235 TemplateSpecializationTypeLoc NewTL 4236 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4237 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 4238 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4239 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4240 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4241 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4242 } 4243 4244 return Result; 4245} 4246 4247template <typename Derived> 4248QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType( 4249 TypeLocBuilder &TLB, 4250 DependentTemplateSpecializationTypeLoc TL, 4251 TemplateName Template, 4252 CXXScopeSpec &SS) { 4253 TemplateArgumentListInfo NewTemplateArgs; 4254 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4255 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4256 typedef TemplateArgumentLocContainerIterator< 4257 DependentTemplateSpecializationTypeLoc> ArgIterator; 4258 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4259 ArgIterator(TL, TL.getNumArgs()), 4260 NewTemplateArgs)) 4261 return QualType(); 4262 4263 // FIXME: maybe don't rebuild if all the template arguments are the same. 4264 4265 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) { 4266 QualType Result 4267 = getSema().Context.getDependentTemplateSpecializationType( 4268 TL.getTypePtr()->getKeyword(), 4269 DTN->getQualifier(), 4270 DTN->getIdentifier(), 4271 NewTemplateArgs); 4272 4273 DependentTemplateSpecializationTypeLoc NewTL 4274 = TLB.push<DependentTemplateSpecializationTypeLoc>(Result); 4275 NewTL.setKeywordLoc(TL.getKeywordLoc()); 4276 4277 NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context)); 4278 NewTL.setNameLoc(TL.getNameLoc()); 4279 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4280 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4281 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4282 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4283 return Result; 4284 } 4285 4286 QualType Result 4287 = getDerived().RebuildTemplateSpecializationType(Template, 4288 TL.getNameLoc(), 4289 NewTemplateArgs); 4290 4291 if (!Result.isNull()) { 4292 /// FIXME: Wrap this in an elaborated-type-specifier? 4293 TemplateSpecializationTypeLoc NewTL 4294 = TLB.push<TemplateSpecializationTypeLoc>(Result); 4295 NewTL.setTemplateNameLoc(TL.getNameLoc()); 4296 NewTL.setLAngleLoc(TL.getLAngleLoc()); 4297 NewTL.setRAngleLoc(TL.getRAngleLoc()); 4298 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 4299 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 4300 } 4301 4302 return Result; 4303} 4304 4305template<typename Derived> 4306QualType 4307TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 4308 ElaboratedTypeLoc TL) { 4309 const ElaboratedType *T = TL.getTypePtr(); 4310 4311 NestedNameSpecifierLoc QualifierLoc; 4312 // NOTE: the qualifier in an ElaboratedType is optional. 4313 if (TL.getQualifierLoc()) { 4314 QualifierLoc 4315 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4316 if (!QualifierLoc) 4317 return QualType(); 4318 } 4319 4320 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 4321 if (NamedT.isNull()) 4322 return QualType(); 4323 4324 QualType Result = TL.getType(); 4325 if (getDerived().AlwaysRebuild() || 4326 QualifierLoc != TL.getQualifierLoc() || 4327 NamedT != T->getNamedType()) { 4328 Result = getDerived().RebuildElaboratedType(TL.getKeywordLoc(), 4329 T->getKeyword(), 4330 QualifierLoc, NamedT); 4331 if (Result.isNull()) 4332 return QualType(); 4333 } 4334 4335 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4336 NewTL.setKeywordLoc(TL.getKeywordLoc()); 4337 NewTL.setQualifierLoc(QualifierLoc); 4338 return Result; 4339} 4340 4341template<typename Derived> 4342QualType TreeTransform<Derived>::TransformAttributedType( 4343 TypeLocBuilder &TLB, 4344 AttributedTypeLoc TL) { 4345 const AttributedType *oldType = TL.getTypePtr(); 4346 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc()); 4347 if (modifiedType.isNull()) 4348 return QualType(); 4349 4350 QualType result = TL.getType(); 4351 4352 // FIXME: dependent operand expressions? 4353 if (getDerived().AlwaysRebuild() || 4354 modifiedType != oldType->getModifiedType()) { 4355 // TODO: this is really lame; we should really be rebuilding the 4356 // equivalent type from first principles. 4357 QualType equivalentType 4358 = getDerived().TransformType(oldType->getEquivalentType()); 4359 if (equivalentType.isNull()) 4360 return QualType(); 4361 result = SemaRef.Context.getAttributedType(oldType->getAttrKind(), 4362 modifiedType, 4363 equivalentType); 4364 } 4365 4366 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(result); 4367 newTL.setAttrNameLoc(TL.getAttrNameLoc()); 4368 if (TL.hasAttrOperand()) 4369 newTL.setAttrOperandParensRange(TL.getAttrOperandParensRange()); 4370 if (TL.hasAttrExprOperand()) 4371 newTL.setAttrExprOperand(TL.getAttrExprOperand()); 4372 else if (TL.hasAttrEnumOperand()) 4373 newTL.setAttrEnumOperandLoc(TL.getAttrEnumOperandLoc()); 4374 4375 return result; 4376} 4377 4378template<typename Derived> 4379QualType 4380TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 4381 ParenTypeLoc TL) { 4382 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 4383 if (Inner.isNull()) 4384 return QualType(); 4385 4386 QualType Result = TL.getType(); 4387 if (getDerived().AlwaysRebuild() || 4388 Inner != TL.getInnerLoc().getType()) { 4389 Result = getDerived().RebuildParenType(Inner); 4390 if (Result.isNull()) 4391 return QualType(); 4392 } 4393 4394 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 4395 NewTL.setLParenLoc(TL.getLParenLoc()); 4396 NewTL.setRParenLoc(TL.getRParenLoc()); 4397 return Result; 4398} 4399 4400template<typename Derived> 4401QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 4402 DependentNameTypeLoc TL) { 4403 const DependentNameType *T = TL.getTypePtr(); 4404 4405 NestedNameSpecifierLoc QualifierLoc 4406 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4407 if (!QualifierLoc) 4408 return QualType(); 4409 4410 QualType Result 4411 = getDerived().RebuildDependentNameType(T->getKeyword(), 4412 TL.getKeywordLoc(), 4413 QualifierLoc, 4414 T->getIdentifier(), 4415 TL.getNameLoc()); 4416 if (Result.isNull()) 4417 return QualType(); 4418 4419 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 4420 QualType NamedT = ElabT->getNamedType(); 4421 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 4422 4423 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4424 NewTL.setKeywordLoc(TL.getKeywordLoc()); 4425 NewTL.setQualifierLoc(QualifierLoc); 4426 } else { 4427 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 4428 NewTL.setKeywordLoc(TL.getKeywordLoc()); 4429 NewTL.setQualifierLoc(QualifierLoc); 4430 NewTL.setNameLoc(TL.getNameLoc()); 4431 } 4432 return Result; 4433} 4434 4435template<typename Derived> 4436QualType TreeTransform<Derived>:: 4437 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 4438 DependentTemplateSpecializationTypeLoc TL) { 4439 NestedNameSpecifierLoc QualifierLoc; 4440 if (TL.getQualifierLoc()) { 4441 QualifierLoc 4442 = getDerived().TransformNestedNameSpecifierLoc(TL.getQualifierLoc()); 4443 if (!QualifierLoc) 4444 return QualType(); 4445 } 4446 4447 return getDerived() 4448 .TransformDependentTemplateSpecializationType(TLB, TL, QualifierLoc); 4449} 4450 4451template<typename Derived> 4452QualType TreeTransform<Derived>:: 4453TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 4454 DependentTemplateSpecializationTypeLoc TL, 4455 NestedNameSpecifierLoc QualifierLoc) { 4456 const DependentTemplateSpecializationType *T = TL.getTypePtr(); 4457 4458 TemplateArgumentListInfo NewTemplateArgs; 4459 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 4460 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 4461 4462 typedef TemplateArgumentLocContainerIterator< 4463 DependentTemplateSpecializationTypeLoc> ArgIterator; 4464 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 4465 ArgIterator(TL, TL.getNumArgs()), 4466 NewTemplateArgs)) 4467 return QualType(); 4468 4469 QualType Result 4470 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 4471 QualifierLoc, 4472 T->getIdentifier(), 4473 TL.getNameLoc(), 4474 NewTemplateArgs); 4475 if (Result.isNull()) 4476 return QualType(); 4477 4478 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 4479 QualType NamedT = ElabT->getNamedType(); 4480 4481 // Copy information relevant to the template specialization. 4482 TemplateSpecializationTypeLoc NamedTL 4483 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 4484 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 4485 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 4486 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 4487 NamedTL.setArgLocInfo(I, TL.getArgLocInfo(I)); 4488 4489 // Copy information relevant to the elaborated type. 4490 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 4491 NewTL.setKeywordLoc(TL.getKeywordLoc()); 4492 NewTL.setQualifierLoc(QualifierLoc); 4493 } else { 4494 TypeLoc NewTL(Result, TL.getOpaqueData()); 4495 TLB.pushFullCopy(NewTL); 4496 } 4497 return Result; 4498} 4499 4500template<typename Derived> 4501QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 4502 PackExpansionTypeLoc TL) { 4503 QualType Pattern 4504 = getDerived().TransformType(TLB, TL.getPatternLoc()); 4505 if (Pattern.isNull()) 4506 return QualType(); 4507 4508 QualType Result = TL.getType(); 4509 if (getDerived().AlwaysRebuild() || 4510 Pattern != TL.getPatternLoc().getType()) { 4511 Result = getDerived().RebuildPackExpansionType(Pattern, 4512 TL.getPatternLoc().getSourceRange(), 4513 TL.getEllipsisLoc(), 4514 TL.getTypePtr()->getNumExpansions()); 4515 if (Result.isNull()) 4516 return QualType(); 4517 } 4518 4519 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(Result); 4520 NewT.setEllipsisLoc(TL.getEllipsisLoc()); 4521 return Result; 4522} 4523 4524template<typename Derived> 4525QualType 4526TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 4527 ObjCInterfaceTypeLoc TL) { 4528 // ObjCInterfaceType is never dependent. 4529 TLB.pushFullCopy(TL); 4530 return TL.getType(); 4531} 4532 4533template<typename Derived> 4534QualType 4535TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 4536 ObjCObjectTypeLoc TL) { 4537 // ObjCObjectType is never dependent. 4538 TLB.pushFullCopy(TL); 4539 return TL.getType(); 4540} 4541 4542template<typename Derived> 4543QualType 4544TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 4545 ObjCObjectPointerTypeLoc TL) { 4546 // ObjCObjectPointerType is never dependent. 4547 TLB.pushFullCopy(TL); 4548 return TL.getType(); 4549} 4550 4551//===----------------------------------------------------------------------===// 4552// Statement transformation 4553//===----------------------------------------------------------------------===// 4554template<typename Derived> 4555StmtResult 4556TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 4557 return SemaRef.Owned(S); 4558} 4559 4560template<typename Derived> 4561StmtResult 4562TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 4563 return getDerived().TransformCompoundStmt(S, false); 4564} 4565 4566template<typename Derived> 4567StmtResult 4568TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 4569 bool IsStmtExpr) { 4570 bool SubStmtInvalid = false; 4571 bool SubStmtChanged = false; 4572 ASTOwningVector<Stmt*> Statements(getSema()); 4573 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 4574 B != BEnd; ++B) { 4575 StmtResult Result = getDerived().TransformStmt(*B); 4576 if (Result.isInvalid()) { 4577 // Immediately fail if this was a DeclStmt, since it's very 4578 // likely that this will cause problems for future statements. 4579 if (isa<DeclStmt>(*B)) 4580 return StmtError(); 4581 4582 // Otherwise, just keep processing substatements and fail later. 4583 SubStmtInvalid = true; 4584 continue; 4585 } 4586 4587 SubStmtChanged = SubStmtChanged || Result.get() != *B; 4588 Statements.push_back(Result.takeAs<Stmt>()); 4589 } 4590 4591 if (SubStmtInvalid) 4592 return StmtError(); 4593 4594 if (!getDerived().AlwaysRebuild() && 4595 !SubStmtChanged) 4596 return SemaRef.Owned(S); 4597 4598 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 4599 move_arg(Statements), 4600 S->getRBracLoc(), 4601 IsStmtExpr); 4602} 4603 4604template<typename Derived> 4605StmtResult 4606TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 4607 ExprResult LHS, RHS; 4608 { 4609 // The case value expressions are not potentially evaluated. 4610 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4611 4612 // Transform the left-hand case value. 4613 LHS = getDerived().TransformExpr(S->getLHS()); 4614 if (LHS.isInvalid()) 4615 return StmtError(); 4616 4617 // Transform the right-hand case value (for the GNU case-range extension). 4618 RHS = getDerived().TransformExpr(S->getRHS()); 4619 if (RHS.isInvalid()) 4620 return StmtError(); 4621 } 4622 4623 // Build the case statement. 4624 // Case statements are always rebuilt so that they will attached to their 4625 // transformed switch statement. 4626 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 4627 LHS.get(), 4628 S->getEllipsisLoc(), 4629 RHS.get(), 4630 S->getColonLoc()); 4631 if (Case.isInvalid()) 4632 return StmtError(); 4633 4634 // Transform the statement following the case 4635 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4636 if (SubStmt.isInvalid()) 4637 return StmtError(); 4638 4639 // Attach the body to the case statement 4640 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 4641} 4642 4643template<typename Derived> 4644StmtResult 4645TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 4646 // Transform the statement following the default case 4647 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4648 if (SubStmt.isInvalid()) 4649 return StmtError(); 4650 4651 // Default statements are always rebuilt 4652 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 4653 SubStmt.get()); 4654} 4655 4656template<typename Derived> 4657StmtResult 4658TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 4659 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4660 if (SubStmt.isInvalid()) 4661 return StmtError(); 4662 4663 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(), 4664 S->getDecl()); 4665 if (!LD) 4666 return StmtError(); 4667 4668 4669 // FIXME: Pass the real colon location in. 4670 return getDerived().RebuildLabelStmt(S->getIdentLoc(), 4671 cast<LabelDecl>(LD), SourceLocation(), 4672 SubStmt.get()); 4673} 4674 4675template<typename Derived> 4676StmtResult 4677TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 4678 // Transform the condition 4679 ExprResult Cond; 4680 VarDecl *ConditionVar = 0; 4681 if (S->getConditionVariable()) { 4682 ConditionVar 4683 = cast_or_null<VarDecl>( 4684 getDerived().TransformDefinition( 4685 S->getConditionVariable()->getLocation(), 4686 S->getConditionVariable())); 4687 if (!ConditionVar) 4688 return StmtError(); 4689 } else { 4690 Cond = getDerived().TransformExpr(S->getCond()); 4691 4692 if (Cond.isInvalid()) 4693 return StmtError(); 4694 4695 // Convert the condition to a boolean value. 4696 if (S->getCond()) { 4697 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), 4698 Cond.get()); 4699 if (CondE.isInvalid()) 4700 return StmtError(); 4701 4702 Cond = CondE.get(); 4703 } 4704 } 4705 4706 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4707 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4708 return StmtError(); 4709 4710 // Transform the "then" branch. 4711 StmtResult Then = getDerived().TransformStmt(S->getThen()); 4712 if (Then.isInvalid()) 4713 return StmtError(); 4714 4715 // Transform the "else" branch. 4716 StmtResult Else = getDerived().TransformStmt(S->getElse()); 4717 if (Else.isInvalid()) 4718 return StmtError(); 4719 4720 if (!getDerived().AlwaysRebuild() && 4721 FullCond.get() == S->getCond() && 4722 ConditionVar == S->getConditionVariable() && 4723 Then.get() == S->getThen() && 4724 Else.get() == S->getElse()) 4725 return SemaRef.Owned(S); 4726 4727 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 4728 Then.get(), 4729 S->getElseLoc(), Else.get()); 4730} 4731 4732template<typename Derived> 4733StmtResult 4734TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 4735 // Transform the condition. 4736 ExprResult Cond; 4737 VarDecl *ConditionVar = 0; 4738 if (S->getConditionVariable()) { 4739 ConditionVar 4740 = cast_or_null<VarDecl>( 4741 getDerived().TransformDefinition( 4742 S->getConditionVariable()->getLocation(), 4743 S->getConditionVariable())); 4744 if (!ConditionVar) 4745 return StmtError(); 4746 } else { 4747 Cond = getDerived().TransformExpr(S->getCond()); 4748 4749 if (Cond.isInvalid()) 4750 return StmtError(); 4751 } 4752 4753 // Rebuild the switch statement. 4754 StmtResult Switch 4755 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 4756 ConditionVar); 4757 if (Switch.isInvalid()) 4758 return StmtError(); 4759 4760 // Transform the body of the switch statement. 4761 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4762 if (Body.isInvalid()) 4763 return StmtError(); 4764 4765 // Complete the switch statement. 4766 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 4767 Body.get()); 4768} 4769 4770template<typename Derived> 4771StmtResult 4772TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 4773 // Transform the condition 4774 ExprResult Cond; 4775 VarDecl *ConditionVar = 0; 4776 if (S->getConditionVariable()) { 4777 ConditionVar 4778 = cast_or_null<VarDecl>( 4779 getDerived().TransformDefinition( 4780 S->getConditionVariable()->getLocation(), 4781 S->getConditionVariable())); 4782 if (!ConditionVar) 4783 return StmtError(); 4784 } else { 4785 Cond = getDerived().TransformExpr(S->getCond()); 4786 4787 if (Cond.isInvalid()) 4788 return StmtError(); 4789 4790 if (S->getCond()) { 4791 // Convert the condition to a boolean value. 4792 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), 4793 Cond.get()); 4794 if (CondE.isInvalid()) 4795 return StmtError(); 4796 Cond = CondE; 4797 } 4798 } 4799 4800 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4801 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4802 return StmtError(); 4803 4804 // Transform the body 4805 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4806 if (Body.isInvalid()) 4807 return StmtError(); 4808 4809 if (!getDerived().AlwaysRebuild() && 4810 FullCond.get() == S->getCond() && 4811 ConditionVar == S->getConditionVariable() && 4812 Body.get() == S->getBody()) 4813 return Owned(S); 4814 4815 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 4816 ConditionVar, Body.get()); 4817} 4818 4819template<typename Derived> 4820StmtResult 4821TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 4822 // Transform the body 4823 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4824 if (Body.isInvalid()) 4825 return StmtError(); 4826 4827 // Transform the condition 4828 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 4829 if (Cond.isInvalid()) 4830 return StmtError(); 4831 4832 if (!getDerived().AlwaysRebuild() && 4833 Cond.get() == S->getCond() && 4834 Body.get() == S->getBody()) 4835 return SemaRef.Owned(S); 4836 4837 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 4838 /*FIXME:*/S->getWhileLoc(), Cond.get(), 4839 S->getRParenLoc()); 4840} 4841 4842template<typename Derived> 4843StmtResult 4844TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 4845 // Transform the initialization statement 4846 StmtResult Init = getDerived().TransformStmt(S->getInit()); 4847 if (Init.isInvalid()) 4848 return StmtError(); 4849 4850 // Transform the condition 4851 ExprResult Cond; 4852 VarDecl *ConditionVar = 0; 4853 if (S->getConditionVariable()) { 4854 ConditionVar 4855 = cast_or_null<VarDecl>( 4856 getDerived().TransformDefinition( 4857 S->getConditionVariable()->getLocation(), 4858 S->getConditionVariable())); 4859 if (!ConditionVar) 4860 return StmtError(); 4861 } else { 4862 Cond = getDerived().TransformExpr(S->getCond()); 4863 4864 if (Cond.isInvalid()) 4865 return StmtError(); 4866 4867 if (S->getCond()) { 4868 // Convert the condition to a boolean value. 4869 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), 4870 Cond.get()); 4871 if (CondE.isInvalid()) 4872 return StmtError(); 4873 4874 Cond = CondE.get(); 4875 } 4876 } 4877 4878 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4879 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4880 return StmtError(); 4881 4882 // Transform the increment 4883 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 4884 if (Inc.isInvalid()) 4885 return StmtError(); 4886 4887 Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc.get())); 4888 if (S->getInc() && !FullInc.get()) 4889 return StmtError(); 4890 4891 // Transform the body 4892 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4893 if (Body.isInvalid()) 4894 return StmtError(); 4895 4896 if (!getDerived().AlwaysRebuild() && 4897 Init.get() == S->getInit() && 4898 FullCond.get() == S->getCond() && 4899 Inc.get() == S->getInc() && 4900 Body.get() == S->getBody()) 4901 return SemaRef.Owned(S); 4902 4903 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 4904 Init.get(), FullCond, ConditionVar, 4905 FullInc, S->getRParenLoc(), Body.get()); 4906} 4907 4908template<typename Derived> 4909StmtResult 4910TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 4911 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(), 4912 S->getLabel()); 4913 if (!LD) 4914 return StmtError(); 4915 4916 // Goto statements must always be rebuilt, to resolve the label. 4917 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 4918 cast<LabelDecl>(LD)); 4919} 4920 4921template<typename Derived> 4922StmtResult 4923TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 4924 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 4925 if (Target.isInvalid()) 4926 return StmtError(); 4927 4928 if (!getDerived().AlwaysRebuild() && 4929 Target.get() == S->getTarget()) 4930 return SemaRef.Owned(S); 4931 4932 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 4933 Target.get()); 4934} 4935 4936template<typename Derived> 4937StmtResult 4938TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 4939 return SemaRef.Owned(S); 4940} 4941 4942template<typename Derived> 4943StmtResult 4944TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 4945 return SemaRef.Owned(S); 4946} 4947 4948template<typename Derived> 4949StmtResult 4950TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 4951 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 4952 if (Result.isInvalid()) 4953 return StmtError(); 4954 4955 // FIXME: We always rebuild the return statement because there is no way 4956 // to tell whether the return type of the function has changed. 4957 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 4958} 4959 4960template<typename Derived> 4961StmtResult 4962TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 4963 bool DeclChanged = false; 4964 llvm::SmallVector<Decl *, 4> Decls; 4965 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 4966 D != DEnd; ++D) { 4967 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 4968 *D); 4969 if (!Transformed) 4970 return StmtError(); 4971 4972 if (Transformed != *D) 4973 DeclChanged = true; 4974 4975 Decls.push_back(Transformed); 4976 } 4977 4978 if (!getDerived().AlwaysRebuild() && !DeclChanged) 4979 return SemaRef.Owned(S); 4980 4981 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 4982 S->getStartLoc(), S->getEndLoc()); 4983} 4984 4985template<typename Derived> 4986StmtResult 4987TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 4988 4989 ASTOwningVector<Expr*> Constraints(getSema()); 4990 ASTOwningVector<Expr*> Exprs(getSema()); 4991 llvm::SmallVector<IdentifierInfo *, 4> Names; 4992 4993 ExprResult AsmString; 4994 ASTOwningVector<Expr*> Clobbers(getSema()); 4995 4996 bool ExprsChanged = false; 4997 4998 // Go through the outputs. 4999 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 5000 Names.push_back(S->getOutputIdentifier(I)); 5001 5002 // No need to transform the constraint literal. 5003 Constraints.push_back(S->getOutputConstraintLiteral(I)); 5004 5005 // Transform the output expr. 5006 Expr *OutputExpr = S->getOutputExpr(I); 5007 ExprResult Result = getDerived().TransformExpr(OutputExpr); 5008 if (Result.isInvalid()) 5009 return StmtError(); 5010 5011 ExprsChanged |= Result.get() != OutputExpr; 5012 5013 Exprs.push_back(Result.get()); 5014 } 5015 5016 // Go through the inputs. 5017 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 5018 Names.push_back(S->getInputIdentifier(I)); 5019 5020 // No need to transform the constraint literal. 5021 Constraints.push_back(S->getInputConstraintLiteral(I)); 5022 5023 // Transform the input expr. 5024 Expr *InputExpr = S->getInputExpr(I); 5025 ExprResult Result = getDerived().TransformExpr(InputExpr); 5026 if (Result.isInvalid()) 5027 return StmtError(); 5028 5029 ExprsChanged |= Result.get() != InputExpr; 5030 5031 Exprs.push_back(Result.get()); 5032 } 5033 5034 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 5035 return SemaRef.Owned(S); 5036 5037 // Go through the clobbers. 5038 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 5039 Clobbers.push_back(S->getClobber(I)); 5040 5041 // No need to transform the asm string literal. 5042 AsmString = SemaRef.Owned(S->getAsmString()); 5043 5044 return getDerived().RebuildAsmStmt(S->getAsmLoc(), 5045 S->isSimple(), 5046 S->isVolatile(), 5047 S->getNumOutputs(), 5048 S->getNumInputs(), 5049 Names.data(), 5050 move_arg(Constraints), 5051 move_arg(Exprs), 5052 AsmString.get(), 5053 move_arg(Clobbers), 5054 S->getRParenLoc(), 5055 S->isMSAsm()); 5056} 5057 5058 5059template<typename Derived> 5060StmtResult 5061TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 5062 // Transform the body of the @try. 5063 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 5064 if (TryBody.isInvalid()) 5065 return StmtError(); 5066 5067 // Transform the @catch statements (if present). 5068 bool AnyCatchChanged = false; 5069 ASTOwningVector<Stmt*> CatchStmts(SemaRef); 5070 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 5071 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 5072 if (Catch.isInvalid()) 5073 return StmtError(); 5074 if (Catch.get() != S->getCatchStmt(I)) 5075 AnyCatchChanged = true; 5076 CatchStmts.push_back(Catch.release()); 5077 } 5078 5079 // Transform the @finally statement (if present). 5080 StmtResult Finally; 5081 if (S->getFinallyStmt()) { 5082 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 5083 if (Finally.isInvalid()) 5084 return StmtError(); 5085 } 5086 5087 // If nothing changed, just retain this statement. 5088 if (!getDerived().AlwaysRebuild() && 5089 TryBody.get() == S->getTryBody() && 5090 !AnyCatchChanged && 5091 Finally.get() == S->getFinallyStmt()) 5092 return SemaRef.Owned(S); 5093 5094 // Build a new statement. 5095 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 5096 move_arg(CatchStmts), Finally.get()); 5097} 5098 5099template<typename Derived> 5100StmtResult 5101TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 5102 // Transform the @catch parameter, if there is one. 5103 VarDecl *Var = 0; 5104 if (VarDecl *FromVar = S->getCatchParamDecl()) { 5105 TypeSourceInfo *TSInfo = 0; 5106 if (FromVar->getTypeSourceInfo()) { 5107 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 5108 if (!TSInfo) 5109 return StmtError(); 5110 } 5111 5112 QualType T; 5113 if (TSInfo) 5114 T = TSInfo->getType(); 5115 else { 5116 T = getDerived().TransformType(FromVar->getType()); 5117 if (T.isNull()) 5118 return StmtError(); 5119 } 5120 5121 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 5122 if (!Var) 5123 return StmtError(); 5124 } 5125 5126 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 5127 if (Body.isInvalid()) 5128 return StmtError(); 5129 5130 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 5131 S->getRParenLoc(), 5132 Var, Body.get()); 5133} 5134 5135template<typename Derived> 5136StmtResult 5137TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 5138 // Transform the body. 5139 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 5140 if (Body.isInvalid()) 5141 return StmtError(); 5142 5143 // If nothing changed, just retain this statement. 5144 if (!getDerived().AlwaysRebuild() && 5145 Body.get() == S->getFinallyBody()) 5146 return SemaRef.Owned(S); 5147 5148 // Build a new statement. 5149 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 5150 Body.get()); 5151} 5152 5153template<typename Derived> 5154StmtResult 5155TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5156 ExprResult Operand; 5157 if (S->getThrowExpr()) { 5158 Operand = getDerived().TransformExpr(S->getThrowExpr()); 5159 if (Operand.isInvalid()) 5160 return StmtError(); 5161 } 5162 5163 if (!getDerived().AlwaysRebuild() && 5164 Operand.get() == S->getThrowExpr()) 5165 return getSema().Owned(S); 5166 5167 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 5168} 5169 5170template<typename Derived> 5171StmtResult 5172TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 5173 ObjCAtSynchronizedStmt *S) { 5174 // Transform the object we are locking. 5175 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 5176 if (Object.isInvalid()) 5177 return StmtError(); 5178 5179 // Transform the body. 5180 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 5181 if (Body.isInvalid()) 5182 return StmtError(); 5183 5184 // If nothing change, just retain the current statement. 5185 if (!getDerived().AlwaysRebuild() && 5186 Object.get() == S->getSynchExpr() && 5187 Body.get() == S->getSynchBody()) 5188 return SemaRef.Owned(S); 5189 5190 // Build a new statement. 5191 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 5192 Object.get(), Body.get()); 5193} 5194 5195template<typename Derived> 5196StmtResult 5197TreeTransform<Derived>::TransformObjCForCollectionStmt( 5198 ObjCForCollectionStmt *S) { 5199 // Transform the element statement. 5200 StmtResult Element = getDerived().TransformStmt(S->getElement()); 5201 if (Element.isInvalid()) 5202 return StmtError(); 5203 5204 // Transform the collection expression. 5205 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 5206 if (Collection.isInvalid()) 5207 return StmtError(); 5208 5209 // Transform the body. 5210 StmtResult Body = getDerived().TransformStmt(S->getBody()); 5211 if (Body.isInvalid()) 5212 return StmtError(); 5213 5214 // If nothing changed, just retain this statement. 5215 if (!getDerived().AlwaysRebuild() && 5216 Element.get() == S->getElement() && 5217 Collection.get() == S->getCollection() && 5218 Body.get() == S->getBody()) 5219 return SemaRef.Owned(S); 5220 5221 // Build a new statement. 5222 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 5223 /*FIXME:*/S->getForLoc(), 5224 Element.get(), 5225 Collection.get(), 5226 S->getRParenLoc(), 5227 Body.get()); 5228} 5229 5230 5231template<typename Derived> 5232StmtResult 5233TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 5234 // Transform the exception declaration, if any. 5235 VarDecl *Var = 0; 5236 if (S->getExceptionDecl()) { 5237 VarDecl *ExceptionDecl = S->getExceptionDecl(); 5238 TypeSourceInfo *T = getDerived().TransformType( 5239 ExceptionDecl->getTypeSourceInfo()); 5240 if (!T) 5241 return StmtError(); 5242 5243 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, 5244 ExceptionDecl->getIdentifier(), 5245 ExceptionDecl->getLocation()); 5246 if (!Var || Var->isInvalidDecl()) 5247 return StmtError(); 5248 } 5249 5250 // Transform the actual exception handler. 5251 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 5252 if (Handler.isInvalid()) 5253 return StmtError(); 5254 5255 if (!getDerived().AlwaysRebuild() && 5256 !Var && 5257 Handler.get() == S->getHandlerBlock()) 5258 return SemaRef.Owned(S); 5259 5260 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 5261 Var, 5262 Handler.get()); 5263} 5264 5265template<typename Derived> 5266StmtResult 5267TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 5268 // Transform the try block itself. 5269 StmtResult TryBlock 5270 = getDerived().TransformCompoundStmt(S->getTryBlock()); 5271 if (TryBlock.isInvalid()) 5272 return StmtError(); 5273 5274 // Transform the handlers. 5275 bool HandlerChanged = false; 5276 ASTOwningVector<Stmt*> Handlers(SemaRef); 5277 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 5278 StmtResult Handler 5279 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 5280 if (Handler.isInvalid()) 5281 return StmtError(); 5282 5283 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 5284 Handlers.push_back(Handler.takeAs<Stmt>()); 5285 } 5286 5287 if (!getDerived().AlwaysRebuild() && 5288 TryBlock.get() == S->getTryBlock() && 5289 !HandlerChanged) 5290 return SemaRef.Owned(S); 5291 5292 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 5293 move_arg(Handlers)); 5294} 5295 5296//===----------------------------------------------------------------------===// 5297// Expression transformation 5298//===----------------------------------------------------------------------===// 5299template<typename Derived> 5300ExprResult 5301TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 5302 return SemaRef.Owned(E); 5303} 5304 5305template<typename Derived> 5306ExprResult 5307TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 5308 NestedNameSpecifierLoc QualifierLoc; 5309 if (E->getQualifierLoc()) { 5310 QualifierLoc 5311 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 5312 if (!QualifierLoc) 5313 return ExprError(); 5314 } 5315 5316 ValueDecl *ND 5317 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 5318 E->getDecl())); 5319 if (!ND) 5320 return ExprError(); 5321 5322 DeclarationNameInfo NameInfo = E->getNameInfo(); 5323 if (NameInfo.getName()) { 5324 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 5325 if (!NameInfo.getName()) 5326 return ExprError(); 5327 } 5328 5329 if (!getDerived().AlwaysRebuild() && 5330 QualifierLoc == E->getQualifierLoc() && 5331 ND == E->getDecl() && 5332 NameInfo.getName() == E->getDecl()->getDeclName() && 5333 !E->hasExplicitTemplateArgs()) { 5334 5335 // Mark it referenced in the new context regardless. 5336 // FIXME: this is a bit instantiation-specific. 5337 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 5338 5339 return SemaRef.Owned(E); 5340 } 5341 5342 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 5343 if (E->hasExplicitTemplateArgs()) { 5344 TemplateArgs = &TransArgs; 5345 TransArgs.setLAngleLoc(E->getLAngleLoc()); 5346 TransArgs.setRAngleLoc(E->getRAngleLoc()); 5347 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 5348 E->getNumTemplateArgs(), 5349 TransArgs)) 5350 return ExprError(); 5351 } 5352 5353 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo, 5354 TemplateArgs); 5355} 5356 5357template<typename Derived> 5358ExprResult 5359TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 5360 return SemaRef.Owned(E); 5361} 5362 5363template<typename Derived> 5364ExprResult 5365TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 5366 return SemaRef.Owned(E); 5367} 5368 5369template<typename Derived> 5370ExprResult 5371TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 5372 return SemaRef.Owned(E); 5373} 5374 5375template<typename Derived> 5376ExprResult 5377TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 5378 return SemaRef.Owned(E); 5379} 5380 5381template<typename Derived> 5382ExprResult 5383TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 5384 return SemaRef.Owned(E); 5385} 5386 5387template<typename Derived> 5388ExprResult 5389TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 5390 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5391 if (SubExpr.isInvalid()) 5392 return ExprError(); 5393 5394 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 5395 return SemaRef.Owned(E); 5396 5397 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 5398 E->getRParen()); 5399} 5400 5401template<typename Derived> 5402ExprResult 5403TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 5404 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5405 if (SubExpr.isInvalid()) 5406 return ExprError(); 5407 5408 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 5409 return SemaRef.Owned(E); 5410 5411 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 5412 E->getOpcode(), 5413 SubExpr.get()); 5414} 5415 5416template<typename Derived> 5417ExprResult 5418TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 5419 // Transform the type. 5420 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 5421 if (!Type) 5422 return ExprError(); 5423 5424 // Transform all of the components into components similar to what the 5425 // parser uses. 5426 // FIXME: It would be slightly more efficient in the non-dependent case to 5427 // just map FieldDecls, rather than requiring the rebuilder to look for 5428 // the fields again. However, __builtin_offsetof is rare enough in 5429 // template code that we don't care. 5430 bool ExprChanged = false; 5431 typedef Sema::OffsetOfComponent Component; 5432 typedef OffsetOfExpr::OffsetOfNode Node; 5433 llvm::SmallVector<Component, 4> Components; 5434 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 5435 const Node &ON = E->getComponent(I); 5436 Component Comp; 5437 Comp.isBrackets = true; 5438 Comp.LocStart = ON.getRange().getBegin(); 5439 Comp.LocEnd = ON.getRange().getEnd(); 5440 switch (ON.getKind()) { 5441 case Node::Array: { 5442 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 5443 ExprResult Index = getDerived().TransformExpr(FromIndex); 5444 if (Index.isInvalid()) 5445 return ExprError(); 5446 5447 ExprChanged = ExprChanged || Index.get() != FromIndex; 5448 Comp.isBrackets = true; 5449 Comp.U.E = Index.get(); 5450 break; 5451 } 5452 5453 case Node::Field: 5454 case Node::Identifier: 5455 Comp.isBrackets = false; 5456 Comp.U.IdentInfo = ON.getFieldName(); 5457 if (!Comp.U.IdentInfo) 5458 continue; 5459 5460 break; 5461 5462 case Node::Base: 5463 // Will be recomputed during the rebuild. 5464 continue; 5465 } 5466 5467 Components.push_back(Comp); 5468 } 5469 5470 // If nothing changed, retain the existing expression. 5471 if (!getDerived().AlwaysRebuild() && 5472 Type == E->getTypeSourceInfo() && 5473 !ExprChanged) 5474 return SemaRef.Owned(E); 5475 5476 // Build a new offsetof expression. 5477 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 5478 Components.data(), Components.size(), 5479 E->getRParenLoc()); 5480} 5481 5482template<typename Derived> 5483ExprResult 5484TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 5485 assert(getDerived().AlreadyTransformed(E->getType()) && 5486 "opaque value expression requires transformation"); 5487 return SemaRef.Owned(E); 5488} 5489 5490template<typename Derived> 5491ExprResult 5492TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 5493 if (E->isArgumentType()) { 5494 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 5495 5496 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 5497 if (!NewT) 5498 return ExprError(); 5499 5500 if (!getDerived().AlwaysRebuild() && OldT == NewT) 5501 return SemaRef.Owned(E); 5502 5503 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 5504 E->isSizeOf(), 5505 E->getSourceRange()); 5506 } 5507 5508 ExprResult SubExpr; 5509 { 5510 // C++0x [expr.sizeof]p1: 5511 // The operand is either an expression, which is an unevaluated operand 5512 // [...] 5513 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 5514 5515 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 5516 if (SubExpr.isInvalid()) 5517 return ExprError(); 5518 5519 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 5520 return SemaRef.Owned(E); 5521 } 5522 5523 return getDerived().RebuildSizeOfAlignOf(SubExpr.get(), E->getOperatorLoc(), 5524 E->isSizeOf(), 5525 E->getSourceRange()); 5526} 5527 5528template<typename Derived> 5529ExprResult 5530TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 5531 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5532 if (LHS.isInvalid()) 5533 return ExprError(); 5534 5535 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5536 if (RHS.isInvalid()) 5537 return ExprError(); 5538 5539 5540 if (!getDerived().AlwaysRebuild() && 5541 LHS.get() == E->getLHS() && 5542 RHS.get() == E->getRHS()) 5543 return SemaRef.Owned(E); 5544 5545 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 5546 /*FIXME:*/E->getLHS()->getLocStart(), 5547 RHS.get(), 5548 E->getRBracketLoc()); 5549} 5550 5551template<typename Derived> 5552ExprResult 5553TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 5554 // Transform the callee. 5555 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 5556 if (Callee.isInvalid()) 5557 return ExprError(); 5558 5559 // Transform arguments. 5560 bool ArgChanged = false; 5561 ASTOwningVector<Expr*> Args(SemaRef); 5562 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 5563 &ArgChanged)) 5564 return ExprError(); 5565 5566 if (!getDerived().AlwaysRebuild() && 5567 Callee.get() == E->getCallee() && 5568 !ArgChanged) 5569 return SemaRef.Owned(E); 5570 5571 // FIXME: Wrong source location information for the '('. 5572 SourceLocation FakeLParenLoc 5573 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 5574 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 5575 move_arg(Args), 5576 E->getRParenLoc()); 5577} 5578 5579template<typename Derived> 5580ExprResult 5581TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 5582 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5583 if (Base.isInvalid()) 5584 return ExprError(); 5585 5586 NestedNameSpecifierLoc QualifierLoc; 5587 if (E->hasQualifier()) { 5588 QualifierLoc 5589 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 5590 5591 if (!QualifierLoc) 5592 return ExprError(); 5593 } 5594 5595 ValueDecl *Member 5596 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 5597 E->getMemberDecl())); 5598 if (!Member) 5599 return ExprError(); 5600 5601 NamedDecl *FoundDecl = E->getFoundDecl(); 5602 if (FoundDecl == E->getMemberDecl()) { 5603 FoundDecl = Member; 5604 } else { 5605 FoundDecl = cast_or_null<NamedDecl>( 5606 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 5607 if (!FoundDecl) 5608 return ExprError(); 5609 } 5610 5611 if (!getDerived().AlwaysRebuild() && 5612 Base.get() == E->getBase() && 5613 QualifierLoc == E->getQualifierLoc() && 5614 Member == E->getMemberDecl() && 5615 FoundDecl == E->getFoundDecl() && 5616 !E->hasExplicitTemplateArgs()) { 5617 5618 // Mark it referenced in the new context regardless. 5619 // FIXME: this is a bit instantiation-specific. 5620 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member); 5621 return SemaRef.Owned(E); 5622 } 5623 5624 TemplateArgumentListInfo TransArgs; 5625 if (E->hasExplicitTemplateArgs()) { 5626 TransArgs.setLAngleLoc(E->getLAngleLoc()); 5627 TransArgs.setRAngleLoc(E->getRAngleLoc()); 5628 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 5629 E->getNumTemplateArgs(), 5630 TransArgs)) 5631 return ExprError(); 5632 } 5633 5634 // FIXME: Bogus source location for the operator 5635 SourceLocation FakeOperatorLoc 5636 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 5637 5638 // FIXME: to do this check properly, we will need to preserve the 5639 // first-qualifier-in-scope here, just in case we had a dependent 5640 // base (and therefore couldn't do the check) and a 5641 // nested-name-qualifier (and therefore could do the lookup). 5642 NamedDecl *FirstQualifierInScope = 0; 5643 5644 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 5645 E->isArrow(), 5646 QualifierLoc, 5647 E->getMemberNameInfo(), 5648 Member, 5649 FoundDecl, 5650 (E->hasExplicitTemplateArgs() 5651 ? &TransArgs : 0), 5652 FirstQualifierInScope); 5653} 5654 5655template<typename Derived> 5656ExprResult 5657TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 5658 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5659 if (LHS.isInvalid()) 5660 return ExprError(); 5661 5662 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5663 if (RHS.isInvalid()) 5664 return ExprError(); 5665 5666 if (!getDerived().AlwaysRebuild() && 5667 LHS.get() == E->getLHS() && 5668 RHS.get() == E->getRHS()) 5669 return SemaRef.Owned(E); 5670 5671 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 5672 LHS.get(), RHS.get()); 5673} 5674 5675template<typename Derived> 5676ExprResult 5677TreeTransform<Derived>::TransformCompoundAssignOperator( 5678 CompoundAssignOperator *E) { 5679 return getDerived().TransformBinaryOperator(E); 5680} 5681 5682template<typename Derived> 5683ExprResult TreeTransform<Derived>:: 5684TransformBinaryConditionalOperator(BinaryConditionalOperator *e) { 5685 // Just rebuild the common and RHS expressions and see whether we 5686 // get any changes. 5687 5688 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon()); 5689 if (commonExpr.isInvalid()) 5690 return ExprError(); 5691 5692 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr()); 5693 if (rhs.isInvalid()) 5694 return ExprError(); 5695 5696 if (!getDerived().AlwaysRebuild() && 5697 commonExpr.get() == e->getCommon() && 5698 rhs.get() == e->getFalseExpr()) 5699 return SemaRef.Owned(e); 5700 5701 return getDerived().RebuildConditionalOperator(commonExpr.take(), 5702 e->getQuestionLoc(), 5703 0, 5704 e->getColonLoc(), 5705 rhs.get()); 5706} 5707 5708template<typename Derived> 5709ExprResult 5710TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 5711 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5712 if (Cond.isInvalid()) 5713 return ExprError(); 5714 5715 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5716 if (LHS.isInvalid()) 5717 return ExprError(); 5718 5719 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5720 if (RHS.isInvalid()) 5721 return ExprError(); 5722 5723 if (!getDerived().AlwaysRebuild() && 5724 Cond.get() == E->getCond() && 5725 LHS.get() == E->getLHS() && 5726 RHS.get() == E->getRHS()) 5727 return SemaRef.Owned(E); 5728 5729 return getDerived().RebuildConditionalOperator(Cond.get(), 5730 E->getQuestionLoc(), 5731 LHS.get(), 5732 E->getColonLoc(), 5733 RHS.get()); 5734} 5735 5736template<typename Derived> 5737ExprResult 5738TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 5739 // Implicit casts are eliminated during transformation, since they 5740 // will be recomputed by semantic analysis after transformation. 5741 return getDerived().TransformExpr(E->getSubExprAsWritten()); 5742} 5743 5744template<typename Derived> 5745ExprResult 5746TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 5747 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5748 if (!Type) 5749 return ExprError(); 5750 5751 ExprResult SubExpr 5752 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5753 if (SubExpr.isInvalid()) 5754 return ExprError(); 5755 5756 if (!getDerived().AlwaysRebuild() && 5757 Type == E->getTypeInfoAsWritten() && 5758 SubExpr.get() == E->getSubExpr()) 5759 return SemaRef.Owned(E); 5760 5761 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 5762 Type, 5763 E->getRParenLoc(), 5764 SubExpr.get()); 5765} 5766 5767template<typename Derived> 5768ExprResult 5769TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 5770 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 5771 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 5772 if (!NewT) 5773 return ExprError(); 5774 5775 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 5776 if (Init.isInvalid()) 5777 return ExprError(); 5778 5779 if (!getDerived().AlwaysRebuild() && 5780 OldT == NewT && 5781 Init.get() == E->getInitializer()) 5782 return SemaRef.Owned(E); 5783 5784 // Note: the expression type doesn't necessarily match the 5785 // type-as-written, but that's okay, because it should always be 5786 // derivable from the initializer. 5787 5788 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 5789 /*FIXME:*/E->getInitializer()->getLocEnd(), 5790 Init.get()); 5791} 5792 5793template<typename Derived> 5794ExprResult 5795TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 5796 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5797 if (Base.isInvalid()) 5798 return ExprError(); 5799 5800 if (!getDerived().AlwaysRebuild() && 5801 Base.get() == E->getBase()) 5802 return SemaRef.Owned(E); 5803 5804 // FIXME: Bad source location 5805 SourceLocation FakeOperatorLoc 5806 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 5807 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 5808 E->getAccessorLoc(), 5809 E->getAccessor()); 5810} 5811 5812template<typename Derived> 5813ExprResult 5814TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 5815 bool InitChanged = false; 5816 5817 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5818 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 5819 Inits, &InitChanged)) 5820 return ExprError(); 5821 5822 if (!getDerived().AlwaysRebuild() && !InitChanged) 5823 return SemaRef.Owned(E); 5824 5825 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 5826 E->getRBraceLoc(), E->getType()); 5827} 5828 5829template<typename Derived> 5830ExprResult 5831TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 5832 Designation Desig; 5833 5834 // transform the initializer value 5835 ExprResult Init = getDerived().TransformExpr(E->getInit()); 5836 if (Init.isInvalid()) 5837 return ExprError(); 5838 5839 // transform the designators. 5840 ASTOwningVector<Expr*, 4> ArrayExprs(SemaRef); 5841 bool ExprChanged = false; 5842 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 5843 DEnd = E->designators_end(); 5844 D != DEnd; ++D) { 5845 if (D->isFieldDesignator()) { 5846 Desig.AddDesignator(Designator::getField(D->getFieldName(), 5847 D->getDotLoc(), 5848 D->getFieldLoc())); 5849 continue; 5850 } 5851 5852 if (D->isArrayDesignator()) { 5853 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 5854 if (Index.isInvalid()) 5855 return ExprError(); 5856 5857 Desig.AddDesignator(Designator::getArray(Index.get(), 5858 D->getLBracketLoc())); 5859 5860 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 5861 ArrayExprs.push_back(Index.release()); 5862 continue; 5863 } 5864 5865 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 5866 ExprResult Start 5867 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 5868 if (Start.isInvalid()) 5869 return ExprError(); 5870 5871 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 5872 if (End.isInvalid()) 5873 return ExprError(); 5874 5875 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 5876 End.get(), 5877 D->getLBracketLoc(), 5878 D->getEllipsisLoc())); 5879 5880 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 5881 End.get() != E->getArrayRangeEnd(*D); 5882 5883 ArrayExprs.push_back(Start.release()); 5884 ArrayExprs.push_back(End.release()); 5885 } 5886 5887 if (!getDerived().AlwaysRebuild() && 5888 Init.get() == E->getInit() && 5889 !ExprChanged) 5890 return SemaRef.Owned(E); 5891 5892 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 5893 E->getEqualOrColonLoc(), 5894 E->usesGNUSyntax(), Init.get()); 5895} 5896 5897template<typename Derived> 5898ExprResult 5899TreeTransform<Derived>::TransformImplicitValueInitExpr( 5900 ImplicitValueInitExpr *E) { 5901 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 5902 5903 // FIXME: Will we ever have proper type location here? Will we actually 5904 // need to transform the type? 5905 QualType T = getDerived().TransformType(E->getType()); 5906 if (T.isNull()) 5907 return ExprError(); 5908 5909 if (!getDerived().AlwaysRebuild() && 5910 T == E->getType()) 5911 return SemaRef.Owned(E); 5912 5913 return getDerived().RebuildImplicitValueInitExpr(T); 5914} 5915 5916template<typename Derived> 5917ExprResult 5918TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 5919 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 5920 if (!TInfo) 5921 return ExprError(); 5922 5923 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5924 if (SubExpr.isInvalid()) 5925 return ExprError(); 5926 5927 if (!getDerived().AlwaysRebuild() && 5928 TInfo == E->getWrittenTypeInfo() && 5929 SubExpr.get() == E->getSubExpr()) 5930 return SemaRef.Owned(E); 5931 5932 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 5933 TInfo, E->getRParenLoc()); 5934} 5935 5936template<typename Derived> 5937ExprResult 5938TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 5939 bool ArgumentChanged = false; 5940 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5941 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 5942 &ArgumentChanged)) 5943 return ExprError(); 5944 5945 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 5946 move_arg(Inits), 5947 E->getRParenLoc()); 5948} 5949 5950/// \brief Transform an address-of-label expression. 5951/// 5952/// By default, the transformation of an address-of-label expression always 5953/// rebuilds the expression, so that the label identifier can be resolved to 5954/// the corresponding label statement by semantic analysis. 5955template<typename Derived> 5956ExprResult 5957TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 5958 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(), 5959 E->getLabel()); 5960 if (!LD) 5961 return ExprError(); 5962 5963 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 5964 cast<LabelDecl>(LD)); 5965} 5966 5967template<typename Derived> 5968ExprResult 5969TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 5970 StmtResult SubStmt 5971 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 5972 if (SubStmt.isInvalid()) 5973 return ExprError(); 5974 5975 if (!getDerived().AlwaysRebuild() && 5976 SubStmt.get() == E->getSubStmt()) 5977 return SemaRef.Owned(E); 5978 5979 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 5980 SubStmt.get(), 5981 E->getRParenLoc()); 5982} 5983 5984template<typename Derived> 5985ExprResult 5986TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 5987 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5988 if (Cond.isInvalid()) 5989 return ExprError(); 5990 5991 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5992 if (LHS.isInvalid()) 5993 return ExprError(); 5994 5995 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5996 if (RHS.isInvalid()) 5997 return ExprError(); 5998 5999 if (!getDerived().AlwaysRebuild() && 6000 Cond.get() == E->getCond() && 6001 LHS.get() == E->getLHS() && 6002 RHS.get() == E->getRHS()) 6003 return SemaRef.Owned(E); 6004 6005 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 6006 Cond.get(), LHS.get(), RHS.get(), 6007 E->getRParenLoc()); 6008} 6009 6010template<typename Derived> 6011ExprResult 6012TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 6013 return SemaRef.Owned(E); 6014} 6015 6016template<typename Derived> 6017ExprResult 6018TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 6019 switch (E->getOperator()) { 6020 case OO_New: 6021 case OO_Delete: 6022 case OO_Array_New: 6023 case OO_Array_Delete: 6024 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 6025 return ExprError(); 6026 6027 case OO_Call: { 6028 // This is a call to an object's operator(). 6029 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 6030 6031 // Transform the object itself. 6032 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 6033 if (Object.isInvalid()) 6034 return ExprError(); 6035 6036 // FIXME: Poor location information 6037 SourceLocation FakeLParenLoc 6038 = SemaRef.PP.getLocForEndOfToken( 6039 static_cast<Expr *>(Object.get())->getLocEnd()); 6040 6041 // Transform the call arguments. 6042 ASTOwningVector<Expr*> Args(SemaRef); 6043 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 6044 Args)) 6045 return ExprError(); 6046 6047 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 6048 move_arg(Args), 6049 E->getLocEnd()); 6050 } 6051 6052#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 6053 case OO_##Name: 6054#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 6055#include "clang/Basic/OperatorKinds.def" 6056 case OO_Subscript: 6057 // Handled below. 6058 break; 6059 6060 case OO_Conditional: 6061 llvm_unreachable("conditional operator is not actually overloadable"); 6062 return ExprError(); 6063 6064 case OO_None: 6065 case NUM_OVERLOADED_OPERATORS: 6066 llvm_unreachable("not an overloaded operator?"); 6067 return ExprError(); 6068 } 6069 6070 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6071 if (Callee.isInvalid()) 6072 return ExprError(); 6073 6074 ExprResult First = getDerived().TransformExpr(E->getArg(0)); 6075 if (First.isInvalid()) 6076 return ExprError(); 6077 6078 ExprResult Second; 6079 if (E->getNumArgs() == 2) { 6080 Second = getDerived().TransformExpr(E->getArg(1)); 6081 if (Second.isInvalid()) 6082 return ExprError(); 6083 } 6084 6085 if (!getDerived().AlwaysRebuild() && 6086 Callee.get() == E->getCallee() && 6087 First.get() == E->getArg(0) && 6088 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 6089 return SemaRef.Owned(E); 6090 6091 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 6092 E->getOperatorLoc(), 6093 Callee.get(), 6094 First.get(), 6095 Second.get()); 6096} 6097 6098template<typename Derived> 6099ExprResult 6100TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 6101 return getDerived().TransformCallExpr(E); 6102} 6103 6104template<typename Derived> 6105ExprResult 6106TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) { 6107 // Transform the callee. 6108 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 6109 if (Callee.isInvalid()) 6110 return ExprError(); 6111 6112 // Transform exec config. 6113 ExprResult EC = getDerived().TransformCallExpr(E->getConfig()); 6114 if (EC.isInvalid()) 6115 return ExprError(); 6116 6117 // Transform arguments. 6118 bool ArgChanged = false; 6119 ASTOwningVector<Expr*> Args(SemaRef); 6120 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6121 &ArgChanged)) 6122 return ExprError(); 6123 6124 if (!getDerived().AlwaysRebuild() && 6125 Callee.get() == E->getCallee() && 6126 !ArgChanged) 6127 return SemaRef.Owned(E); 6128 6129 // FIXME: Wrong source location information for the '('. 6130 SourceLocation FakeLParenLoc 6131 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 6132 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 6133 move_arg(Args), 6134 E->getRParenLoc(), EC.get()); 6135} 6136 6137template<typename Derived> 6138ExprResult 6139TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 6140 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 6141 if (!Type) 6142 return ExprError(); 6143 6144 ExprResult SubExpr 6145 = getDerived().TransformExpr(E->getSubExprAsWritten()); 6146 if (SubExpr.isInvalid()) 6147 return ExprError(); 6148 6149 if (!getDerived().AlwaysRebuild() && 6150 Type == E->getTypeInfoAsWritten() && 6151 SubExpr.get() == E->getSubExpr()) 6152 return SemaRef.Owned(E); 6153 6154 // FIXME: Poor source location information here. 6155 SourceLocation FakeLAngleLoc 6156 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 6157 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 6158 SourceLocation FakeRParenLoc 6159 = SemaRef.PP.getLocForEndOfToken( 6160 E->getSubExpr()->getSourceRange().getEnd()); 6161 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 6162 E->getStmtClass(), 6163 FakeLAngleLoc, 6164 Type, 6165 FakeRAngleLoc, 6166 FakeRAngleLoc, 6167 SubExpr.get(), 6168 FakeRParenLoc); 6169} 6170 6171template<typename Derived> 6172ExprResult 6173TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 6174 return getDerived().TransformCXXNamedCastExpr(E); 6175} 6176 6177template<typename Derived> 6178ExprResult 6179TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 6180 return getDerived().TransformCXXNamedCastExpr(E); 6181} 6182 6183template<typename Derived> 6184ExprResult 6185TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 6186 CXXReinterpretCastExpr *E) { 6187 return getDerived().TransformCXXNamedCastExpr(E); 6188} 6189 6190template<typename Derived> 6191ExprResult 6192TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 6193 return getDerived().TransformCXXNamedCastExpr(E); 6194} 6195 6196template<typename Derived> 6197ExprResult 6198TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 6199 CXXFunctionalCastExpr *E) { 6200 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 6201 if (!Type) 6202 return ExprError(); 6203 6204 ExprResult SubExpr 6205 = getDerived().TransformExpr(E->getSubExprAsWritten()); 6206 if (SubExpr.isInvalid()) 6207 return ExprError(); 6208 6209 if (!getDerived().AlwaysRebuild() && 6210 Type == E->getTypeInfoAsWritten() && 6211 SubExpr.get() == E->getSubExpr()) 6212 return SemaRef.Owned(E); 6213 6214 return getDerived().RebuildCXXFunctionalCastExpr(Type, 6215 /*FIXME:*/E->getSubExpr()->getLocStart(), 6216 SubExpr.get(), 6217 E->getRParenLoc()); 6218} 6219 6220template<typename Derived> 6221ExprResult 6222TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 6223 if (E->isTypeOperand()) { 6224 TypeSourceInfo *TInfo 6225 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 6226 if (!TInfo) 6227 return ExprError(); 6228 6229 if (!getDerived().AlwaysRebuild() && 6230 TInfo == E->getTypeOperandSourceInfo()) 6231 return SemaRef.Owned(E); 6232 6233 return getDerived().RebuildCXXTypeidExpr(E->getType(), 6234 E->getLocStart(), 6235 TInfo, 6236 E->getLocEnd()); 6237 } 6238 6239 // We don't know whether the expression is potentially evaluated until 6240 // after we perform semantic analysis, so the expression is potentially 6241 // potentially evaluated. 6242 EnterExpressionEvaluationContext Unevaluated(SemaRef, 6243 Sema::PotentiallyPotentiallyEvaluated); 6244 6245 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 6246 if (SubExpr.isInvalid()) 6247 return ExprError(); 6248 6249 if (!getDerived().AlwaysRebuild() && 6250 SubExpr.get() == E->getExprOperand()) 6251 return SemaRef.Owned(E); 6252 6253 return getDerived().RebuildCXXTypeidExpr(E->getType(), 6254 E->getLocStart(), 6255 SubExpr.get(), 6256 E->getLocEnd()); 6257} 6258 6259template<typename Derived> 6260ExprResult 6261TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 6262 if (E->isTypeOperand()) { 6263 TypeSourceInfo *TInfo 6264 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 6265 if (!TInfo) 6266 return ExprError(); 6267 6268 if (!getDerived().AlwaysRebuild() && 6269 TInfo == E->getTypeOperandSourceInfo()) 6270 return SemaRef.Owned(E); 6271 6272 return getDerived().RebuildCXXTypeidExpr(E->getType(), 6273 E->getLocStart(), 6274 TInfo, 6275 E->getLocEnd()); 6276 } 6277 6278 // We don't know whether the expression is potentially evaluated until 6279 // after we perform semantic analysis, so the expression is potentially 6280 // potentially evaluated. 6281 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 6282 6283 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 6284 if (SubExpr.isInvalid()) 6285 return ExprError(); 6286 6287 if (!getDerived().AlwaysRebuild() && 6288 SubExpr.get() == E->getExprOperand()) 6289 return SemaRef.Owned(E); 6290 6291 return getDerived().RebuildCXXUuidofExpr(E->getType(), 6292 E->getLocStart(), 6293 SubExpr.get(), 6294 E->getLocEnd()); 6295} 6296 6297template<typename Derived> 6298ExprResult 6299TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 6300 return SemaRef.Owned(E); 6301} 6302 6303template<typename Derived> 6304ExprResult 6305TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 6306 CXXNullPtrLiteralExpr *E) { 6307 return SemaRef.Owned(E); 6308} 6309 6310template<typename Derived> 6311ExprResult 6312TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 6313 DeclContext *DC = getSema().getFunctionLevelDeclContext(); 6314 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC); 6315 QualType T = MD->getThisType(getSema().Context); 6316 6317 if (!getDerived().AlwaysRebuild() && T == E->getType()) 6318 return SemaRef.Owned(E); 6319 6320 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 6321} 6322 6323template<typename Derived> 6324ExprResult 6325TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 6326 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 6327 if (SubExpr.isInvalid()) 6328 return ExprError(); 6329 6330 if (!getDerived().AlwaysRebuild() && 6331 SubExpr.get() == E->getSubExpr()) 6332 return SemaRef.Owned(E); 6333 6334 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get()); 6335} 6336 6337template<typename Derived> 6338ExprResult 6339TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 6340 ParmVarDecl *Param 6341 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 6342 E->getParam())); 6343 if (!Param) 6344 return ExprError(); 6345 6346 if (!getDerived().AlwaysRebuild() && 6347 Param == E->getParam()) 6348 return SemaRef.Owned(E); 6349 6350 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 6351} 6352 6353template<typename Derived> 6354ExprResult 6355TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 6356 CXXScalarValueInitExpr *E) { 6357 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6358 if (!T) 6359 return ExprError(); 6360 6361 if (!getDerived().AlwaysRebuild() && 6362 T == E->getTypeSourceInfo()) 6363 return SemaRef.Owned(E); 6364 6365 return getDerived().RebuildCXXScalarValueInitExpr(T, 6366 /*FIXME:*/T->getTypeLoc().getEndLoc(), 6367 E->getRParenLoc()); 6368} 6369 6370template<typename Derived> 6371ExprResult 6372TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 6373 // Transform the type that we're allocating 6374 TypeSourceInfo *AllocTypeInfo 6375 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 6376 if (!AllocTypeInfo) 6377 return ExprError(); 6378 6379 // Transform the size of the array we're allocating (if any). 6380 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 6381 if (ArraySize.isInvalid()) 6382 return ExprError(); 6383 6384 // Transform the placement arguments (if any). 6385 bool ArgumentChanged = false; 6386 ASTOwningVector<Expr*> PlacementArgs(SemaRef); 6387 if (getDerived().TransformExprs(E->getPlacementArgs(), 6388 E->getNumPlacementArgs(), true, 6389 PlacementArgs, &ArgumentChanged)) 6390 return ExprError(); 6391 6392 // transform the constructor arguments (if any). 6393 ASTOwningVector<Expr*> ConstructorArgs(SemaRef); 6394 if (TransformExprs(E->getConstructorArgs(), E->getNumConstructorArgs(), true, 6395 ConstructorArgs, &ArgumentChanged)) 6396 return ExprError(); 6397 6398 // Transform constructor, new operator, and delete operator. 6399 CXXConstructorDecl *Constructor = 0; 6400 if (E->getConstructor()) { 6401 Constructor = cast_or_null<CXXConstructorDecl>( 6402 getDerived().TransformDecl(E->getLocStart(), 6403 E->getConstructor())); 6404 if (!Constructor) 6405 return ExprError(); 6406 } 6407 6408 FunctionDecl *OperatorNew = 0; 6409 if (E->getOperatorNew()) { 6410 OperatorNew = cast_or_null<FunctionDecl>( 6411 getDerived().TransformDecl(E->getLocStart(), 6412 E->getOperatorNew())); 6413 if (!OperatorNew) 6414 return ExprError(); 6415 } 6416 6417 FunctionDecl *OperatorDelete = 0; 6418 if (E->getOperatorDelete()) { 6419 OperatorDelete = cast_or_null<FunctionDecl>( 6420 getDerived().TransformDecl(E->getLocStart(), 6421 E->getOperatorDelete())); 6422 if (!OperatorDelete) 6423 return ExprError(); 6424 } 6425 6426 if (!getDerived().AlwaysRebuild() && 6427 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 6428 ArraySize.get() == E->getArraySize() && 6429 Constructor == E->getConstructor() && 6430 OperatorNew == E->getOperatorNew() && 6431 OperatorDelete == E->getOperatorDelete() && 6432 !ArgumentChanged) { 6433 // Mark any declarations we need as referenced. 6434 // FIXME: instantiation-specific. 6435 if (Constructor) 6436 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6437 if (OperatorNew) 6438 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew); 6439 if (OperatorDelete) 6440 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 6441 return SemaRef.Owned(E); 6442 } 6443 6444 QualType AllocType = AllocTypeInfo->getType(); 6445 if (!ArraySize.get()) { 6446 // If no array size was specified, but the new expression was 6447 // instantiated with an array type (e.g., "new T" where T is 6448 // instantiated with "int[4]"), extract the outer bound from the 6449 // array type as our array size. We do this with constant and 6450 // dependently-sized array types. 6451 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 6452 if (!ArrayT) { 6453 // Do nothing 6454 } else if (const ConstantArrayType *ConsArrayT 6455 = dyn_cast<ConstantArrayType>(ArrayT)) { 6456 ArraySize 6457 = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, 6458 ConsArrayT->getSize(), 6459 SemaRef.Context.getSizeType(), 6460 /*FIXME:*/E->getLocStart())); 6461 AllocType = ConsArrayT->getElementType(); 6462 } else if (const DependentSizedArrayType *DepArrayT 6463 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 6464 if (DepArrayT->getSizeExpr()) { 6465 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); 6466 AllocType = DepArrayT->getElementType(); 6467 } 6468 } 6469 } 6470 6471 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 6472 E->isGlobalNew(), 6473 /*FIXME:*/E->getLocStart(), 6474 move_arg(PlacementArgs), 6475 /*FIXME:*/E->getLocStart(), 6476 E->getTypeIdParens(), 6477 AllocType, 6478 AllocTypeInfo, 6479 ArraySize.get(), 6480 /*FIXME:*/E->getLocStart(), 6481 move_arg(ConstructorArgs), 6482 E->getLocEnd()); 6483} 6484 6485template<typename Derived> 6486ExprResult 6487TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 6488 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 6489 if (Operand.isInvalid()) 6490 return ExprError(); 6491 6492 // Transform the delete operator, if known. 6493 FunctionDecl *OperatorDelete = 0; 6494 if (E->getOperatorDelete()) { 6495 OperatorDelete = cast_or_null<FunctionDecl>( 6496 getDerived().TransformDecl(E->getLocStart(), 6497 E->getOperatorDelete())); 6498 if (!OperatorDelete) 6499 return ExprError(); 6500 } 6501 6502 if (!getDerived().AlwaysRebuild() && 6503 Operand.get() == E->getArgument() && 6504 OperatorDelete == E->getOperatorDelete()) { 6505 // Mark any declarations we need as referenced. 6506 // FIXME: instantiation-specific. 6507 if (OperatorDelete) 6508 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 6509 6510 if (!E->getArgument()->isTypeDependent()) { 6511 QualType Destroyed = SemaRef.Context.getBaseElementType( 6512 E->getDestroyedType()); 6513 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 6514 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 6515 SemaRef.MarkDeclarationReferenced(E->getLocStart(), 6516 SemaRef.LookupDestructor(Record)); 6517 } 6518 } 6519 6520 return SemaRef.Owned(E); 6521 } 6522 6523 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 6524 E->isGlobalDelete(), 6525 E->isArrayForm(), 6526 Operand.get()); 6527} 6528 6529template<typename Derived> 6530ExprResult 6531TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 6532 CXXPseudoDestructorExpr *E) { 6533 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6534 if (Base.isInvalid()) 6535 return ExprError(); 6536 6537 ParsedType ObjectTypePtr; 6538 bool MayBePseudoDestructor = false; 6539 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 6540 E->getOperatorLoc(), 6541 E->isArrow()? tok::arrow : tok::period, 6542 ObjectTypePtr, 6543 MayBePseudoDestructor); 6544 if (Base.isInvalid()) 6545 return ExprError(); 6546 6547 QualType ObjectType = ObjectTypePtr.get(); 6548 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc(); 6549 if (QualifierLoc) { 6550 QualifierLoc 6551 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType); 6552 if (!QualifierLoc) 6553 return ExprError(); 6554 } 6555 CXXScopeSpec SS; 6556 SS.Adopt(QualifierLoc); 6557 6558 PseudoDestructorTypeStorage Destroyed; 6559 if (E->getDestroyedTypeInfo()) { 6560 TypeSourceInfo *DestroyedTypeInfo 6561 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 6562 ObjectType, 0, SS); 6563 if (!DestroyedTypeInfo) 6564 return ExprError(); 6565 Destroyed = DestroyedTypeInfo; 6566 } else if (ObjectType->isDependentType()) { 6567 // We aren't likely to be able to resolve the identifier down to a type 6568 // now anyway, so just retain the identifier. 6569 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 6570 E->getDestroyedTypeLoc()); 6571 } else { 6572 // Look for a destructor known with the given name. 6573 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 6574 *E->getDestroyedTypeIdentifier(), 6575 E->getDestroyedTypeLoc(), 6576 /*Scope=*/0, 6577 SS, ObjectTypePtr, 6578 false); 6579 if (!T) 6580 return ExprError(); 6581 6582 Destroyed 6583 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 6584 E->getDestroyedTypeLoc()); 6585 } 6586 6587 TypeSourceInfo *ScopeTypeInfo = 0; 6588 if (E->getScopeTypeInfo()) { 6589 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo()); 6590 if (!ScopeTypeInfo) 6591 return ExprError(); 6592 } 6593 6594 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 6595 E->getOperatorLoc(), 6596 E->isArrow(), 6597 SS, 6598 ScopeTypeInfo, 6599 E->getColonColonLoc(), 6600 E->getTildeLoc(), 6601 Destroyed); 6602} 6603 6604template<typename Derived> 6605ExprResult 6606TreeTransform<Derived>::TransformUnresolvedLookupExpr( 6607 UnresolvedLookupExpr *Old) { 6608 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 6609 Sema::LookupOrdinaryName); 6610 6611 // Transform all the decls. 6612 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 6613 E = Old->decls_end(); I != E; ++I) { 6614 NamedDecl *InstD = static_cast<NamedDecl*>( 6615 getDerived().TransformDecl(Old->getNameLoc(), 6616 *I)); 6617 if (!InstD) { 6618 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 6619 // This can happen because of dependent hiding. 6620 if (isa<UsingShadowDecl>(*I)) 6621 continue; 6622 else 6623 return ExprError(); 6624 } 6625 6626 // Expand using declarations. 6627 if (isa<UsingDecl>(InstD)) { 6628 UsingDecl *UD = cast<UsingDecl>(InstD); 6629 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 6630 E = UD->shadow_end(); I != E; ++I) 6631 R.addDecl(*I); 6632 continue; 6633 } 6634 6635 R.addDecl(InstD); 6636 } 6637 6638 // Resolve a kind, but don't do any further analysis. If it's 6639 // ambiguous, the callee needs to deal with it. 6640 R.resolveKind(); 6641 6642 // Rebuild the nested-name qualifier, if present. 6643 CXXScopeSpec SS; 6644 if (Old->getQualifierLoc()) { 6645 NestedNameSpecifierLoc QualifierLoc 6646 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 6647 if (!QualifierLoc) 6648 return ExprError(); 6649 6650 SS.Adopt(QualifierLoc); 6651 } 6652 6653 if (Old->getNamingClass()) { 6654 CXXRecordDecl *NamingClass 6655 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 6656 Old->getNameLoc(), 6657 Old->getNamingClass())); 6658 if (!NamingClass) 6659 return ExprError(); 6660 6661 R.setNamingClass(NamingClass); 6662 } 6663 6664 // If we have no template arguments, it's a normal declaration name. 6665 if (!Old->hasExplicitTemplateArgs()) 6666 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 6667 6668 // If we have template arguments, rebuild them, then rebuild the 6669 // templateid expression. 6670 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 6671 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 6672 Old->getNumTemplateArgs(), 6673 TransArgs)) 6674 return ExprError(); 6675 6676 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(), 6677 TransArgs); 6678} 6679 6680template<typename Derived> 6681ExprResult 6682TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 6683 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 6684 if (!T) 6685 return ExprError(); 6686 6687 if (!getDerived().AlwaysRebuild() && 6688 T == E->getQueriedTypeSourceInfo()) 6689 return SemaRef.Owned(E); 6690 6691 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 6692 E->getLocStart(), 6693 T, 6694 E->getLocEnd()); 6695} 6696 6697template<typename Derived> 6698ExprResult 6699TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 6700 TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); 6701 if (!LhsT) 6702 return ExprError(); 6703 6704 TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); 6705 if (!RhsT) 6706 return ExprError(); 6707 6708 if (!getDerived().AlwaysRebuild() && 6709 LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) 6710 return SemaRef.Owned(E); 6711 6712 return getDerived().RebuildBinaryTypeTrait(E->getTrait(), 6713 E->getLocStart(), 6714 LhsT, RhsT, 6715 E->getLocEnd()); 6716} 6717 6718template<typename Derived> 6719ExprResult 6720TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 6721 DependentScopeDeclRefExpr *E) { 6722 NestedNameSpecifierLoc QualifierLoc 6723 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc()); 6724 if (!QualifierLoc) 6725 return ExprError(); 6726 6727 // TODO: If this is a conversion-function-id, verify that the 6728 // destination type name (if present) resolves the same way after 6729 // instantiation as it did in the local scope. 6730 6731 DeclarationNameInfo NameInfo 6732 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 6733 if (!NameInfo.getName()) 6734 return ExprError(); 6735 6736 if (!E->hasExplicitTemplateArgs()) { 6737 if (!getDerived().AlwaysRebuild() && 6738 QualifierLoc == E->getQualifierLoc() && 6739 // Note: it is sufficient to compare the Name component of NameInfo: 6740 // if name has not changed, DNLoc has not changed either. 6741 NameInfo.getName() == E->getDeclName()) 6742 return SemaRef.Owned(E); 6743 6744 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 6745 NameInfo, 6746 /*TemplateArgs*/ 0); 6747 } 6748 6749 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6750 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6751 E->getNumTemplateArgs(), 6752 TransArgs)) 6753 return ExprError(); 6754 6755 return getDerived().RebuildDependentScopeDeclRefExpr(QualifierLoc, 6756 NameInfo, 6757 &TransArgs); 6758} 6759 6760template<typename Derived> 6761ExprResult 6762TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 6763 // CXXConstructExprs are always implicit, so when we have a 6764 // 1-argument construction we just transform that argument. 6765 if (E->getNumArgs() == 1 || 6766 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) 6767 return getDerived().TransformExpr(E->getArg(0)); 6768 6769 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 6770 6771 QualType T = getDerived().TransformType(E->getType()); 6772 if (T.isNull()) 6773 return ExprError(); 6774 6775 CXXConstructorDecl *Constructor 6776 = cast_or_null<CXXConstructorDecl>( 6777 getDerived().TransformDecl(E->getLocStart(), 6778 E->getConstructor())); 6779 if (!Constructor) 6780 return ExprError(); 6781 6782 bool ArgumentChanged = false; 6783 ASTOwningVector<Expr*> Args(SemaRef); 6784 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6785 &ArgumentChanged)) 6786 return ExprError(); 6787 6788 if (!getDerived().AlwaysRebuild() && 6789 T == E->getType() && 6790 Constructor == E->getConstructor() && 6791 !ArgumentChanged) { 6792 // Mark the constructor as referenced. 6793 // FIXME: Instantiation-specific 6794 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6795 return SemaRef.Owned(E); 6796 } 6797 6798 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 6799 Constructor, E->isElidable(), 6800 move_arg(Args), 6801 E->requiresZeroInitialization(), 6802 E->getConstructionKind(), 6803 E->getParenRange()); 6804} 6805 6806/// \brief Transform a C++ temporary-binding expression. 6807/// 6808/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 6809/// transform the subexpression and return that. 6810template<typename Derived> 6811ExprResult 6812TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 6813 return getDerived().TransformExpr(E->getSubExpr()); 6814} 6815 6816/// \brief Transform a C++ expression that contains cleanups that should 6817/// be run after the expression is evaluated. 6818/// 6819/// Since ExprWithCleanups nodes are implicitly generated, we 6820/// just transform the subexpression and return that. 6821template<typename Derived> 6822ExprResult 6823TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 6824 return getDerived().TransformExpr(E->getSubExpr()); 6825} 6826 6827template<typename Derived> 6828ExprResult 6829TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 6830 CXXTemporaryObjectExpr *E) { 6831 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6832 if (!T) 6833 return ExprError(); 6834 6835 CXXConstructorDecl *Constructor 6836 = cast_or_null<CXXConstructorDecl>( 6837 getDerived().TransformDecl(E->getLocStart(), 6838 E->getConstructor())); 6839 if (!Constructor) 6840 return ExprError(); 6841 6842 bool ArgumentChanged = false; 6843 ASTOwningVector<Expr*> Args(SemaRef); 6844 Args.reserve(E->getNumArgs()); 6845 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6846 &ArgumentChanged)) 6847 return ExprError(); 6848 6849 if (!getDerived().AlwaysRebuild() && 6850 T == E->getTypeSourceInfo() && 6851 Constructor == E->getConstructor() && 6852 !ArgumentChanged) { 6853 // FIXME: Instantiation-specific 6854 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6855 return SemaRef.MaybeBindToTemporary(E); 6856 } 6857 6858 return getDerived().RebuildCXXTemporaryObjectExpr(T, 6859 /*FIXME:*/T->getTypeLoc().getEndLoc(), 6860 move_arg(Args), 6861 E->getLocEnd()); 6862} 6863 6864template<typename Derived> 6865ExprResult 6866TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 6867 CXXUnresolvedConstructExpr *E) { 6868 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6869 if (!T) 6870 return ExprError(); 6871 6872 bool ArgumentChanged = false; 6873 ASTOwningVector<Expr*> Args(SemaRef); 6874 Args.reserve(E->arg_size()); 6875 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 6876 &ArgumentChanged)) 6877 return ExprError(); 6878 6879 if (!getDerived().AlwaysRebuild() && 6880 T == E->getTypeSourceInfo() && 6881 !ArgumentChanged) 6882 return SemaRef.Owned(E); 6883 6884 // FIXME: we're faking the locations of the commas 6885 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 6886 E->getLParenLoc(), 6887 move_arg(Args), 6888 E->getRParenLoc()); 6889} 6890 6891template<typename Derived> 6892ExprResult 6893TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 6894 CXXDependentScopeMemberExpr *E) { 6895 // Transform the base of the expression. 6896 ExprResult Base((Expr*) 0); 6897 Expr *OldBase; 6898 QualType BaseType; 6899 QualType ObjectType; 6900 if (!E->isImplicitAccess()) { 6901 OldBase = E->getBase(); 6902 Base = getDerived().TransformExpr(OldBase); 6903 if (Base.isInvalid()) 6904 return ExprError(); 6905 6906 // Start the member reference and compute the object's type. 6907 ParsedType ObjectTy; 6908 bool MayBePseudoDestructor = false; 6909 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 6910 E->getOperatorLoc(), 6911 E->isArrow()? tok::arrow : tok::period, 6912 ObjectTy, 6913 MayBePseudoDestructor); 6914 if (Base.isInvalid()) 6915 return ExprError(); 6916 6917 ObjectType = ObjectTy.get(); 6918 BaseType = ((Expr*) Base.get())->getType(); 6919 } else { 6920 OldBase = 0; 6921 BaseType = getDerived().TransformType(E->getBaseType()); 6922 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 6923 } 6924 6925 // Transform the first part of the nested-name-specifier that qualifies 6926 // the member name. 6927 NamedDecl *FirstQualifierInScope 6928 = getDerived().TransformFirstQualifierInScope( 6929 E->getFirstQualifierFoundInScope(), 6930 E->getQualifierLoc().getBeginLoc()); 6931 6932 NestedNameSpecifierLoc QualifierLoc; 6933 if (E->getQualifier()) { 6934 QualifierLoc 6935 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 6936 ObjectType, 6937 FirstQualifierInScope); 6938 if (!QualifierLoc) 6939 return ExprError(); 6940 } 6941 6942 // TODO: If this is a conversion-function-id, verify that the 6943 // destination type name (if present) resolves the same way after 6944 // instantiation as it did in the local scope. 6945 6946 DeclarationNameInfo NameInfo 6947 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 6948 if (!NameInfo.getName()) 6949 return ExprError(); 6950 6951 if (!E->hasExplicitTemplateArgs()) { 6952 // This is a reference to a member without an explicitly-specified 6953 // template argument list. Optimize for this common case. 6954 if (!getDerived().AlwaysRebuild() && 6955 Base.get() == OldBase && 6956 BaseType == E->getBaseType() && 6957 QualifierLoc == E->getQualifierLoc() && 6958 NameInfo.getName() == E->getMember() && 6959 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 6960 return SemaRef.Owned(E); 6961 6962 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6963 BaseType, 6964 E->isArrow(), 6965 E->getOperatorLoc(), 6966 QualifierLoc, 6967 FirstQualifierInScope, 6968 NameInfo, 6969 /*TemplateArgs*/ 0); 6970 } 6971 6972 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6973 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6974 E->getNumTemplateArgs(), 6975 TransArgs)) 6976 return ExprError(); 6977 6978 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6979 BaseType, 6980 E->isArrow(), 6981 E->getOperatorLoc(), 6982 QualifierLoc, 6983 FirstQualifierInScope, 6984 NameInfo, 6985 &TransArgs); 6986} 6987 6988template<typename Derived> 6989ExprResult 6990TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 6991 // Transform the base of the expression. 6992 ExprResult Base((Expr*) 0); 6993 QualType BaseType; 6994 if (!Old->isImplicitAccess()) { 6995 Base = getDerived().TransformExpr(Old->getBase()); 6996 if (Base.isInvalid()) 6997 return ExprError(); 6998 BaseType = ((Expr*) Base.get())->getType(); 6999 } else { 7000 BaseType = getDerived().TransformType(Old->getBaseType()); 7001 } 7002 7003 NestedNameSpecifierLoc QualifierLoc; 7004 if (Old->getQualifierLoc()) { 7005 QualifierLoc 7006 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 7007 if (!QualifierLoc) 7008 return ExprError(); 7009 } 7010 7011 LookupResult R(SemaRef, Old->getMemberNameInfo(), 7012 Sema::LookupOrdinaryName); 7013 7014 // Transform all the decls. 7015 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 7016 E = Old->decls_end(); I != E; ++I) { 7017 NamedDecl *InstD = static_cast<NamedDecl*>( 7018 getDerived().TransformDecl(Old->getMemberLoc(), 7019 *I)); 7020 if (!InstD) { 7021 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 7022 // This can happen because of dependent hiding. 7023 if (isa<UsingShadowDecl>(*I)) 7024 continue; 7025 else 7026 return ExprError(); 7027 } 7028 7029 // Expand using declarations. 7030 if (isa<UsingDecl>(InstD)) { 7031 UsingDecl *UD = cast<UsingDecl>(InstD); 7032 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 7033 E = UD->shadow_end(); I != E; ++I) 7034 R.addDecl(*I); 7035 continue; 7036 } 7037 7038 R.addDecl(InstD); 7039 } 7040 7041 R.resolveKind(); 7042 7043 // Determine the naming class. 7044 if (Old->getNamingClass()) { 7045 CXXRecordDecl *NamingClass 7046 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 7047 Old->getMemberLoc(), 7048 Old->getNamingClass())); 7049 if (!NamingClass) 7050 return ExprError(); 7051 7052 R.setNamingClass(NamingClass); 7053 } 7054 7055 TemplateArgumentListInfo TransArgs; 7056 if (Old->hasExplicitTemplateArgs()) { 7057 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 7058 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 7059 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 7060 Old->getNumTemplateArgs(), 7061 TransArgs)) 7062 return ExprError(); 7063 } 7064 7065 // FIXME: to do this check properly, we will need to preserve the 7066 // first-qualifier-in-scope here, just in case we had a dependent 7067 // base (and therefore couldn't do the check) and a 7068 // nested-name-qualifier (and therefore could do the lookup). 7069 NamedDecl *FirstQualifierInScope = 0; 7070 7071 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 7072 BaseType, 7073 Old->getOperatorLoc(), 7074 Old->isArrow(), 7075 QualifierLoc, 7076 FirstQualifierInScope, 7077 R, 7078 (Old->hasExplicitTemplateArgs() 7079 ? &TransArgs : 0)); 7080} 7081 7082template<typename Derived> 7083ExprResult 7084TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 7085 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 7086 if (SubExpr.isInvalid()) 7087 return ExprError(); 7088 7089 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 7090 return SemaRef.Owned(E); 7091 7092 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 7093} 7094 7095template<typename Derived> 7096ExprResult 7097TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 7098 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 7099 if (Pattern.isInvalid()) 7100 return ExprError(); 7101 7102 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 7103 return SemaRef.Owned(E); 7104 7105 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 7106 E->getNumExpansions()); 7107} 7108 7109template<typename Derived> 7110ExprResult 7111TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 7112 // If E is not value-dependent, then nothing will change when we transform it. 7113 // Note: This is an instantiation-centric view. 7114 if (!E->isValueDependent()) 7115 return SemaRef.Owned(E); 7116 7117 // Note: None of the implementations of TryExpandParameterPacks can ever 7118 // produce a diagnostic when given only a single unexpanded parameter pack, 7119 // so 7120 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 7121 bool ShouldExpand = false; 7122 bool RetainExpansion = false; 7123 llvm::Optional<unsigned> NumExpansions; 7124 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 7125 &Unexpanded, 1, 7126 ShouldExpand, RetainExpansion, 7127 NumExpansions)) 7128 return ExprError(); 7129 7130 if (!ShouldExpand || RetainExpansion) 7131 return SemaRef.Owned(E); 7132 7133 // We now know the length of the parameter pack, so build a new expression 7134 // that stores that length. 7135 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), 7136 E->getPackLoc(), E->getRParenLoc(), 7137 *NumExpansions); 7138} 7139 7140template<typename Derived> 7141ExprResult 7142TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 7143 SubstNonTypeTemplateParmPackExpr *E) { 7144 // Default behavior is to do nothing with this transformation. 7145 return SemaRef.Owned(E); 7146} 7147 7148template<typename Derived> 7149ExprResult 7150TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 7151 return SemaRef.Owned(E); 7152} 7153 7154template<typename Derived> 7155ExprResult 7156TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 7157 TypeSourceInfo *EncodedTypeInfo 7158 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 7159 if (!EncodedTypeInfo) 7160 return ExprError(); 7161 7162 if (!getDerived().AlwaysRebuild() && 7163 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 7164 return SemaRef.Owned(E); 7165 7166 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 7167 EncodedTypeInfo, 7168 E->getRParenLoc()); 7169} 7170 7171template<typename Derived> 7172ExprResult 7173TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 7174 // Transform arguments. 7175 bool ArgChanged = false; 7176 ASTOwningVector<Expr*> Args(SemaRef); 7177 Args.reserve(E->getNumArgs()); 7178 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 7179 &ArgChanged)) 7180 return ExprError(); 7181 7182 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 7183 // Class message: transform the receiver type. 7184 TypeSourceInfo *ReceiverTypeInfo 7185 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 7186 if (!ReceiverTypeInfo) 7187 return ExprError(); 7188 7189 // If nothing changed, just retain the existing message send. 7190 if (!getDerived().AlwaysRebuild() && 7191 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 7192 return SemaRef.Owned(E); 7193 7194 // Build a new class message send. 7195 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 7196 E->getSelector(), 7197 E->getSelectorLoc(), 7198 E->getMethodDecl(), 7199 E->getLeftLoc(), 7200 move_arg(Args), 7201 E->getRightLoc()); 7202 } 7203 7204 // Instance message: transform the receiver 7205 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 7206 "Only class and instance messages may be instantiated"); 7207 ExprResult Receiver 7208 = getDerived().TransformExpr(E->getInstanceReceiver()); 7209 if (Receiver.isInvalid()) 7210 return ExprError(); 7211 7212 // If nothing changed, just retain the existing message send. 7213 if (!getDerived().AlwaysRebuild() && 7214 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 7215 return SemaRef.Owned(E); 7216 7217 // Build a new instance message send. 7218 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 7219 E->getSelector(), 7220 E->getSelectorLoc(), 7221 E->getMethodDecl(), 7222 E->getLeftLoc(), 7223 move_arg(Args), 7224 E->getRightLoc()); 7225} 7226 7227template<typename Derived> 7228ExprResult 7229TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 7230 return SemaRef.Owned(E); 7231} 7232 7233template<typename Derived> 7234ExprResult 7235TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 7236 return SemaRef.Owned(E); 7237} 7238 7239template<typename Derived> 7240ExprResult 7241TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 7242 // Transform the base expression. 7243 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7244 if (Base.isInvalid()) 7245 return ExprError(); 7246 7247 // We don't need to transform the ivar; it will never change. 7248 7249 // If nothing changed, just retain the existing expression. 7250 if (!getDerived().AlwaysRebuild() && 7251 Base.get() == E->getBase()) 7252 return SemaRef.Owned(E); 7253 7254 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 7255 E->getLocation(), 7256 E->isArrow(), E->isFreeIvar()); 7257} 7258 7259template<typename Derived> 7260ExprResult 7261TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 7262 // 'super' and types never change. Property never changes. Just 7263 // retain the existing expression. 7264 if (!E->isObjectReceiver()) 7265 return SemaRef.Owned(E); 7266 7267 // Transform the base expression. 7268 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7269 if (Base.isInvalid()) 7270 return ExprError(); 7271 7272 // We don't need to transform the property; it will never change. 7273 7274 // If nothing changed, just retain the existing expression. 7275 if (!getDerived().AlwaysRebuild() && 7276 Base.get() == E->getBase()) 7277 return SemaRef.Owned(E); 7278 7279 if (E->isExplicitProperty()) 7280 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 7281 E->getExplicitProperty(), 7282 E->getLocation()); 7283 7284 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 7285 E->getType(), 7286 E->getImplicitPropertyGetter(), 7287 E->getImplicitPropertySetter(), 7288 E->getLocation()); 7289} 7290 7291template<typename Derived> 7292ExprResult 7293TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 7294 // Transform the base expression. 7295 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7296 if (Base.isInvalid()) 7297 return ExprError(); 7298 7299 // If nothing changed, just retain the existing expression. 7300 if (!getDerived().AlwaysRebuild() && 7301 Base.get() == E->getBase()) 7302 return SemaRef.Owned(E); 7303 7304 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 7305 E->isArrow()); 7306} 7307 7308template<typename Derived> 7309ExprResult 7310TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 7311 bool ArgumentChanged = false; 7312 ASTOwningVector<Expr*> SubExprs(SemaRef); 7313 SubExprs.reserve(E->getNumSubExprs()); 7314 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 7315 SubExprs, &ArgumentChanged)) 7316 return ExprError(); 7317 7318 if (!getDerived().AlwaysRebuild() && 7319 !ArgumentChanged) 7320 return SemaRef.Owned(E); 7321 7322 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 7323 move_arg(SubExprs), 7324 E->getRParenLoc()); 7325} 7326 7327template<typename Derived> 7328ExprResult 7329TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 7330 BlockDecl *oldBlock = E->getBlockDecl(); 7331 7332 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/0); 7333 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 7334 7335 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 7336 llvm::SmallVector<ParmVarDecl*, 4> params; 7337 llvm::SmallVector<QualType, 4> paramTypes; 7338 7339 // Parameter substitution. 7340 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 7341 oldBlock->param_begin(), 7342 oldBlock->param_size(), 7343 0, paramTypes, ¶ms)) 7344 return true; 7345 7346 const FunctionType *exprFunctionType = E->getFunctionType(); 7347 QualType exprResultType = exprFunctionType->getResultType(); 7348 if (!exprResultType.isNull()) { 7349 if (!exprResultType->isDependentType()) 7350 blockScope->ReturnType = exprResultType; 7351 else if (exprResultType != getSema().Context.DependentTy) 7352 blockScope->ReturnType = getDerived().TransformType(exprResultType); 7353 } 7354 7355 // If the return type has not been determined yet, leave it as a dependent 7356 // type; it'll get set when we process the body. 7357 if (blockScope->ReturnType.isNull()) 7358 blockScope->ReturnType = getSema().Context.DependentTy; 7359 7360 // Don't allow returning a objc interface by value. 7361 if (blockScope->ReturnType->isObjCObjectType()) { 7362 getSema().Diag(E->getCaretLocation(), 7363 diag::err_object_cannot_be_passed_returned_by_value) 7364 << 0 << blockScope->ReturnType; 7365 return ExprError(); 7366 } 7367 7368 QualType functionType = getDerived().RebuildFunctionProtoType( 7369 blockScope->ReturnType, 7370 paramTypes.data(), 7371 paramTypes.size(), 7372 oldBlock->isVariadic(), 7373 0, RQ_None, 7374 exprFunctionType->getExtInfo()); 7375 blockScope->FunctionType = functionType; 7376 7377 // Set the parameters on the block decl. 7378 if (!params.empty()) 7379 blockScope->TheDecl->setParams(params.data(), params.size()); 7380 7381 // If the return type wasn't explicitly set, it will have been marked as a 7382 // dependent type (DependentTy); clear out the return type setting so 7383 // we will deduce the return type when type-checking the block's body. 7384 if (blockScope->ReturnType == getSema().Context.DependentTy) 7385 blockScope->ReturnType = QualType(); 7386 7387 // Transform the body 7388 StmtResult body = getDerived().TransformStmt(E->getBody()); 7389 if (body.isInvalid()) 7390 return ExprError(); 7391 7392#ifndef NDEBUG 7393 // In builds with assertions, make sure that we captured everything we 7394 // captured before. 7395 7396 if (oldBlock->capturesCXXThis()) assert(blockScope->CapturesCXXThis); 7397 7398 for (BlockDecl::capture_iterator i = oldBlock->capture_begin(), 7399 e = oldBlock->capture_end(); i != e; ++i) { 7400 VarDecl *oldCapture = i->getVariable(); 7401 7402 // Ignore parameter packs. 7403 if (isa<ParmVarDecl>(oldCapture) && 7404 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 7405 continue; 7406 7407 VarDecl *newCapture = 7408 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 7409 oldCapture)); 7410 assert(blockScope->CaptureMap.count(newCapture)); 7411 } 7412#endif 7413 7414 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 7415 /*Scope=*/0); 7416} 7417 7418template<typename Derived> 7419ExprResult 7420TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 7421 ValueDecl *ND 7422 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 7423 E->getDecl())); 7424 if (!ND) 7425 return ExprError(); 7426 7427 if (!getDerived().AlwaysRebuild() && 7428 ND == E->getDecl()) { 7429 // Mark it referenced in the new context regardless. 7430 // FIXME: this is a bit instantiation-specific. 7431 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 7432 7433 return SemaRef.Owned(E); 7434 } 7435 7436 DeclarationNameInfo NameInfo(E->getDecl()->getDeclName(), E->getLocation()); 7437 return getDerived().RebuildDeclRefExpr(NestedNameSpecifierLoc(), 7438 ND, NameInfo, 0); 7439} 7440 7441//===----------------------------------------------------------------------===// 7442// Type reconstruction 7443//===----------------------------------------------------------------------===// 7444 7445template<typename Derived> 7446QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 7447 SourceLocation Star) { 7448 return SemaRef.BuildPointerType(PointeeType, Star, 7449 getDerived().getBaseEntity()); 7450} 7451 7452template<typename Derived> 7453QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 7454 SourceLocation Star) { 7455 return SemaRef.BuildBlockPointerType(PointeeType, Star, 7456 getDerived().getBaseEntity()); 7457} 7458 7459template<typename Derived> 7460QualType 7461TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 7462 bool WrittenAsLValue, 7463 SourceLocation Sigil) { 7464 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 7465 Sigil, getDerived().getBaseEntity()); 7466} 7467 7468template<typename Derived> 7469QualType 7470TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 7471 QualType ClassType, 7472 SourceLocation Sigil) { 7473 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 7474 Sigil, getDerived().getBaseEntity()); 7475} 7476 7477template<typename Derived> 7478QualType 7479TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 7480 ArrayType::ArraySizeModifier SizeMod, 7481 const llvm::APInt *Size, 7482 Expr *SizeExpr, 7483 unsigned IndexTypeQuals, 7484 SourceRange BracketsRange) { 7485 if (SizeExpr || !Size) 7486 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 7487 IndexTypeQuals, BracketsRange, 7488 getDerived().getBaseEntity()); 7489 7490 QualType Types[] = { 7491 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 7492 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 7493 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 7494 }; 7495 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 7496 QualType SizeType; 7497 for (unsigned I = 0; I != NumTypes; ++I) 7498 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 7499 SizeType = Types[I]; 7500 break; 7501 } 7502 7503 IntegerLiteral ArraySize(SemaRef.Context, *Size, SizeType, 7504 /*FIXME*/BracketsRange.getBegin()); 7505 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 7506 IndexTypeQuals, BracketsRange, 7507 getDerived().getBaseEntity()); 7508} 7509 7510template<typename Derived> 7511QualType 7512TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 7513 ArrayType::ArraySizeModifier SizeMod, 7514 const llvm::APInt &Size, 7515 unsigned IndexTypeQuals, 7516 SourceRange BracketsRange) { 7517 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 7518 IndexTypeQuals, BracketsRange); 7519} 7520 7521template<typename Derived> 7522QualType 7523TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 7524 ArrayType::ArraySizeModifier SizeMod, 7525 unsigned IndexTypeQuals, 7526 SourceRange BracketsRange) { 7527 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 7528 IndexTypeQuals, BracketsRange); 7529} 7530 7531template<typename Derived> 7532QualType 7533TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 7534 ArrayType::ArraySizeModifier SizeMod, 7535 Expr *SizeExpr, 7536 unsigned IndexTypeQuals, 7537 SourceRange BracketsRange) { 7538 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 7539 SizeExpr, 7540 IndexTypeQuals, BracketsRange); 7541} 7542 7543template<typename Derived> 7544QualType 7545TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 7546 ArrayType::ArraySizeModifier SizeMod, 7547 Expr *SizeExpr, 7548 unsigned IndexTypeQuals, 7549 SourceRange BracketsRange) { 7550 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 7551 SizeExpr, 7552 IndexTypeQuals, BracketsRange); 7553} 7554 7555template<typename Derived> 7556QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 7557 unsigned NumElements, 7558 VectorType::VectorKind VecKind) { 7559 // FIXME: semantic checking! 7560 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 7561} 7562 7563template<typename Derived> 7564QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 7565 unsigned NumElements, 7566 SourceLocation AttributeLoc) { 7567 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 7568 NumElements, true); 7569 IntegerLiteral *VectorSize 7570 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 7571 AttributeLoc); 7572 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 7573} 7574 7575template<typename Derived> 7576QualType 7577TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 7578 Expr *SizeExpr, 7579 SourceLocation AttributeLoc) { 7580 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 7581} 7582 7583template<typename Derived> 7584QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 7585 QualType *ParamTypes, 7586 unsigned NumParamTypes, 7587 bool Variadic, 7588 unsigned Quals, 7589 RefQualifierKind RefQualifier, 7590 const FunctionType::ExtInfo &Info) { 7591 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 7592 Quals, RefQualifier, 7593 getDerived().getBaseLocation(), 7594 getDerived().getBaseEntity(), 7595 Info); 7596} 7597 7598template<typename Derived> 7599QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 7600 return SemaRef.Context.getFunctionNoProtoType(T); 7601} 7602 7603template<typename Derived> 7604QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 7605 assert(D && "no decl found"); 7606 if (D->isInvalidDecl()) return QualType(); 7607 7608 // FIXME: Doesn't account for ObjCInterfaceDecl! 7609 TypeDecl *Ty; 7610 if (isa<UsingDecl>(D)) { 7611 UsingDecl *Using = cast<UsingDecl>(D); 7612 assert(Using->isTypeName() && 7613 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 7614 7615 // A valid resolved using typename decl points to exactly one type decl. 7616 assert(++Using->shadow_begin() == Using->shadow_end()); 7617 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 7618 7619 } else { 7620 assert(isa<UnresolvedUsingTypenameDecl>(D) && 7621 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 7622 Ty = cast<UnresolvedUsingTypenameDecl>(D); 7623 } 7624 7625 return SemaRef.Context.getTypeDeclType(Ty); 7626} 7627 7628template<typename Derived> 7629QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 7630 SourceLocation Loc) { 7631 return SemaRef.BuildTypeofExprType(E, Loc); 7632} 7633 7634template<typename Derived> 7635QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 7636 return SemaRef.Context.getTypeOfType(Underlying); 7637} 7638 7639template<typename Derived> 7640QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 7641 SourceLocation Loc) { 7642 return SemaRef.BuildDecltypeType(E, Loc); 7643} 7644 7645template<typename Derived> 7646QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 7647 TemplateName Template, 7648 SourceLocation TemplateNameLoc, 7649 TemplateArgumentListInfo &TemplateArgs) { 7650 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 7651} 7652 7653template<typename Derived> 7654TemplateName 7655TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 7656 bool TemplateKW, 7657 TemplateDecl *Template) { 7658 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 7659 Template); 7660} 7661 7662template<typename Derived> 7663TemplateName 7664TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 7665 const IdentifierInfo &Name, 7666 SourceLocation NameLoc, 7667 QualType ObjectType, 7668 NamedDecl *FirstQualifierInScope) { 7669 UnqualifiedId TemplateName; 7670 TemplateName.setIdentifier(&Name, NameLoc); 7671 Sema::TemplateTy Template; 7672 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7673 /*FIXME:*/SourceLocation(), 7674 SS, 7675 TemplateName, 7676 ParsedType::make(ObjectType), 7677 /*EnteringContext=*/false, 7678 Template); 7679 return Template.get(); 7680} 7681 7682template<typename Derived> 7683TemplateName 7684TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 7685 OverloadedOperatorKind Operator, 7686 SourceLocation NameLoc, 7687 QualType ObjectType) { 7688 UnqualifiedId Name; 7689 // FIXME: Bogus location information. 7690 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 7691 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 7692 Sema::TemplateTy Template; 7693 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7694 /*FIXME:*/SourceLocation(), 7695 SS, 7696 Name, 7697 ParsedType::make(ObjectType), 7698 /*EnteringContext=*/false, 7699 Template); 7700 return Template.template getAsVal<TemplateName>(); 7701} 7702 7703template<typename Derived> 7704ExprResult 7705TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 7706 SourceLocation OpLoc, 7707 Expr *OrigCallee, 7708 Expr *First, 7709 Expr *Second) { 7710 Expr *Callee = OrigCallee->IgnoreParenCasts(); 7711 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 7712 7713 // Determine whether this should be a builtin operation. 7714 if (Op == OO_Subscript) { 7715 if (!First->getType()->isOverloadableType() && 7716 !Second->getType()->isOverloadableType()) 7717 return getSema().CreateBuiltinArraySubscriptExpr(First, 7718 Callee->getLocStart(), 7719 Second, OpLoc); 7720 } else if (Op == OO_Arrow) { 7721 // -> is never a builtin operation. 7722 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 7723 } else if (Second == 0 || isPostIncDec) { 7724 if (!First->getType()->isOverloadableType()) { 7725 // The argument is not of overloadable type, so try to create a 7726 // built-in unary operation. 7727 UnaryOperatorKind Opc 7728 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7729 7730 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 7731 } 7732 } else { 7733 if (!First->getType()->isOverloadableType() && 7734 !Second->getType()->isOverloadableType()) { 7735 // Neither of the arguments is an overloadable type, so try to 7736 // create a built-in binary operation. 7737 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7738 ExprResult Result 7739 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 7740 if (Result.isInvalid()) 7741 return ExprError(); 7742 7743 return move(Result); 7744 } 7745 } 7746 7747 // Compute the transformed set of functions (and function templates) to be 7748 // used during overload resolution. 7749 UnresolvedSet<16> Functions; 7750 7751 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 7752 assert(ULE->requiresADL()); 7753 7754 // FIXME: Do we have to check 7755 // IsAcceptableNonMemberOperatorCandidate for each of these? 7756 Functions.append(ULE->decls_begin(), ULE->decls_end()); 7757 } else { 7758 Functions.addDecl(cast<DeclRefExpr>(Callee)->getDecl()); 7759 } 7760 7761 // Add any functions found via argument-dependent lookup. 7762 Expr *Args[2] = { First, Second }; 7763 unsigned NumArgs = 1 + (Second != 0); 7764 7765 // Create the overloaded operator invocation for unary operators. 7766 if (NumArgs == 1 || isPostIncDec) { 7767 UnaryOperatorKind Opc 7768 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7769 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 7770 } 7771 7772 if (Op == OO_Subscript) 7773 return SemaRef.CreateOverloadedArraySubscriptExpr(Callee->getLocStart(), 7774 OpLoc, 7775 First, 7776 Second); 7777 7778 // Create the overloaded operator invocation for binary operators. 7779 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7780 ExprResult Result 7781 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 7782 if (Result.isInvalid()) 7783 return ExprError(); 7784 7785 return move(Result); 7786} 7787 7788template<typename Derived> 7789ExprResult 7790TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 7791 SourceLocation OperatorLoc, 7792 bool isArrow, 7793 CXXScopeSpec &SS, 7794 TypeSourceInfo *ScopeType, 7795 SourceLocation CCLoc, 7796 SourceLocation TildeLoc, 7797 PseudoDestructorTypeStorage Destroyed) { 7798 QualType BaseType = Base->getType(); 7799 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 7800 (!isArrow && !BaseType->getAs<RecordType>()) || 7801 (isArrow && BaseType->getAs<PointerType>() && 7802 !BaseType->getAs<PointerType>()->getPointeeType() 7803 ->template getAs<RecordType>())){ 7804 // This pseudo-destructor expression is still a pseudo-destructor. 7805 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 7806 isArrow? tok::arrow : tok::period, 7807 SS, ScopeType, CCLoc, TildeLoc, 7808 Destroyed, 7809 /*FIXME?*/true); 7810 } 7811 7812 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 7813 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 7814 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 7815 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 7816 NameInfo.setNamedTypeInfo(DestroyedType); 7817 7818 // FIXME: the ScopeType should be tacked onto SS. 7819 7820 return getSema().BuildMemberReferenceExpr(Base, BaseType, 7821 OperatorLoc, isArrow, 7822 SS, /*FIXME: FirstQualifier*/ 0, 7823 NameInfo, 7824 /*TemplateArgs*/ 0); 7825} 7826 7827} // end namespace clang 7828 7829#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 7830