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