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