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