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