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