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