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