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