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