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