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