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