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