TreeTransform.h revision 7cc58b4c927fca539d43eaa58e00dca95946eb7c
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 llvm_unreachable("Invalid C++ named cast"); 1732 } 1733 1734 return ExprError(); 1735 } 1736 1737 /// \brief Build a new C++ static_cast expression. 1738 /// 1739 /// By default, performs semantic analysis to build the new expression. 1740 /// Subclasses may override this routine to provide different behavior. 1741 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, 1742 SourceLocation LAngleLoc, 1743 TypeSourceInfo *TInfo, 1744 SourceLocation RAngleLoc, 1745 SourceLocation LParenLoc, 1746 Expr *SubExpr, 1747 SourceLocation RParenLoc) { 1748 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast, 1749 TInfo, SubExpr, 1750 SourceRange(LAngleLoc, RAngleLoc), 1751 SourceRange(LParenLoc, RParenLoc)); 1752 } 1753 1754 /// \brief Build a new C++ dynamic_cast expression. 1755 /// 1756 /// By default, performs semantic analysis to build the new expression. 1757 /// Subclasses may override this routine to provide different behavior. 1758 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, 1759 SourceLocation LAngleLoc, 1760 TypeSourceInfo *TInfo, 1761 SourceLocation RAngleLoc, 1762 SourceLocation LParenLoc, 1763 Expr *SubExpr, 1764 SourceLocation RParenLoc) { 1765 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast, 1766 TInfo, SubExpr, 1767 SourceRange(LAngleLoc, RAngleLoc), 1768 SourceRange(LParenLoc, RParenLoc)); 1769 } 1770 1771 /// \brief Build a new C++ reinterpret_cast expression. 1772 /// 1773 /// By default, performs semantic analysis to build the new expression. 1774 /// Subclasses may override this routine to provide different behavior. 1775 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, 1776 SourceLocation LAngleLoc, 1777 TypeSourceInfo *TInfo, 1778 SourceLocation RAngleLoc, 1779 SourceLocation LParenLoc, 1780 Expr *SubExpr, 1781 SourceLocation RParenLoc) { 1782 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, 1783 TInfo, SubExpr, 1784 SourceRange(LAngleLoc, RAngleLoc), 1785 SourceRange(LParenLoc, RParenLoc)); 1786 } 1787 1788 /// \brief Build a new C++ const_cast expression. 1789 /// 1790 /// By default, performs semantic analysis to build the new expression. 1791 /// Subclasses may override this routine to provide different behavior. 1792 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, 1793 SourceLocation LAngleLoc, 1794 TypeSourceInfo *TInfo, 1795 SourceLocation RAngleLoc, 1796 SourceLocation LParenLoc, 1797 Expr *SubExpr, 1798 SourceLocation RParenLoc) { 1799 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast, 1800 TInfo, SubExpr, 1801 SourceRange(LAngleLoc, RAngleLoc), 1802 SourceRange(LParenLoc, RParenLoc)); 1803 } 1804 1805 /// \brief Build a new C++ functional-style cast expression. 1806 /// 1807 /// By default, performs semantic analysis to build the new expression. 1808 /// Subclasses may override this routine to provide different behavior. 1809 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, 1810 SourceLocation LParenLoc, 1811 Expr *Sub, 1812 SourceLocation RParenLoc) { 1813 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc, 1814 MultiExprArg(&Sub, 1), 1815 RParenLoc); 1816 } 1817 1818 /// \brief Build a new C++ typeid(type) expression. 1819 /// 1820 /// By default, performs semantic analysis to build the new expression. 1821 /// Subclasses may override this routine to provide different behavior. 1822 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, 1823 SourceLocation TypeidLoc, 1824 TypeSourceInfo *Operand, 1825 SourceLocation RParenLoc) { 1826 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, 1827 RParenLoc); 1828 } 1829 1830 1831 /// \brief Build a new C++ typeid(expr) expression. 1832 /// 1833 /// By default, performs semantic analysis to build the new expression. 1834 /// Subclasses may override this routine to provide different behavior. 1835 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType, 1836 SourceLocation TypeidLoc, 1837 Expr *Operand, 1838 SourceLocation RParenLoc) { 1839 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand, 1840 RParenLoc); 1841 } 1842 1843 /// \brief Build a new C++ __uuidof(type) expression. 1844 /// 1845 /// By default, performs semantic analysis to build the new expression. 1846 /// Subclasses may override this routine to provide different behavior. 1847 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType, 1848 SourceLocation TypeidLoc, 1849 TypeSourceInfo *Operand, 1850 SourceLocation RParenLoc) { 1851 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand, 1852 RParenLoc); 1853 } 1854 1855 /// \brief Build a new C++ __uuidof(expr) expression. 1856 /// 1857 /// By default, performs semantic analysis to build the new expression. 1858 /// Subclasses may override this routine to provide different behavior. 1859 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType, 1860 SourceLocation TypeidLoc, 1861 Expr *Operand, 1862 SourceLocation RParenLoc) { 1863 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand, 1864 RParenLoc); 1865 } 1866 1867 /// \brief Build a new C++ "this" expression. 1868 /// 1869 /// By default, builds a new "this" expression without performing any 1870 /// semantic analysis. Subclasses may override this routine to provide 1871 /// different behavior. 1872 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, 1873 QualType ThisType, 1874 bool isImplicit) { 1875 return getSema().Owned( 1876 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, 1877 isImplicit)); 1878 } 1879 1880 /// \brief Build a new C++ throw expression. 1881 /// 1882 /// By default, performs semantic analysis to build the new expression. 1883 /// Subclasses may override this routine to provide different behavior. 1884 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub, 1885 bool IsThrownVariableInScope) { 1886 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope); 1887 } 1888 1889 /// \brief Build a new C++ default-argument expression. 1890 /// 1891 /// By default, builds a new default-argument expression, which does not 1892 /// require any semantic analysis. Subclasses may override this routine to 1893 /// provide different behavior. 1894 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, 1895 ParmVarDecl *Param) { 1896 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Loc, 1897 Param)); 1898 } 1899 1900 /// \brief Build a new C++ zero-initialization expression. 1901 /// 1902 /// By default, performs semantic analysis to build the new expression. 1903 /// Subclasses may override this routine to provide different behavior. 1904 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo, 1905 SourceLocation LParenLoc, 1906 SourceLocation RParenLoc) { 1907 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, 1908 MultiExprArg(getSema(), 0, 0), 1909 RParenLoc); 1910 } 1911 1912 /// \brief Build a new C++ "new" expression. 1913 /// 1914 /// By default, performs semantic analysis to build the new expression. 1915 /// Subclasses may override this routine to provide different behavior. 1916 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, 1917 bool UseGlobal, 1918 SourceLocation PlacementLParen, 1919 MultiExprArg PlacementArgs, 1920 SourceLocation PlacementRParen, 1921 SourceRange TypeIdParens, 1922 QualType AllocatedType, 1923 TypeSourceInfo *AllocatedTypeInfo, 1924 Expr *ArraySize, 1925 SourceLocation ConstructorLParen, 1926 MultiExprArg ConstructorArgs, 1927 SourceLocation ConstructorRParen) { 1928 return getSema().BuildCXXNew(StartLoc, UseGlobal, 1929 PlacementLParen, 1930 move(PlacementArgs), 1931 PlacementRParen, 1932 TypeIdParens, 1933 AllocatedType, 1934 AllocatedTypeInfo, 1935 ArraySize, 1936 ConstructorLParen, 1937 move(ConstructorArgs), 1938 ConstructorRParen); 1939 } 1940 1941 /// \brief Build a new C++ "delete" expression. 1942 /// 1943 /// By default, performs semantic analysis to build the new expression. 1944 /// Subclasses may override this routine to provide different behavior. 1945 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, 1946 bool IsGlobalDelete, 1947 bool IsArrayForm, 1948 Expr *Operand) { 1949 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, 1950 Operand); 1951 } 1952 1953 /// \brief Build a new unary type trait expression. 1954 /// 1955 /// By default, performs semantic analysis to build the new expression. 1956 /// Subclasses may override this routine to provide different behavior. 1957 ExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait, 1958 SourceLocation StartLoc, 1959 TypeSourceInfo *T, 1960 SourceLocation RParenLoc) { 1961 return getSema().BuildUnaryTypeTrait(Trait, StartLoc, T, RParenLoc); 1962 } 1963 1964 /// \brief Build a new binary type trait expression. 1965 /// 1966 /// By default, performs semantic analysis to build the new expression. 1967 /// Subclasses may override this routine to provide different behavior. 1968 ExprResult RebuildBinaryTypeTrait(BinaryTypeTrait Trait, 1969 SourceLocation StartLoc, 1970 TypeSourceInfo *LhsT, 1971 TypeSourceInfo *RhsT, 1972 SourceLocation RParenLoc) { 1973 return getSema().BuildBinaryTypeTrait(Trait, StartLoc, LhsT, RhsT, RParenLoc); 1974 } 1975 1976 /// \brief Build a new array type trait expression. 1977 /// 1978 /// By default, performs semantic analysis to build the new expression. 1979 /// Subclasses may override this routine to provide different behavior. 1980 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait, 1981 SourceLocation StartLoc, 1982 TypeSourceInfo *TSInfo, 1983 Expr *DimExpr, 1984 SourceLocation RParenLoc) { 1985 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc); 1986 } 1987 1988 /// \brief Build a new expression trait expression. 1989 /// 1990 /// By default, performs semantic analysis to build the new expression. 1991 /// Subclasses may override this routine to provide different behavior. 1992 ExprResult RebuildExpressionTrait(ExpressionTrait Trait, 1993 SourceLocation StartLoc, 1994 Expr *Queried, 1995 SourceLocation RParenLoc) { 1996 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc); 1997 } 1998 1999 /// \brief Build a new (previously unresolved) declaration reference 2000 /// expression. 2001 /// 2002 /// By default, performs semantic analysis to build the new expression. 2003 /// Subclasses may override this routine to provide different behavior. 2004 ExprResult RebuildDependentScopeDeclRefExpr( 2005 NestedNameSpecifierLoc QualifierLoc, 2006 const DeclarationNameInfo &NameInfo, 2007 const TemplateArgumentListInfo *TemplateArgs) { 2008 CXXScopeSpec SS; 2009 SS.Adopt(QualifierLoc); 2010 2011 if (TemplateArgs) 2012 return getSema().BuildQualifiedTemplateIdExpr(SS, NameInfo, 2013 *TemplateArgs); 2014 2015 return getSema().BuildQualifiedDeclarationNameExpr(SS, NameInfo); 2016 } 2017 2018 /// \brief Build a new template-id expression. 2019 /// 2020 /// By default, performs semantic analysis to build the new expression. 2021 /// Subclasses may override this routine to provide different behavior. 2022 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS, 2023 LookupResult &R, 2024 bool RequiresADL, 2025 const TemplateArgumentListInfo &TemplateArgs) { 2026 return getSema().BuildTemplateIdExpr(SS, R, RequiresADL, TemplateArgs); 2027 } 2028 2029 /// \brief Build a new object-construction expression. 2030 /// 2031 /// By default, performs semantic analysis to build the new expression. 2032 /// Subclasses may override this routine to provide different behavior. 2033 ExprResult RebuildCXXConstructExpr(QualType T, 2034 SourceLocation Loc, 2035 CXXConstructorDecl *Constructor, 2036 bool IsElidable, 2037 MultiExprArg Args, 2038 bool HadMultipleCandidates, 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 HadMultipleCandidates, 2050 RequiresZeroInit, ConstructKind, 2051 ParenRange); 2052 } 2053 2054 /// \brief Build a new object-construction expression. 2055 /// 2056 /// By default, performs semantic analysis to build the new expression. 2057 /// Subclasses may override this routine to provide different behavior. 2058 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo, 2059 SourceLocation LParenLoc, 2060 MultiExprArg Args, 2061 SourceLocation RParenLoc) { 2062 return getSema().BuildCXXTypeConstructExpr(TSInfo, 2063 LParenLoc, 2064 move(Args), 2065 RParenLoc); 2066 } 2067 2068 /// \brief Build a new object-construction expression. 2069 /// 2070 /// By default, performs semantic analysis to build the new expression. 2071 /// Subclasses may override this routine to provide different behavior. 2072 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo, 2073 SourceLocation LParenLoc, 2074 MultiExprArg Args, 2075 SourceLocation RParenLoc) { 2076 return getSema().BuildCXXTypeConstructExpr(TSInfo, 2077 LParenLoc, 2078 move(Args), 2079 RParenLoc); 2080 } 2081 2082 /// \brief Build a new member reference expression. 2083 /// 2084 /// By default, performs semantic analysis to build the new expression. 2085 /// Subclasses may override this routine to provide different behavior. 2086 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE, 2087 QualType BaseType, 2088 bool IsArrow, 2089 SourceLocation OperatorLoc, 2090 NestedNameSpecifierLoc QualifierLoc, 2091 NamedDecl *FirstQualifierInScope, 2092 const DeclarationNameInfo &MemberNameInfo, 2093 const TemplateArgumentListInfo *TemplateArgs) { 2094 CXXScopeSpec SS; 2095 SS.Adopt(QualifierLoc); 2096 2097 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, 2098 OperatorLoc, IsArrow, 2099 SS, FirstQualifierInScope, 2100 MemberNameInfo, 2101 TemplateArgs); 2102 } 2103 2104 /// \brief Build a new member reference expression. 2105 /// 2106 /// By default, performs semantic analysis to build the new expression. 2107 /// Subclasses may override this routine to provide different behavior. 2108 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, 2109 QualType BaseType, 2110 SourceLocation OperatorLoc, 2111 bool IsArrow, 2112 NestedNameSpecifierLoc QualifierLoc, 2113 NamedDecl *FirstQualifierInScope, 2114 LookupResult &R, 2115 const TemplateArgumentListInfo *TemplateArgs) { 2116 CXXScopeSpec SS; 2117 SS.Adopt(QualifierLoc); 2118 2119 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType, 2120 OperatorLoc, IsArrow, 2121 SS, FirstQualifierInScope, 2122 R, TemplateArgs); 2123 } 2124 2125 /// \brief Build a new noexcept expression. 2126 /// 2127 /// By default, performs semantic analysis to build the new expression. 2128 /// Subclasses may override this routine to provide different behavior. 2129 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) { 2130 return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd()); 2131 } 2132 2133 /// \brief Build a new expression to compute the length of a parameter pack. 2134 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, 2135 SourceLocation PackLoc, 2136 SourceLocation RParenLoc, 2137 unsigned Length) { 2138 return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(), 2139 OperatorLoc, Pack, PackLoc, 2140 RParenLoc, Length); 2141 } 2142 2143 /// \brief Build a new Objective-C @encode expression. 2144 /// 2145 /// By default, performs semantic analysis to build the new expression. 2146 /// Subclasses may override this routine to provide different behavior. 2147 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 2148 TypeSourceInfo *EncodeTypeInfo, 2149 SourceLocation RParenLoc) { 2150 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, 2151 RParenLoc)); 2152 } 2153 2154 /// \brief Build a new Objective-C class message. 2155 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo, 2156 Selector Sel, 2157 ArrayRef<SourceLocation> SelectorLocs, 2158 ObjCMethodDecl *Method, 2159 SourceLocation LBracLoc, 2160 MultiExprArg Args, 2161 SourceLocation RBracLoc) { 2162 return SemaRef.BuildClassMessage(ReceiverTypeInfo, 2163 ReceiverTypeInfo->getType(), 2164 /*SuperLoc=*/SourceLocation(), 2165 Sel, Method, LBracLoc, SelectorLocs, 2166 RBracLoc, move(Args)); 2167 } 2168 2169 /// \brief Build a new Objective-C instance message. 2170 ExprResult RebuildObjCMessageExpr(Expr *Receiver, 2171 Selector Sel, 2172 ArrayRef<SourceLocation> SelectorLocs, 2173 ObjCMethodDecl *Method, 2174 SourceLocation LBracLoc, 2175 MultiExprArg Args, 2176 SourceLocation RBracLoc) { 2177 return SemaRef.BuildInstanceMessage(Receiver, 2178 Receiver->getType(), 2179 /*SuperLoc=*/SourceLocation(), 2180 Sel, Method, LBracLoc, SelectorLocs, 2181 RBracLoc, move(Args)); 2182 } 2183 2184 /// \brief Build a new Objective-C ivar reference expression. 2185 /// 2186 /// By default, performs semantic analysis to build the new expression. 2187 /// Subclasses may override this routine to provide different behavior. 2188 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar, 2189 SourceLocation IvarLoc, 2190 bool IsArrow, bool IsFreeIvar) { 2191 // FIXME: We lose track of the IsFreeIvar bit. 2192 CXXScopeSpec SS; 2193 ExprResult Base = getSema().Owned(BaseArg); 2194 LookupResult R(getSema(), Ivar->getDeclName(), IvarLoc, 2195 Sema::LookupMemberName); 2196 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2197 /*FIME:*/IvarLoc, 2198 SS, 0, 2199 false); 2200 if (Result.isInvalid() || Base.isInvalid()) 2201 return ExprError(); 2202 2203 if (Result.get()) 2204 return move(Result); 2205 2206 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2207 /*FIXME:*/IvarLoc, IsArrow, SS, 2208 /*FirstQualifierInScope=*/0, 2209 R, 2210 /*TemplateArgs=*/0); 2211 } 2212 2213 /// \brief Build a new Objective-C property reference expression. 2214 /// 2215 /// By default, performs semantic analysis to build the new expression. 2216 /// Subclasses may override this routine to provide different behavior. 2217 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg, 2218 ObjCPropertyDecl *Property, 2219 SourceLocation PropertyLoc) { 2220 CXXScopeSpec SS; 2221 ExprResult Base = getSema().Owned(BaseArg); 2222 LookupResult R(getSema(), Property->getDeclName(), PropertyLoc, 2223 Sema::LookupMemberName); 2224 bool IsArrow = false; 2225 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2226 /*FIME:*/PropertyLoc, 2227 SS, 0, false); 2228 if (Result.isInvalid() || Base.isInvalid()) 2229 return ExprError(); 2230 2231 if (Result.get()) 2232 return move(Result); 2233 2234 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2235 /*FIXME:*/PropertyLoc, IsArrow, 2236 SS, 2237 /*FirstQualifierInScope=*/0, 2238 R, 2239 /*TemplateArgs=*/0); 2240 } 2241 2242 /// \brief Build a new Objective-C property reference expression. 2243 /// 2244 /// By default, performs semantic analysis to build the new expression. 2245 /// Subclasses may override this routine to provide different behavior. 2246 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T, 2247 ObjCMethodDecl *Getter, 2248 ObjCMethodDecl *Setter, 2249 SourceLocation PropertyLoc) { 2250 // Since these expressions can only be value-dependent, we do not 2251 // need to perform semantic analysis again. 2252 return Owned( 2253 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T, 2254 VK_LValue, OK_ObjCProperty, 2255 PropertyLoc, Base)); 2256 } 2257 2258 /// \brief Build a new Objective-C "isa" expression. 2259 /// 2260 /// By default, performs semantic analysis to build the new expression. 2261 /// Subclasses may override this routine to provide different behavior. 2262 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc, 2263 bool IsArrow) { 2264 CXXScopeSpec SS; 2265 ExprResult Base = getSema().Owned(BaseArg); 2266 LookupResult R(getSema(), &getSema().Context.Idents.get("isa"), IsaLoc, 2267 Sema::LookupMemberName); 2268 ExprResult Result = getSema().LookupMemberExpr(R, Base, IsArrow, 2269 /*FIME:*/IsaLoc, 2270 SS, 0, false); 2271 if (Result.isInvalid() || Base.isInvalid()) 2272 return ExprError(); 2273 2274 if (Result.get()) 2275 return move(Result); 2276 2277 return getSema().BuildMemberReferenceExpr(Base.get(), Base.get()->getType(), 2278 /*FIXME:*/IsaLoc, IsArrow, SS, 2279 /*FirstQualifierInScope=*/0, 2280 R, 2281 /*TemplateArgs=*/0); 2282 } 2283 2284 /// \brief Build a new shuffle vector expression. 2285 /// 2286 /// By default, performs semantic analysis to build the new expression. 2287 /// Subclasses may override this routine to provide different behavior. 2288 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 2289 MultiExprArg SubExprs, 2290 SourceLocation RParenLoc) { 2291 // Find the declaration for __builtin_shufflevector 2292 const IdentifierInfo &Name 2293 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 2294 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 2295 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 2296 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 2297 2298 // Build a reference to the __builtin_shufflevector builtin 2299 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 2300 ExprResult Callee 2301 = SemaRef.Owned(new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 2302 VK_LValue, BuiltinLoc)); 2303 Callee = SemaRef.UsualUnaryConversions(Callee.take()); 2304 if (Callee.isInvalid()) 2305 return ExprError(); 2306 2307 // Build the CallExpr 2308 unsigned NumSubExprs = SubExprs.size(); 2309 Expr **Subs = (Expr **)SubExprs.release(); 2310 ExprResult TheCall = SemaRef.Owned( 2311 new (SemaRef.Context) CallExpr(SemaRef.Context, Callee.take(), 2312 Subs, NumSubExprs, 2313 Builtin->getCallResultType(), 2314 Expr::getValueKindForType(Builtin->getResultType()), 2315 RParenLoc)); 2316 2317 // Type-check the __builtin_shufflevector expression. 2318 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.take())); 2319 } 2320 2321 /// \brief Build a new template argument pack expansion. 2322 /// 2323 /// By default, performs semantic analysis to build a new pack expansion 2324 /// for a template argument. Subclasses may override this routine to provide 2325 /// different behavior. 2326 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, 2327 SourceLocation EllipsisLoc, 2328 llvm::Optional<unsigned> NumExpansions) { 2329 switch (Pattern.getArgument().getKind()) { 2330 case TemplateArgument::Expression: { 2331 ExprResult Result 2332 = getSema().CheckPackExpansion(Pattern.getSourceExpression(), 2333 EllipsisLoc, NumExpansions); 2334 if (Result.isInvalid()) 2335 return TemplateArgumentLoc(); 2336 2337 return TemplateArgumentLoc(Result.get(), Result.get()); 2338 } 2339 2340 case TemplateArgument::Template: 2341 return TemplateArgumentLoc(TemplateArgument( 2342 Pattern.getArgument().getAsTemplate(), 2343 NumExpansions), 2344 Pattern.getTemplateQualifierLoc(), 2345 Pattern.getTemplateNameLoc(), 2346 EllipsisLoc); 2347 2348 case TemplateArgument::Null: 2349 case TemplateArgument::Integral: 2350 case TemplateArgument::Declaration: 2351 case TemplateArgument::Pack: 2352 case TemplateArgument::TemplateExpansion: 2353 llvm_unreachable("Pack expansion pattern has no parameter packs"); 2354 2355 case TemplateArgument::Type: 2356 if (TypeSourceInfo *Expansion 2357 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(), 2358 EllipsisLoc, 2359 NumExpansions)) 2360 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()), 2361 Expansion); 2362 break; 2363 } 2364 2365 return TemplateArgumentLoc(); 2366 } 2367 2368 /// \brief Build a new expression pack expansion. 2369 /// 2370 /// By default, performs semantic analysis to build a new pack expansion 2371 /// for an expression. Subclasses may override this routine to provide 2372 /// different behavior. 2373 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, 2374 llvm::Optional<unsigned> NumExpansions) { 2375 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); 2376 } 2377 2378private: 2379 TypeLoc TransformTypeInObjectScope(TypeLoc TL, 2380 QualType ObjectType, 2381 NamedDecl *FirstQualifierInScope, 2382 CXXScopeSpec &SS); 2383 2384 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo, 2385 QualType ObjectType, 2386 NamedDecl *FirstQualifierInScope, 2387 CXXScopeSpec &SS); 2388}; 2389 2390template<typename Derived> 2391StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 2392 if (!S) 2393 return SemaRef.Owned(S); 2394 2395 switch (S->getStmtClass()) { 2396 case Stmt::NoStmtClass: break; 2397 2398 // Transform individual statement nodes 2399#define STMT(Node, Parent) \ 2400 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 2401#define ABSTRACT_STMT(Node) 2402#define EXPR(Node, Parent) 2403#include "clang/AST/StmtNodes.inc" 2404 2405 // Transform expressions by calling TransformExpr. 2406#define STMT(Node, Parent) 2407#define ABSTRACT_STMT(Stmt) 2408#define EXPR(Node, Parent) case Stmt::Node##Class: 2409#include "clang/AST/StmtNodes.inc" 2410 { 2411 ExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 2412 if (E.isInvalid()) 2413 return StmtError(); 2414 2415 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E.take())); 2416 } 2417 } 2418 2419 return SemaRef.Owned(S); 2420} 2421 2422 2423template<typename Derived> 2424ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { 2425 if (!E) 2426 return SemaRef.Owned(E); 2427 2428 switch (E->getStmtClass()) { 2429 case Stmt::NoStmtClass: break; 2430#define STMT(Node, Parent) case Stmt::Node##Class: break; 2431#define ABSTRACT_STMT(Stmt) 2432#define EXPR(Node, Parent) \ 2433 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 2434#include "clang/AST/StmtNodes.inc" 2435 } 2436 2437 return SemaRef.Owned(E); 2438} 2439 2440template<typename Derived> 2441bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, 2442 unsigned NumInputs, 2443 bool IsCall, 2444 SmallVectorImpl<Expr *> &Outputs, 2445 bool *ArgChanged) { 2446 for (unsigned I = 0; I != NumInputs; ++I) { 2447 // If requested, drop call arguments that need to be dropped. 2448 if (IsCall && getDerived().DropCallArgument(Inputs[I])) { 2449 if (ArgChanged) 2450 *ArgChanged = true; 2451 2452 break; 2453 } 2454 2455 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { 2456 Expr *Pattern = Expansion->getPattern(); 2457 2458 SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2459 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 2460 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 2461 2462 // Determine whether the set of unexpanded parameter packs can and should 2463 // be expanded. 2464 bool Expand = true; 2465 bool RetainExpansion = false; 2466 llvm::Optional<unsigned> OrigNumExpansions 2467 = Expansion->getNumExpansions(); 2468 llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; 2469 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 2470 Pattern->getSourceRange(), 2471 Unexpanded, 2472 Expand, RetainExpansion, 2473 NumExpansions)) 2474 return true; 2475 2476 if (!Expand) { 2477 // The transform has determined that we should perform a simple 2478 // transformation on the pack expansion, producing another pack 2479 // expansion. 2480 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2481 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 2482 if (OutPattern.isInvalid()) 2483 return true; 2484 2485 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 2486 Expansion->getEllipsisLoc(), 2487 NumExpansions); 2488 if (Out.isInvalid()) 2489 return true; 2490 2491 if (ArgChanged) 2492 *ArgChanged = true; 2493 Outputs.push_back(Out.get()); 2494 continue; 2495 } 2496 2497 // Record right away that the argument was changed. This needs 2498 // to happen even if the array expands to nothing. 2499 if (ArgChanged) *ArgChanged = true; 2500 2501 // The transform has determined that we should perform an elementwise 2502 // expansion of the pattern. Do so. 2503 for (unsigned I = 0; I != *NumExpansions; ++I) { 2504 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2505 ExprResult Out = getDerived().TransformExpr(Pattern); 2506 if (Out.isInvalid()) 2507 return true; 2508 2509 if (Out.get()->containsUnexpandedParameterPack()) { 2510 Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc(), 2511 OrigNumExpansions); 2512 if (Out.isInvalid()) 2513 return true; 2514 } 2515 2516 Outputs.push_back(Out.get()); 2517 } 2518 2519 continue; 2520 } 2521 2522 ExprResult Result = getDerived().TransformExpr(Inputs[I]); 2523 if (Result.isInvalid()) 2524 return true; 2525 2526 if (Result.get() != Inputs[I] && ArgChanged) 2527 *ArgChanged = true; 2528 2529 Outputs.push_back(Result.get()); 2530 } 2531 2532 return false; 2533} 2534 2535template<typename Derived> 2536NestedNameSpecifierLoc 2537TreeTransform<Derived>::TransformNestedNameSpecifierLoc( 2538 NestedNameSpecifierLoc NNS, 2539 QualType ObjectType, 2540 NamedDecl *FirstQualifierInScope) { 2541 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 2542 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier; 2543 Qualifier = Qualifier.getPrefix()) 2544 Qualifiers.push_back(Qualifier); 2545 2546 CXXScopeSpec SS; 2547 while (!Qualifiers.empty()) { 2548 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 2549 NestedNameSpecifier *QNNS = Q.getNestedNameSpecifier(); 2550 2551 switch (QNNS->getKind()) { 2552 case NestedNameSpecifier::Identifier: 2553 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/0, 2554 *QNNS->getAsIdentifier(), 2555 Q.getLocalBeginLoc(), 2556 Q.getLocalEndLoc(), 2557 ObjectType, false, SS, 2558 FirstQualifierInScope, false)) 2559 return NestedNameSpecifierLoc(); 2560 2561 break; 2562 2563 case NestedNameSpecifier::Namespace: { 2564 NamespaceDecl *NS 2565 = cast_or_null<NamespaceDecl>( 2566 getDerived().TransformDecl( 2567 Q.getLocalBeginLoc(), 2568 QNNS->getAsNamespace())); 2569 SS.Extend(SemaRef.Context, NS, Q.getLocalBeginLoc(), Q.getLocalEndLoc()); 2570 break; 2571 } 2572 2573 case NestedNameSpecifier::NamespaceAlias: { 2574 NamespaceAliasDecl *Alias 2575 = cast_or_null<NamespaceAliasDecl>( 2576 getDerived().TransformDecl(Q.getLocalBeginLoc(), 2577 QNNS->getAsNamespaceAlias())); 2578 SS.Extend(SemaRef.Context, Alias, Q.getLocalBeginLoc(), 2579 Q.getLocalEndLoc()); 2580 break; 2581 } 2582 2583 case NestedNameSpecifier::Global: 2584 // There is no meaningful transformation that one could perform on the 2585 // global scope. 2586 SS.MakeGlobal(SemaRef.Context, Q.getBeginLoc()); 2587 break; 2588 2589 case NestedNameSpecifier::TypeSpecWithTemplate: 2590 case NestedNameSpecifier::TypeSpec: { 2591 TypeLoc TL = TransformTypeInObjectScope(Q.getTypeLoc(), ObjectType, 2592 FirstQualifierInScope, SS); 2593 2594 if (!TL) 2595 return NestedNameSpecifierLoc(); 2596 2597 if (TL.getType()->isDependentType() || TL.getType()->isRecordType() || 2598 (SemaRef.getLangOptions().CPlusPlus0x && 2599 TL.getType()->isEnumeralType())) { 2600 assert(!TL.getType().hasLocalQualifiers() && 2601 "Can't get cv-qualifiers here"); 2602 SS.Extend(SemaRef.Context, /*FIXME:*/SourceLocation(), TL, 2603 Q.getLocalEndLoc()); 2604 break; 2605 } 2606 // If the nested-name-specifier is an invalid type def, don't emit an 2607 // error because a previous error should have already been emitted. 2608 TypedefTypeLoc* TTL = dyn_cast<TypedefTypeLoc>(&TL); 2609 if (!TTL || !TTL->getTypedefNameDecl()->isInvalidDecl()) { 2610 SemaRef.Diag(TL.getBeginLoc(), diag::err_nested_name_spec_non_tag) 2611 << TL.getType() << SS.getRange(); 2612 } 2613 return NestedNameSpecifierLoc(); 2614 } 2615 } 2616 2617 // The qualifier-in-scope and object type only apply to the leftmost entity. 2618 FirstQualifierInScope = 0; 2619 ObjectType = QualType(); 2620 } 2621 2622 // Don't rebuild the nested-name-specifier if we don't have to. 2623 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() && 2624 !getDerived().AlwaysRebuild()) 2625 return NNS; 2626 2627 // If we can re-use the source-location data from the original 2628 // nested-name-specifier, do so. 2629 if (SS.location_size() == NNS.getDataLength() && 2630 memcmp(SS.location_data(), NNS.getOpaqueData(), SS.location_size()) == 0) 2631 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData()); 2632 2633 // Allocate new nested-name-specifier location information. 2634 return SS.getWithLocInContext(SemaRef.Context); 2635} 2636 2637template<typename Derived> 2638DeclarationNameInfo 2639TreeTransform<Derived> 2640::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 2641 DeclarationName Name = NameInfo.getName(); 2642 if (!Name) 2643 return DeclarationNameInfo(); 2644 2645 switch (Name.getNameKind()) { 2646 case DeclarationName::Identifier: 2647 case DeclarationName::ObjCZeroArgSelector: 2648 case DeclarationName::ObjCOneArgSelector: 2649 case DeclarationName::ObjCMultiArgSelector: 2650 case DeclarationName::CXXOperatorName: 2651 case DeclarationName::CXXLiteralOperatorName: 2652 case DeclarationName::CXXUsingDirective: 2653 return NameInfo; 2654 2655 case DeclarationName::CXXConstructorName: 2656 case DeclarationName::CXXDestructorName: 2657 case DeclarationName::CXXConversionFunctionName: { 2658 TypeSourceInfo *NewTInfo; 2659 CanQualType NewCanTy; 2660 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 2661 NewTInfo = getDerived().TransformType(OldTInfo); 2662 if (!NewTInfo) 2663 return DeclarationNameInfo(); 2664 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 2665 } 2666 else { 2667 NewTInfo = 0; 2668 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 2669 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 2670 if (NewT.isNull()) 2671 return DeclarationNameInfo(); 2672 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 2673 } 2674 2675 DeclarationName NewName 2676 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 2677 NewCanTy); 2678 DeclarationNameInfo NewNameInfo(NameInfo); 2679 NewNameInfo.setName(NewName); 2680 NewNameInfo.setNamedTypeInfo(NewTInfo); 2681 return NewNameInfo; 2682 } 2683 } 2684 2685 llvm_unreachable("Unknown name kind."); 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->hadMultipleCandidates(), 7351 E->requiresZeroInitialization(), 7352 E->getConstructionKind(), 7353 E->getParenRange()); 7354} 7355 7356/// \brief Transform a C++ temporary-binding expression. 7357/// 7358/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 7359/// transform the subexpression and return that. 7360template<typename Derived> 7361ExprResult 7362TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 7363 return getDerived().TransformExpr(E->getSubExpr()); 7364} 7365 7366/// \brief Transform a C++ expression that contains cleanups that should 7367/// be run after the expression is evaluated. 7368/// 7369/// Since ExprWithCleanups nodes are implicitly generated, we 7370/// just transform the subexpression and return that. 7371template<typename Derived> 7372ExprResult 7373TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 7374 return getDerived().TransformExpr(E->getSubExpr()); 7375} 7376 7377template<typename Derived> 7378ExprResult 7379TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 7380 CXXTemporaryObjectExpr *E) { 7381 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 7382 if (!T) 7383 return ExprError(); 7384 7385 CXXConstructorDecl *Constructor 7386 = cast_or_null<CXXConstructorDecl>( 7387 getDerived().TransformDecl(E->getLocStart(), 7388 E->getConstructor())); 7389 if (!Constructor) 7390 return ExprError(); 7391 7392 bool ArgumentChanged = false; 7393 ASTOwningVector<Expr*> Args(SemaRef); 7394 Args.reserve(E->getNumArgs()); 7395 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 7396 &ArgumentChanged)) 7397 return ExprError(); 7398 7399 if (!getDerived().AlwaysRebuild() && 7400 T == E->getTypeSourceInfo() && 7401 Constructor == E->getConstructor() && 7402 !ArgumentChanged) { 7403 // FIXME: Instantiation-specific 7404 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 7405 return SemaRef.MaybeBindToTemporary(E); 7406 } 7407 7408 return getDerived().RebuildCXXTemporaryObjectExpr(T, 7409 /*FIXME:*/T->getTypeLoc().getEndLoc(), 7410 move_arg(Args), 7411 E->getLocEnd()); 7412} 7413 7414template<typename Derived> 7415ExprResult 7416TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 7417 CXXUnresolvedConstructExpr *E) { 7418 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 7419 if (!T) 7420 return ExprError(); 7421 7422 bool ArgumentChanged = false; 7423 ASTOwningVector<Expr*> Args(SemaRef); 7424 Args.reserve(E->arg_size()); 7425 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 7426 &ArgumentChanged)) 7427 return ExprError(); 7428 7429 if (!getDerived().AlwaysRebuild() && 7430 T == E->getTypeSourceInfo() && 7431 !ArgumentChanged) 7432 return SemaRef.Owned(E); 7433 7434 // FIXME: we're faking the locations of the commas 7435 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 7436 E->getLParenLoc(), 7437 move_arg(Args), 7438 E->getRParenLoc()); 7439} 7440 7441template<typename Derived> 7442ExprResult 7443TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 7444 CXXDependentScopeMemberExpr *E) { 7445 // Transform the base of the expression. 7446 ExprResult Base((Expr*) 0); 7447 Expr *OldBase; 7448 QualType BaseType; 7449 QualType ObjectType; 7450 if (!E->isImplicitAccess()) { 7451 OldBase = E->getBase(); 7452 Base = getDerived().TransformExpr(OldBase); 7453 if (Base.isInvalid()) 7454 return ExprError(); 7455 7456 // Start the member reference and compute the object's type. 7457 ParsedType ObjectTy; 7458 bool MayBePseudoDestructor = false; 7459 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 7460 E->getOperatorLoc(), 7461 E->isArrow()? tok::arrow : tok::period, 7462 ObjectTy, 7463 MayBePseudoDestructor); 7464 if (Base.isInvalid()) 7465 return ExprError(); 7466 7467 ObjectType = ObjectTy.get(); 7468 BaseType = ((Expr*) Base.get())->getType(); 7469 } else { 7470 OldBase = 0; 7471 BaseType = getDerived().TransformType(E->getBaseType()); 7472 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 7473 } 7474 7475 // Transform the first part of the nested-name-specifier that qualifies 7476 // the member name. 7477 NamedDecl *FirstQualifierInScope 7478 = getDerived().TransformFirstQualifierInScope( 7479 E->getFirstQualifierFoundInScope(), 7480 E->getQualifierLoc().getBeginLoc()); 7481 7482 NestedNameSpecifierLoc QualifierLoc; 7483 if (E->getQualifier()) { 7484 QualifierLoc 7485 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(), 7486 ObjectType, 7487 FirstQualifierInScope); 7488 if (!QualifierLoc) 7489 return ExprError(); 7490 } 7491 7492 // TODO: If this is a conversion-function-id, verify that the 7493 // destination type name (if present) resolves the same way after 7494 // instantiation as it did in the local scope. 7495 7496 DeclarationNameInfo NameInfo 7497 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 7498 if (!NameInfo.getName()) 7499 return ExprError(); 7500 7501 if (!E->hasExplicitTemplateArgs()) { 7502 // This is a reference to a member without an explicitly-specified 7503 // template argument list. Optimize for this common case. 7504 if (!getDerived().AlwaysRebuild() && 7505 Base.get() == OldBase && 7506 BaseType == E->getBaseType() && 7507 QualifierLoc == E->getQualifierLoc() && 7508 NameInfo.getName() == E->getMember() && 7509 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 7510 return SemaRef.Owned(E); 7511 7512 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 7513 BaseType, 7514 E->isArrow(), 7515 E->getOperatorLoc(), 7516 QualifierLoc, 7517 FirstQualifierInScope, 7518 NameInfo, 7519 /*TemplateArgs*/ 0); 7520 } 7521 7522 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 7523 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 7524 E->getNumTemplateArgs(), 7525 TransArgs)) 7526 return ExprError(); 7527 7528 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 7529 BaseType, 7530 E->isArrow(), 7531 E->getOperatorLoc(), 7532 QualifierLoc, 7533 FirstQualifierInScope, 7534 NameInfo, 7535 &TransArgs); 7536} 7537 7538template<typename Derived> 7539ExprResult 7540TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 7541 // Transform the base of the expression. 7542 ExprResult Base((Expr*) 0); 7543 QualType BaseType; 7544 if (!Old->isImplicitAccess()) { 7545 Base = getDerived().TransformExpr(Old->getBase()); 7546 if (Base.isInvalid()) 7547 return ExprError(); 7548 BaseType = ((Expr*) Base.get())->getType(); 7549 } else { 7550 BaseType = getDerived().TransformType(Old->getBaseType()); 7551 } 7552 7553 NestedNameSpecifierLoc QualifierLoc; 7554 if (Old->getQualifierLoc()) { 7555 QualifierLoc 7556 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc()); 7557 if (!QualifierLoc) 7558 return ExprError(); 7559 } 7560 7561 LookupResult R(SemaRef, Old->getMemberNameInfo(), 7562 Sema::LookupOrdinaryName); 7563 7564 // Transform all the decls. 7565 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 7566 E = Old->decls_end(); I != E; ++I) { 7567 NamedDecl *InstD = static_cast<NamedDecl*>( 7568 getDerived().TransformDecl(Old->getMemberLoc(), 7569 *I)); 7570 if (!InstD) { 7571 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 7572 // This can happen because of dependent hiding. 7573 if (isa<UsingShadowDecl>(*I)) 7574 continue; 7575 else { 7576 R.clear(); 7577 return ExprError(); 7578 } 7579 } 7580 7581 // Expand using declarations. 7582 if (isa<UsingDecl>(InstD)) { 7583 UsingDecl *UD = cast<UsingDecl>(InstD); 7584 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 7585 E = UD->shadow_end(); I != E; ++I) 7586 R.addDecl(*I); 7587 continue; 7588 } 7589 7590 R.addDecl(InstD); 7591 } 7592 7593 R.resolveKind(); 7594 7595 // Determine the naming class. 7596 if (Old->getNamingClass()) { 7597 CXXRecordDecl *NamingClass 7598 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 7599 Old->getMemberLoc(), 7600 Old->getNamingClass())); 7601 if (!NamingClass) 7602 return ExprError(); 7603 7604 R.setNamingClass(NamingClass); 7605 } 7606 7607 TemplateArgumentListInfo TransArgs; 7608 if (Old->hasExplicitTemplateArgs()) { 7609 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 7610 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 7611 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 7612 Old->getNumTemplateArgs(), 7613 TransArgs)) 7614 return ExprError(); 7615 } 7616 7617 // FIXME: to do this check properly, we will need to preserve the 7618 // first-qualifier-in-scope here, just in case we had a dependent 7619 // base (and therefore couldn't do the check) and a 7620 // nested-name-qualifier (and therefore could do the lookup). 7621 NamedDecl *FirstQualifierInScope = 0; 7622 7623 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 7624 BaseType, 7625 Old->getOperatorLoc(), 7626 Old->isArrow(), 7627 QualifierLoc, 7628 FirstQualifierInScope, 7629 R, 7630 (Old->hasExplicitTemplateArgs() 7631 ? &TransArgs : 0)); 7632} 7633 7634template<typename Derived> 7635ExprResult 7636TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 7637 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 7638 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 7639 if (SubExpr.isInvalid()) 7640 return ExprError(); 7641 7642 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 7643 return SemaRef.Owned(E); 7644 7645 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 7646} 7647 7648template<typename Derived> 7649ExprResult 7650TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 7651 ExprResult Pattern = getDerived().TransformExpr(E->getPattern()); 7652 if (Pattern.isInvalid()) 7653 return ExprError(); 7654 7655 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern()) 7656 return SemaRef.Owned(E); 7657 7658 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(), 7659 E->getNumExpansions()); 7660} 7661 7662template<typename Derived> 7663ExprResult 7664TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 7665 // If E is not value-dependent, then nothing will change when we transform it. 7666 // Note: This is an instantiation-centric view. 7667 if (!E->isValueDependent()) 7668 return SemaRef.Owned(E); 7669 7670 // Note: None of the implementations of TryExpandParameterPacks can ever 7671 // produce a diagnostic when given only a single unexpanded parameter pack, 7672 // so 7673 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 7674 bool ShouldExpand = false; 7675 bool RetainExpansion = false; 7676 llvm::Optional<unsigned> NumExpansions; 7677 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 7678 Unexpanded, 7679 ShouldExpand, RetainExpansion, 7680 NumExpansions)) 7681 return ExprError(); 7682 7683 if (!ShouldExpand || RetainExpansion) 7684 return SemaRef.Owned(E); 7685 7686 // We now know the length of the parameter pack, so build a new expression 7687 // that stores that length. 7688 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), 7689 E->getPackLoc(), E->getRParenLoc(), 7690 *NumExpansions); 7691} 7692 7693template<typename Derived> 7694ExprResult 7695TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr( 7696 SubstNonTypeTemplateParmPackExpr *E) { 7697 // Default behavior is to do nothing with this transformation. 7698 return SemaRef.Owned(E); 7699} 7700 7701template<typename Derived> 7702ExprResult 7703TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr( 7704 SubstNonTypeTemplateParmExpr *E) { 7705 // Default behavior is to do nothing with this transformation. 7706 return SemaRef.Owned(E); 7707} 7708 7709template<typename Derived> 7710ExprResult 7711TreeTransform<Derived>::TransformMaterializeTemporaryExpr( 7712 MaterializeTemporaryExpr *E) { 7713 return getDerived().TransformExpr(E->GetTemporaryExpr()); 7714} 7715 7716template<typename Derived> 7717ExprResult 7718TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 7719 return SemaRef.Owned(E); 7720} 7721 7722template<typename Derived> 7723ExprResult 7724TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 7725 TypeSourceInfo *EncodedTypeInfo 7726 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 7727 if (!EncodedTypeInfo) 7728 return ExprError(); 7729 7730 if (!getDerived().AlwaysRebuild() && 7731 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 7732 return SemaRef.Owned(E); 7733 7734 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 7735 EncodedTypeInfo, 7736 E->getRParenLoc()); 7737} 7738 7739template<typename Derived> 7740ExprResult TreeTransform<Derived>:: 7741TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 7742 ExprResult result = getDerived().TransformExpr(E->getSubExpr()); 7743 if (result.isInvalid()) return ExprError(); 7744 Expr *subExpr = result.take(); 7745 7746 if (!getDerived().AlwaysRebuild() && 7747 subExpr == E->getSubExpr()) 7748 return SemaRef.Owned(E); 7749 7750 return SemaRef.Owned(new(SemaRef.Context) 7751 ObjCIndirectCopyRestoreExpr(subExpr, E->getType(), E->shouldCopy())); 7752} 7753 7754template<typename Derived> 7755ExprResult TreeTransform<Derived>:: 7756TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 7757 TypeSourceInfo *TSInfo 7758 = getDerived().TransformType(E->getTypeInfoAsWritten()); 7759 if (!TSInfo) 7760 return ExprError(); 7761 7762 ExprResult Result = getDerived().TransformExpr(E->getSubExpr()); 7763 if (Result.isInvalid()) 7764 return ExprError(); 7765 7766 if (!getDerived().AlwaysRebuild() && 7767 TSInfo == E->getTypeInfoAsWritten() && 7768 Result.get() == E->getSubExpr()) 7769 return SemaRef.Owned(E); 7770 7771 return SemaRef.BuildObjCBridgedCast(E->getLParenLoc(), E->getBridgeKind(), 7772 E->getBridgeKeywordLoc(), TSInfo, 7773 Result.get()); 7774} 7775 7776template<typename Derived> 7777ExprResult 7778TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 7779 // Transform arguments. 7780 bool ArgChanged = false; 7781 ASTOwningVector<Expr*> Args(SemaRef); 7782 Args.reserve(E->getNumArgs()); 7783 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 7784 &ArgChanged)) 7785 return ExprError(); 7786 7787 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 7788 // Class message: transform the receiver type. 7789 TypeSourceInfo *ReceiverTypeInfo 7790 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 7791 if (!ReceiverTypeInfo) 7792 return ExprError(); 7793 7794 // If nothing changed, just retain the existing message send. 7795 if (!getDerived().AlwaysRebuild() && 7796 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 7797 return SemaRef.Owned(E); 7798 7799 // Build a new class message send. 7800 SmallVector<SourceLocation, 16> SelLocs; 7801 E->getSelectorLocs(SelLocs); 7802 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 7803 E->getSelector(), 7804 SelLocs, 7805 E->getMethodDecl(), 7806 E->getLeftLoc(), 7807 move_arg(Args), 7808 E->getRightLoc()); 7809 } 7810 7811 // Instance message: transform the receiver 7812 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 7813 "Only class and instance messages may be instantiated"); 7814 ExprResult Receiver 7815 = getDerived().TransformExpr(E->getInstanceReceiver()); 7816 if (Receiver.isInvalid()) 7817 return ExprError(); 7818 7819 // If nothing changed, just retain the existing message send. 7820 if (!getDerived().AlwaysRebuild() && 7821 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 7822 return SemaRef.Owned(E); 7823 7824 // Build a new instance message send. 7825 SmallVector<SourceLocation, 16> SelLocs; 7826 E->getSelectorLocs(SelLocs); 7827 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 7828 E->getSelector(), 7829 SelLocs, 7830 E->getMethodDecl(), 7831 E->getLeftLoc(), 7832 move_arg(Args), 7833 E->getRightLoc()); 7834} 7835 7836template<typename Derived> 7837ExprResult 7838TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 7839 return SemaRef.Owned(E); 7840} 7841 7842template<typename Derived> 7843ExprResult 7844TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 7845 return SemaRef.Owned(E); 7846} 7847 7848template<typename Derived> 7849ExprResult 7850TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 7851 // Transform the base expression. 7852 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7853 if (Base.isInvalid()) 7854 return ExprError(); 7855 7856 // We don't need to transform the ivar; it will never change. 7857 7858 // If nothing changed, just retain the existing expression. 7859 if (!getDerived().AlwaysRebuild() && 7860 Base.get() == E->getBase()) 7861 return SemaRef.Owned(E); 7862 7863 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 7864 E->getLocation(), 7865 E->isArrow(), E->isFreeIvar()); 7866} 7867 7868template<typename Derived> 7869ExprResult 7870TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 7871 // 'super' and types never change. Property never changes. Just 7872 // retain the existing expression. 7873 if (!E->isObjectReceiver()) 7874 return SemaRef.Owned(E); 7875 7876 // Transform the base expression. 7877 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7878 if (Base.isInvalid()) 7879 return ExprError(); 7880 7881 // We don't need to transform the property; it will never change. 7882 7883 // If nothing changed, just retain the existing expression. 7884 if (!getDerived().AlwaysRebuild() && 7885 Base.get() == E->getBase()) 7886 return SemaRef.Owned(E); 7887 7888 if (E->isExplicitProperty()) 7889 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 7890 E->getExplicitProperty(), 7891 E->getLocation()); 7892 7893 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 7894 E->getType(), 7895 E->getImplicitPropertyGetter(), 7896 E->getImplicitPropertySetter(), 7897 E->getLocation()); 7898} 7899 7900template<typename Derived> 7901ExprResult 7902TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 7903 // Transform the base expression. 7904 ExprResult Base = getDerived().TransformExpr(E->getBase()); 7905 if (Base.isInvalid()) 7906 return ExprError(); 7907 7908 // If nothing changed, just retain the existing expression. 7909 if (!getDerived().AlwaysRebuild() && 7910 Base.get() == E->getBase()) 7911 return SemaRef.Owned(E); 7912 7913 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 7914 E->isArrow()); 7915} 7916 7917template<typename Derived> 7918ExprResult 7919TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 7920 bool ArgumentChanged = false; 7921 ASTOwningVector<Expr*> SubExprs(SemaRef); 7922 SubExprs.reserve(E->getNumSubExprs()); 7923 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 7924 SubExprs, &ArgumentChanged)) 7925 return ExprError(); 7926 7927 if (!getDerived().AlwaysRebuild() && 7928 !ArgumentChanged) 7929 return SemaRef.Owned(E); 7930 7931 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 7932 move_arg(SubExprs), 7933 E->getRParenLoc()); 7934} 7935 7936template<typename Derived> 7937ExprResult 7938TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 7939 BlockDecl *oldBlock = E->getBlockDecl(); 7940 7941 SemaRef.ActOnBlockStart(E->getCaretLocation(), /*Scope=*/0); 7942 BlockScopeInfo *blockScope = SemaRef.getCurBlock(); 7943 7944 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic()); 7945 // We built a new blockScopeInfo in call to ActOnBlockStart 7946 // in above, CapturesCXXThis need be set here from the block 7947 // expression. 7948 blockScope->CapturesCXXThis = oldBlock->capturesCXXThis(); 7949 7950 SmallVector<ParmVarDecl*, 4> params; 7951 SmallVector<QualType, 4> paramTypes; 7952 7953 // Parameter substitution. 7954 if (getDerived().TransformFunctionTypeParams(E->getCaretLocation(), 7955 oldBlock->param_begin(), 7956 oldBlock->param_size(), 7957 0, paramTypes, ¶ms)) 7958 return true; 7959 7960 const FunctionType *exprFunctionType = E->getFunctionType(); 7961 QualType exprResultType = exprFunctionType->getResultType(); 7962 if (!exprResultType.isNull()) { 7963 if (!exprResultType->isDependentType()) 7964 blockScope->ReturnType = exprResultType; 7965 else if (exprResultType != getSema().Context.DependentTy) 7966 blockScope->ReturnType = getDerived().TransformType(exprResultType); 7967 } 7968 7969 // If the return type has not been determined yet, leave it as a dependent 7970 // type; it'll get set when we process the body. 7971 if (blockScope->ReturnType.isNull()) 7972 blockScope->ReturnType = getSema().Context.DependentTy; 7973 7974 // Don't allow returning a objc interface by value. 7975 if (blockScope->ReturnType->isObjCObjectType()) { 7976 getSema().Diag(E->getCaretLocation(), 7977 diag::err_object_cannot_be_passed_returned_by_value) 7978 << 0 << blockScope->ReturnType; 7979 return ExprError(); 7980 } 7981 7982 QualType functionType = getDerived().RebuildFunctionProtoType( 7983 blockScope->ReturnType, 7984 paramTypes.data(), 7985 paramTypes.size(), 7986 oldBlock->isVariadic(), 7987 0, RQ_None, 7988 exprFunctionType->getExtInfo()); 7989 blockScope->FunctionType = functionType; 7990 7991 // Set the parameters on the block decl. 7992 if (!params.empty()) 7993 blockScope->TheDecl->setParams(params); 7994 7995 // If the return type wasn't explicitly set, it will have been marked as a 7996 // dependent type (DependentTy); clear out the return type setting so 7997 // we will deduce the return type when type-checking the block's body. 7998 if (blockScope->ReturnType == getSema().Context.DependentTy) 7999 blockScope->ReturnType = QualType(); 8000 8001 // Transform the body 8002 StmtResult body = getDerived().TransformStmt(E->getBody()); 8003 if (body.isInvalid()) 8004 return ExprError(); 8005 8006#ifndef NDEBUG 8007 // In builds with assertions, make sure that we captured everything we 8008 // captured before. 8009 if (!SemaRef.getDiagnostics().hasErrorOccurred()) { 8010 for (BlockDecl::capture_iterator i = oldBlock->capture_begin(), 8011 e = oldBlock->capture_end(); i != e; ++i) { 8012 VarDecl *oldCapture = i->getVariable(); 8013 8014 // Ignore parameter packs. 8015 if (isa<ParmVarDecl>(oldCapture) && 8016 cast<ParmVarDecl>(oldCapture)->isParameterPack()) 8017 continue; 8018 8019 VarDecl *newCapture = 8020 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(), 8021 oldCapture)); 8022 assert(blockScope->CaptureMap.count(newCapture)); 8023 } 8024 } 8025#endif 8026 8027 return SemaRef.ActOnBlockStmtExpr(E->getCaretLocation(), body.get(), 8028 /*Scope=*/0); 8029} 8030 8031template<typename Derived> 8032ExprResult 8033TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 8034 ValueDecl *ND 8035 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 8036 E->getDecl())); 8037 if (!ND) 8038 return ExprError(); 8039 8040 if (!getDerived().AlwaysRebuild() && 8041 ND == E->getDecl()) { 8042 // Mark it referenced in the new context regardless. 8043 // FIXME: this is a bit instantiation-specific. 8044 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 8045 8046 return SemaRef.Owned(E); 8047 } 8048 8049 DeclarationNameInfo NameInfo(E->getDecl()->getDeclName(), E->getLocation()); 8050 return getDerived().RebuildDeclRefExpr(NestedNameSpecifierLoc(), 8051 ND, NameInfo, 0); 8052} 8053 8054template<typename Derived> 8055ExprResult 8056TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) { 8057 llvm_unreachable("Cannot transform asType expressions yet"); 8058} 8059 8060//===----------------------------------------------------------------------===// 8061// Type reconstruction 8062//===----------------------------------------------------------------------===// 8063 8064template<typename Derived> 8065QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 8066 SourceLocation Star) { 8067 return SemaRef.BuildPointerType(PointeeType, Star, 8068 getDerived().getBaseEntity()); 8069} 8070 8071template<typename Derived> 8072QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 8073 SourceLocation Star) { 8074 return SemaRef.BuildBlockPointerType(PointeeType, Star, 8075 getDerived().getBaseEntity()); 8076} 8077 8078template<typename Derived> 8079QualType 8080TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 8081 bool WrittenAsLValue, 8082 SourceLocation Sigil) { 8083 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 8084 Sigil, getDerived().getBaseEntity()); 8085} 8086 8087template<typename Derived> 8088QualType 8089TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 8090 QualType ClassType, 8091 SourceLocation Sigil) { 8092 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 8093 Sigil, getDerived().getBaseEntity()); 8094} 8095 8096template<typename Derived> 8097QualType 8098TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 8099 ArrayType::ArraySizeModifier SizeMod, 8100 const llvm::APInt *Size, 8101 Expr *SizeExpr, 8102 unsigned IndexTypeQuals, 8103 SourceRange BracketsRange) { 8104 if (SizeExpr || !Size) 8105 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 8106 IndexTypeQuals, BracketsRange, 8107 getDerived().getBaseEntity()); 8108 8109 QualType Types[] = { 8110 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 8111 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 8112 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 8113 }; 8114 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 8115 QualType SizeType; 8116 for (unsigned I = 0; I != NumTypes; ++I) 8117 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 8118 SizeType = Types[I]; 8119 break; 8120 } 8121 8122 IntegerLiteral ArraySize(SemaRef.Context, *Size, SizeType, 8123 /*FIXME*/BracketsRange.getBegin()); 8124 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 8125 IndexTypeQuals, BracketsRange, 8126 getDerived().getBaseEntity()); 8127} 8128 8129template<typename Derived> 8130QualType 8131TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 8132 ArrayType::ArraySizeModifier SizeMod, 8133 const llvm::APInt &Size, 8134 unsigned IndexTypeQuals, 8135 SourceRange BracketsRange) { 8136 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 8137 IndexTypeQuals, BracketsRange); 8138} 8139 8140template<typename Derived> 8141QualType 8142TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 8143 ArrayType::ArraySizeModifier SizeMod, 8144 unsigned IndexTypeQuals, 8145 SourceRange BracketsRange) { 8146 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 8147 IndexTypeQuals, BracketsRange); 8148} 8149 8150template<typename Derived> 8151QualType 8152TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 8153 ArrayType::ArraySizeModifier SizeMod, 8154 Expr *SizeExpr, 8155 unsigned IndexTypeQuals, 8156 SourceRange BracketsRange) { 8157 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 8158 SizeExpr, 8159 IndexTypeQuals, BracketsRange); 8160} 8161 8162template<typename Derived> 8163QualType 8164TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 8165 ArrayType::ArraySizeModifier SizeMod, 8166 Expr *SizeExpr, 8167 unsigned IndexTypeQuals, 8168 SourceRange BracketsRange) { 8169 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 8170 SizeExpr, 8171 IndexTypeQuals, BracketsRange); 8172} 8173 8174template<typename Derived> 8175QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 8176 unsigned NumElements, 8177 VectorType::VectorKind VecKind) { 8178 // FIXME: semantic checking! 8179 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 8180} 8181 8182template<typename Derived> 8183QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 8184 unsigned NumElements, 8185 SourceLocation AttributeLoc) { 8186 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 8187 NumElements, true); 8188 IntegerLiteral *VectorSize 8189 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 8190 AttributeLoc); 8191 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 8192} 8193 8194template<typename Derived> 8195QualType 8196TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 8197 Expr *SizeExpr, 8198 SourceLocation AttributeLoc) { 8199 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 8200} 8201 8202template<typename Derived> 8203QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 8204 QualType *ParamTypes, 8205 unsigned NumParamTypes, 8206 bool Variadic, 8207 unsigned Quals, 8208 RefQualifierKind RefQualifier, 8209 const FunctionType::ExtInfo &Info) { 8210 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 8211 Quals, RefQualifier, 8212 getDerived().getBaseLocation(), 8213 getDerived().getBaseEntity(), 8214 Info); 8215} 8216 8217template<typename Derived> 8218QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 8219 return SemaRef.Context.getFunctionNoProtoType(T); 8220} 8221 8222template<typename Derived> 8223QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 8224 assert(D && "no decl found"); 8225 if (D->isInvalidDecl()) return QualType(); 8226 8227 // FIXME: Doesn't account for ObjCInterfaceDecl! 8228 TypeDecl *Ty; 8229 if (isa<UsingDecl>(D)) { 8230 UsingDecl *Using = cast<UsingDecl>(D); 8231 assert(Using->isTypeName() && 8232 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 8233 8234 // A valid resolved using typename decl points to exactly one type decl. 8235 assert(++Using->shadow_begin() == Using->shadow_end()); 8236 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 8237 8238 } else { 8239 assert(isa<UnresolvedUsingTypenameDecl>(D) && 8240 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 8241 Ty = cast<UnresolvedUsingTypenameDecl>(D); 8242 } 8243 8244 return SemaRef.Context.getTypeDeclType(Ty); 8245} 8246 8247template<typename Derived> 8248QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 8249 SourceLocation Loc) { 8250 return SemaRef.BuildTypeofExprType(E, Loc); 8251} 8252 8253template<typename Derived> 8254QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 8255 return SemaRef.Context.getTypeOfType(Underlying); 8256} 8257 8258template<typename Derived> 8259QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 8260 SourceLocation Loc) { 8261 return SemaRef.BuildDecltypeType(E, Loc); 8262} 8263 8264template<typename Derived> 8265QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType, 8266 UnaryTransformType::UTTKind UKind, 8267 SourceLocation Loc) { 8268 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc); 8269} 8270 8271template<typename Derived> 8272QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 8273 TemplateName Template, 8274 SourceLocation TemplateNameLoc, 8275 TemplateArgumentListInfo &TemplateArgs) { 8276 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 8277} 8278 8279template<typename Derived> 8280TemplateName 8281TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 8282 bool TemplateKW, 8283 TemplateDecl *Template) { 8284 return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW, 8285 Template); 8286} 8287 8288template<typename Derived> 8289TemplateName 8290TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 8291 const IdentifierInfo &Name, 8292 SourceLocation NameLoc, 8293 QualType ObjectType, 8294 NamedDecl *FirstQualifierInScope) { 8295 UnqualifiedId TemplateName; 8296 TemplateName.setIdentifier(&Name, NameLoc); 8297 Sema::TemplateTy Template; 8298 getSema().ActOnDependentTemplateName(/*Scope=*/0, 8299 /*FIXME:*/SourceLocation(), 8300 SS, 8301 TemplateName, 8302 ParsedType::make(ObjectType), 8303 /*EnteringContext=*/false, 8304 Template); 8305 return Template.get(); 8306} 8307 8308template<typename Derived> 8309TemplateName 8310TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS, 8311 OverloadedOperatorKind Operator, 8312 SourceLocation NameLoc, 8313 QualType ObjectType) { 8314 UnqualifiedId Name; 8315 // FIXME: Bogus location information. 8316 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc }; 8317 Name.setOperatorFunctionId(NameLoc, Operator, SymbolLocations); 8318 Sema::TemplateTy Template; 8319 getSema().ActOnDependentTemplateName(/*Scope=*/0, 8320 /*FIXME:*/SourceLocation(), 8321 SS, 8322 Name, 8323 ParsedType::make(ObjectType), 8324 /*EnteringContext=*/false, 8325 Template); 8326 return Template.template getAsVal<TemplateName>(); 8327} 8328 8329template<typename Derived> 8330ExprResult 8331TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 8332 SourceLocation OpLoc, 8333 Expr *OrigCallee, 8334 Expr *First, 8335 Expr *Second) { 8336 Expr *Callee = OrigCallee->IgnoreParenCasts(); 8337 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 8338 8339 // Determine whether this should be a builtin operation. 8340 if (Op == OO_Subscript) { 8341 if (!First->getType()->isOverloadableType() && 8342 !Second->getType()->isOverloadableType()) 8343 return getSema().CreateBuiltinArraySubscriptExpr(First, 8344 Callee->getLocStart(), 8345 Second, OpLoc); 8346 } else if (Op == OO_Arrow) { 8347 // -> is never a builtin operation. 8348 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 8349 } else if (Second == 0 || isPostIncDec) { 8350 if (!First->getType()->isOverloadableType()) { 8351 // The argument is not of overloadable type, so try to create a 8352 // built-in unary operation. 8353 UnaryOperatorKind Opc 8354 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 8355 8356 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 8357 } 8358 } else { 8359 if (!First->getType()->isOverloadableType() && 8360 !Second->getType()->isOverloadableType()) { 8361 // Neither of the arguments is an overloadable type, so try to 8362 // create a built-in binary operation. 8363 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 8364 ExprResult Result 8365 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 8366 if (Result.isInvalid()) 8367 return ExprError(); 8368 8369 return move(Result); 8370 } 8371 } 8372 8373 // Compute the transformed set of functions (and function templates) to be 8374 // used during overload resolution. 8375 UnresolvedSet<16> Functions; 8376 8377 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 8378 assert(ULE->requiresADL()); 8379 8380 // FIXME: Do we have to check 8381 // IsAcceptableNonMemberOperatorCandidate for each of these? 8382 Functions.append(ULE->decls_begin(), ULE->decls_end()); 8383 } else { 8384 Functions.addDecl(cast<DeclRefExpr>(Callee)->getDecl()); 8385 } 8386 8387 // Add any functions found via argument-dependent lookup. 8388 Expr *Args[2] = { First, Second }; 8389 unsigned NumArgs = 1 + (Second != 0); 8390 8391 // Create the overloaded operator invocation for unary operators. 8392 if (NumArgs == 1 || isPostIncDec) { 8393 UnaryOperatorKind Opc 8394 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 8395 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 8396 } 8397 8398 if (Op == OO_Subscript) { 8399 SourceLocation LBrace; 8400 SourceLocation RBrace; 8401 8402 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) { 8403 DeclarationNameLoc &NameLoc = DRE->getNameInfo().getInfo(); 8404 LBrace = SourceLocation::getFromRawEncoding( 8405 NameLoc.CXXOperatorName.BeginOpNameLoc); 8406 RBrace = SourceLocation::getFromRawEncoding( 8407 NameLoc.CXXOperatorName.EndOpNameLoc); 8408 } else { 8409 LBrace = Callee->getLocStart(); 8410 RBrace = OpLoc; 8411 } 8412 8413 return SemaRef.CreateOverloadedArraySubscriptExpr(LBrace, RBrace, 8414 First, Second); 8415 } 8416 8417 // Create the overloaded operator invocation for binary operators. 8418 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 8419 ExprResult Result 8420 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 8421 if (Result.isInvalid()) 8422 return ExprError(); 8423 8424 return move(Result); 8425} 8426 8427template<typename Derived> 8428ExprResult 8429TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 8430 SourceLocation OperatorLoc, 8431 bool isArrow, 8432 CXXScopeSpec &SS, 8433 TypeSourceInfo *ScopeType, 8434 SourceLocation CCLoc, 8435 SourceLocation TildeLoc, 8436 PseudoDestructorTypeStorage Destroyed) { 8437 QualType BaseType = Base->getType(); 8438 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 8439 (!isArrow && !BaseType->getAs<RecordType>()) || 8440 (isArrow && BaseType->getAs<PointerType>() && 8441 !BaseType->getAs<PointerType>()->getPointeeType() 8442 ->template getAs<RecordType>())){ 8443 // This pseudo-destructor expression is still a pseudo-destructor. 8444 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 8445 isArrow? tok::arrow : tok::period, 8446 SS, ScopeType, CCLoc, TildeLoc, 8447 Destroyed, 8448 /*FIXME?*/true); 8449 } 8450 8451 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 8452 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 8453 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 8454 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 8455 NameInfo.setNamedTypeInfo(DestroyedType); 8456 8457 // FIXME: the ScopeType should be tacked onto SS. 8458 8459 return getSema().BuildMemberReferenceExpr(Base, BaseType, 8460 OperatorLoc, isArrow, 8461 SS, /*FIXME: FirstQualifier*/ 0, 8462 NameInfo, 8463 /*TemplateArgs*/ 0); 8464} 8465 8466} // end namespace clang 8467 8468#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 8469