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