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