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