TreeTransform.h revision a7fc901a2e39bfe55bfcff5934b2d9fdf9656491
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 ParmVarDecl *OldParm = TL.getArg(i); 3400 3401 QualType NewType; 3402 ParmVarDecl *NewParm; 3403 3404 if (OldParm) { 3405 NewParm = getDerived().TransformFunctionTypeParam(OldParm); 3406 if (!NewParm) 3407 return true; 3408 NewType = NewParm->getType(); 3409 3410 // Deal with the possibility that we don't have a parameter 3411 // declaration for this parameter. 3412 } else { 3413 NewParm = 0; 3414 3415 QualType OldType = T->getArgType(i); 3416 NewType = getDerived().TransformType(OldType); 3417 if (NewType.isNull()) 3418 return true; 3419 } 3420 3421 PTypes.push_back(NewType); 3422 PVars.push_back(NewParm); 3423 } 3424 3425 return false; 3426} 3427 3428template<typename Derived> 3429QualType 3430TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 3431 FunctionProtoTypeLoc TL) { 3432 // Transform the parameters and return type. 3433 // 3434 // We instantiate in source order, with the return type first followed by 3435 // the parameters, because users tend to expect this (even if they shouldn't 3436 // rely on it!). 3437 // 3438 // When the function has a trailing return type, we instantiate the 3439 // parameters before the return type, since the return type can then refer 3440 // to the parameters themselves (via decltype, sizeof, etc.). 3441 // 3442 llvm::SmallVector<QualType, 4> ParamTypes; 3443 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 3444 FunctionProtoType *T = TL.getTypePtr(); 3445 3446 QualType ResultType; 3447 3448 if (TL.getTrailingReturn()) { 3449 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls)) 3450 return QualType(); 3451 3452 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3453 if (ResultType.isNull()) 3454 return QualType(); 3455 } 3456 else { 3457 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3458 if (ResultType.isNull()) 3459 return QualType(); 3460 3461 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls)) 3462 return QualType(); 3463 } 3464 3465 QualType Result = TL.getType(); 3466 if (getDerived().AlwaysRebuild() || 3467 ResultType != T->getResultType() || 3468 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 3469 Result = getDerived().RebuildFunctionProtoType(ResultType, 3470 ParamTypes.data(), 3471 ParamTypes.size(), 3472 T->isVariadic(), 3473 T->getTypeQuals(), 3474 T->getExtInfo()); 3475 if (Result.isNull()) 3476 return QualType(); 3477 } 3478 3479 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 3480 NewTL.setLParenLoc(TL.getLParenLoc()); 3481 NewTL.setRParenLoc(TL.getRParenLoc()); 3482 NewTL.setTrailingReturn(TL.getTrailingReturn()); 3483 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 3484 NewTL.setArg(i, ParamDecls[i]); 3485 3486 return Result; 3487} 3488 3489template<typename Derived> 3490QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 3491 TypeLocBuilder &TLB, 3492 FunctionNoProtoTypeLoc TL) { 3493 FunctionNoProtoType *T = TL.getTypePtr(); 3494 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3495 if (ResultType.isNull()) 3496 return QualType(); 3497 3498 QualType Result = TL.getType(); 3499 if (getDerived().AlwaysRebuild() || 3500 ResultType != T->getResultType()) 3501 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 3502 3503 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 3504 NewTL.setLParenLoc(TL.getLParenLoc()); 3505 NewTL.setRParenLoc(TL.getRParenLoc()); 3506 NewTL.setTrailingReturn(false); 3507 3508 return Result; 3509} 3510 3511template<typename Derived> QualType 3512TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 3513 UnresolvedUsingTypeLoc TL) { 3514 UnresolvedUsingType *T = TL.getTypePtr(); 3515 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 3516 if (!D) 3517 return QualType(); 3518 3519 QualType Result = TL.getType(); 3520 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 3521 Result = getDerived().RebuildUnresolvedUsingType(D); 3522 if (Result.isNull()) 3523 return QualType(); 3524 } 3525 3526 // We might get an arbitrary type spec type back. We should at 3527 // least always get a type spec type, though. 3528 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 3529 NewTL.setNameLoc(TL.getNameLoc()); 3530 3531 return Result; 3532} 3533 3534template<typename Derived> 3535QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 3536 TypedefTypeLoc TL) { 3537 TypedefType *T = TL.getTypePtr(); 3538 TypedefDecl *Typedef 3539 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3540 T->getDecl())); 3541 if (!Typedef) 3542 return QualType(); 3543 3544 QualType Result = TL.getType(); 3545 if (getDerived().AlwaysRebuild() || 3546 Typedef != T->getDecl()) { 3547 Result = getDerived().RebuildTypedefType(Typedef); 3548 if (Result.isNull()) 3549 return QualType(); 3550 } 3551 3552 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 3553 NewTL.setNameLoc(TL.getNameLoc()); 3554 3555 return Result; 3556} 3557 3558template<typename Derived> 3559QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 3560 TypeOfExprTypeLoc TL) { 3561 // typeof expressions are not potentially evaluated contexts 3562 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3563 3564 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 3565 if (E.isInvalid()) 3566 return QualType(); 3567 3568 QualType Result = TL.getType(); 3569 if (getDerived().AlwaysRebuild() || 3570 E.get() != TL.getUnderlyingExpr()) { 3571 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 3572 if (Result.isNull()) 3573 return QualType(); 3574 } 3575 else E.take(); 3576 3577 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 3578 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3579 NewTL.setLParenLoc(TL.getLParenLoc()); 3580 NewTL.setRParenLoc(TL.getRParenLoc()); 3581 3582 return Result; 3583} 3584 3585template<typename Derived> 3586QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 3587 TypeOfTypeLoc TL) { 3588 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 3589 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 3590 if (!New_Under_TI) 3591 return QualType(); 3592 3593 QualType Result = TL.getType(); 3594 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 3595 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 3596 if (Result.isNull()) 3597 return QualType(); 3598 } 3599 3600 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 3601 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3602 NewTL.setLParenLoc(TL.getLParenLoc()); 3603 NewTL.setRParenLoc(TL.getRParenLoc()); 3604 NewTL.setUnderlyingTInfo(New_Under_TI); 3605 3606 return Result; 3607} 3608 3609template<typename Derived> 3610QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 3611 DecltypeTypeLoc TL) { 3612 DecltypeType *T = TL.getTypePtr(); 3613 3614 // decltype expressions are not potentially evaluated contexts 3615 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3616 3617 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 3618 if (E.isInvalid()) 3619 return QualType(); 3620 3621 QualType Result = TL.getType(); 3622 if (getDerived().AlwaysRebuild() || 3623 E.get() != T->getUnderlyingExpr()) { 3624 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 3625 if (Result.isNull()) 3626 return QualType(); 3627 } 3628 else E.take(); 3629 3630 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 3631 NewTL.setNameLoc(TL.getNameLoc()); 3632 3633 return Result; 3634} 3635 3636template<typename Derived> 3637QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 3638 RecordTypeLoc TL) { 3639 RecordType *T = TL.getTypePtr(); 3640 RecordDecl *Record 3641 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3642 T->getDecl())); 3643 if (!Record) 3644 return QualType(); 3645 3646 QualType Result = TL.getType(); 3647 if (getDerived().AlwaysRebuild() || 3648 Record != T->getDecl()) { 3649 Result = getDerived().RebuildRecordType(Record); 3650 if (Result.isNull()) 3651 return QualType(); 3652 } 3653 3654 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 3655 NewTL.setNameLoc(TL.getNameLoc()); 3656 3657 return Result; 3658} 3659 3660template<typename Derived> 3661QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 3662 EnumTypeLoc TL) { 3663 EnumType *T = TL.getTypePtr(); 3664 EnumDecl *Enum 3665 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3666 T->getDecl())); 3667 if (!Enum) 3668 return QualType(); 3669 3670 QualType Result = TL.getType(); 3671 if (getDerived().AlwaysRebuild() || 3672 Enum != T->getDecl()) { 3673 Result = getDerived().RebuildEnumType(Enum); 3674 if (Result.isNull()) 3675 return QualType(); 3676 } 3677 3678 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 3679 NewTL.setNameLoc(TL.getNameLoc()); 3680 3681 return Result; 3682} 3683 3684template<typename Derived> 3685QualType TreeTransform<Derived>::TransformInjectedClassNameType( 3686 TypeLocBuilder &TLB, 3687 InjectedClassNameTypeLoc TL) { 3688 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 3689 TL.getTypePtr()->getDecl()); 3690 if (!D) return QualType(); 3691 3692 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 3693 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 3694 return T; 3695} 3696 3697 3698template<typename Derived> 3699QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 3700 TypeLocBuilder &TLB, 3701 TemplateTypeParmTypeLoc TL) { 3702 return TransformTypeSpecType(TLB, TL); 3703} 3704 3705template<typename Derived> 3706QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 3707 TypeLocBuilder &TLB, 3708 SubstTemplateTypeParmTypeLoc TL) { 3709 return TransformTypeSpecType(TLB, TL); 3710} 3711 3712template<typename Derived> 3713QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3714 TypeLocBuilder &TLB, 3715 TemplateSpecializationTypeLoc TL) { 3716 const TemplateSpecializationType *T = TL.getTypePtr(); 3717 3718 TemplateName Template 3719 = getDerived().TransformTemplateName(T->getTemplateName()); 3720 if (Template.isNull()) 3721 return QualType(); 3722 3723 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 3724} 3725 3726namespace { 3727 /// \brief Simple iterator that traverses the template arguments in a 3728 /// container that provides a \c getArgLoc() member function. 3729 /// 3730 /// This iterator is intended to be used with the iterator form of 3731 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 3732 template<typename ArgLocContainer> 3733 class TemplateArgumentLocContainerIterator { 3734 ArgLocContainer *Container; 3735 unsigned Index; 3736 3737 public: 3738 typedef TemplateArgumentLoc value_type; 3739 typedef TemplateArgumentLoc reference; 3740 typedef int difference_type; 3741 typedef std::input_iterator_tag iterator_category; 3742 3743 class pointer { 3744 TemplateArgumentLoc Arg; 3745 3746 public: 3747 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3748 3749 const TemplateArgumentLoc *operator->() const { 3750 return &Arg; 3751 } 3752 }; 3753 3754 3755 TemplateArgumentLocContainerIterator() {} 3756 3757 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 3758 unsigned Index) 3759 : Container(&Container), Index(Index) { } 3760 3761 TemplateArgumentLocContainerIterator &operator++() { 3762 ++Index; 3763 return *this; 3764 } 3765 3766 TemplateArgumentLocContainerIterator operator++(int) { 3767 TemplateArgumentLocContainerIterator Old(*this); 3768 ++(*this); 3769 return Old; 3770 } 3771 3772 TemplateArgumentLoc operator*() const { 3773 return Container->getArgLoc(Index); 3774 } 3775 3776 pointer operator->() const { 3777 return pointer(Container->getArgLoc(Index)); 3778 } 3779 3780 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 3781 const TemplateArgumentLocContainerIterator &Y) { 3782 return X.Container == Y.Container && X.Index == Y.Index; 3783 } 3784 3785 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 3786 const TemplateArgumentLocContainerIterator &Y) { 3787 return !(X == Y); 3788 } 3789 }; 3790} 3791 3792 3793template <typename Derived> 3794QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3795 TypeLocBuilder &TLB, 3796 TemplateSpecializationTypeLoc TL, 3797 TemplateName Template) { 3798 TemplateArgumentListInfo NewTemplateArgs; 3799 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 3800 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 3801 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 3802 ArgIterator; 3803 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 3804 ArgIterator(TL, TL.getNumArgs()), 3805 NewTemplateArgs)) 3806 return QualType(); 3807 3808 // FIXME: maybe don't rebuild if all the template arguments are the same. 3809 3810 QualType Result = 3811 getDerived().RebuildTemplateSpecializationType(Template, 3812 TL.getTemplateNameLoc(), 3813 NewTemplateArgs); 3814 3815 if (!Result.isNull()) { 3816 TemplateSpecializationTypeLoc NewTL 3817 = TLB.push<TemplateSpecializationTypeLoc>(Result); 3818 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 3819 NewTL.setLAngleLoc(TL.getLAngleLoc()); 3820 NewTL.setRAngleLoc(TL.getRAngleLoc()); 3821 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 3822 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 3823 } 3824 3825 return Result; 3826} 3827 3828template<typename Derived> 3829QualType 3830TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 3831 ElaboratedTypeLoc TL) { 3832 ElaboratedType *T = TL.getTypePtr(); 3833 3834 NestedNameSpecifier *NNS = 0; 3835 // NOTE: the qualifier in an ElaboratedType is optional. 3836 if (T->getQualifier() != 0) { 3837 NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3838 TL.getQualifierRange()); 3839 if (!NNS) 3840 return QualType(); 3841 } 3842 3843 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 3844 if (NamedT.isNull()) 3845 return QualType(); 3846 3847 QualType Result = TL.getType(); 3848 if (getDerived().AlwaysRebuild() || 3849 NNS != T->getQualifier() || 3850 NamedT != T->getNamedType()) { 3851 Result = getDerived().RebuildElaboratedType(TL.getKeywordLoc(), 3852 T->getKeyword(), NNS, NamedT); 3853 if (Result.isNull()) 3854 return QualType(); 3855 } 3856 3857 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3858 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3859 NewTL.setQualifierRange(TL.getQualifierRange()); 3860 3861 return Result; 3862} 3863 3864template<typename Derived> 3865QualType 3866TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 3867 ParenTypeLoc TL) { 3868 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 3869 if (Inner.isNull()) 3870 return QualType(); 3871 3872 QualType Result = TL.getType(); 3873 if (getDerived().AlwaysRebuild() || 3874 Inner != TL.getInnerLoc().getType()) { 3875 Result = getDerived().RebuildParenType(Inner); 3876 if (Result.isNull()) 3877 return QualType(); 3878 } 3879 3880 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 3881 NewTL.setLParenLoc(TL.getLParenLoc()); 3882 NewTL.setRParenLoc(TL.getRParenLoc()); 3883 return Result; 3884} 3885 3886template<typename Derived> 3887QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 3888 DependentNameTypeLoc TL) { 3889 DependentNameType *T = TL.getTypePtr(); 3890 3891 NestedNameSpecifier *NNS 3892 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3893 TL.getQualifierRange()); 3894 if (!NNS) 3895 return QualType(); 3896 3897 QualType Result 3898 = getDerived().RebuildDependentNameType(T->getKeyword(), NNS, 3899 T->getIdentifier(), 3900 TL.getKeywordLoc(), 3901 TL.getQualifierRange(), 3902 TL.getNameLoc()); 3903 if (Result.isNull()) 3904 return QualType(); 3905 3906 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 3907 QualType NamedT = ElabT->getNamedType(); 3908 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 3909 3910 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3911 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3912 NewTL.setQualifierRange(TL.getQualifierRange()); 3913 } else { 3914 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 3915 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3916 NewTL.setQualifierRange(TL.getQualifierRange()); 3917 NewTL.setNameLoc(TL.getNameLoc()); 3918 } 3919 return Result; 3920} 3921 3922template<typename Derived> 3923QualType TreeTransform<Derived>:: 3924 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 3925 DependentTemplateSpecializationTypeLoc TL) { 3926 DependentTemplateSpecializationType *T = TL.getTypePtr(); 3927 3928 NestedNameSpecifier *NNS 3929 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3930 TL.getQualifierRange()); 3931 if (!NNS) 3932 return QualType(); 3933 3934 return getDerived() 3935 .TransformDependentTemplateSpecializationType(TLB, TL, NNS); 3936} 3937 3938template<typename Derived> 3939QualType TreeTransform<Derived>:: 3940 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 3941 DependentTemplateSpecializationTypeLoc TL, 3942 NestedNameSpecifier *NNS) { 3943 DependentTemplateSpecializationType *T = TL.getTypePtr(); 3944 3945 TemplateArgumentListInfo NewTemplateArgs; 3946 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 3947 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 3948 3949 typedef TemplateArgumentLocContainerIterator< 3950 DependentTemplateSpecializationTypeLoc> ArgIterator; 3951 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 3952 ArgIterator(TL, TL.getNumArgs()), 3953 NewTemplateArgs)) 3954 return QualType(); 3955 3956 QualType Result 3957 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 3958 NNS, 3959 TL.getQualifierRange(), 3960 T->getIdentifier(), 3961 TL.getNameLoc(), 3962 NewTemplateArgs); 3963 if (Result.isNull()) 3964 return QualType(); 3965 3966 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 3967 QualType NamedT = ElabT->getNamedType(); 3968 3969 // Copy information relevant to the template specialization. 3970 TemplateSpecializationTypeLoc NamedTL 3971 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 3972 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 3973 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 3974 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3975 NamedTL.setArgLocInfo(I, TL.getArgLocInfo(I)); 3976 3977 // Copy information relevant to the elaborated type. 3978 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3979 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3980 NewTL.setQualifierRange(TL.getQualifierRange()); 3981 } else { 3982 TypeLoc NewTL(Result, TL.getOpaqueData()); 3983 TLB.pushFullCopy(NewTL); 3984 } 3985 return Result; 3986} 3987 3988template<typename Derived> 3989QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 3990 PackExpansionTypeLoc TL) { 3991 // FIXME: Implement! 3992 getSema().Diag(TL.getEllipsisLoc(), 3993 diag::err_pack_expansion_instantiation_unsupported); 3994 return QualType(); 3995} 3996 3997template<typename Derived> 3998QualType 3999TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 4000 ObjCInterfaceTypeLoc TL) { 4001 // ObjCInterfaceType is never dependent. 4002 TLB.pushFullCopy(TL); 4003 return TL.getType(); 4004} 4005 4006template<typename Derived> 4007QualType 4008TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 4009 ObjCObjectTypeLoc TL) { 4010 // ObjCObjectType is never dependent. 4011 TLB.pushFullCopy(TL); 4012 return TL.getType(); 4013} 4014 4015template<typename Derived> 4016QualType 4017TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 4018 ObjCObjectPointerTypeLoc TL) { 4019 // ObjCObjectPointerType is never dependent. 4020 TLB.pushFullCopy(TL); 4021 return TL.getType(); 4022} 4023 4024//===----------------------------------------------------------------------===// 4025// Statement transformation 4026//===----------------------------------------------------------------------===// 4027template<typename Derived> 4028StmtResult 4029TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 4030 return SemaRef.Owned(S); 4031} 4032 4033template<typename Derived> 4034StmtResult 4035TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 4036 return getDerived().TransformCompoundStmt(S, false); 4037} 4038 4039template<typename Derived> 4040StmtResult 4041TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 4042 bool IsStmtExpr) { 4043 bool SubStmtInvalid = false; 4044 bool SubStmtChanged = false; 4045 ASTOwningVector<Stmt*> Statements(getSema()); 4046 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 4047 B != BEnd; ++B) { 4048 StmtResult Result = getDerived().TransformStmt(*B); 4049 if (Result.isInvalid()) { 4050 // Immediately fail if this was a DeclStmt, since it's very 4051 // likely that this will cause problems for future statements. 4052 if (isa<DeclStmt>(*B)) 4053 return StmtError(); 4054 4055 // Otherwise, just keep processing substatements and fail later. 4056 SubStmtInvalid = true; 4057 continue; 4058 } 4059 4060 SubStmtChanged = SubStmtChanged || Result.get() != *B; 4061 Statements.push_back(Result.takeAs<Stmt>()); 4062 } 4063 4064 if (SubStmtInvalid) 4065 return StmtError(); 4066 4067 if (!getDerived().AlwaysRebuild() && 4068 !SubStmtChanged) 4069 return SemaRef.Owned(S); 4070 4071 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 4072 move_arg(Statements), 4073 S->getRBracLoc(), 4074 IsStmtExpr); 4075} 4076 4077template<typename Derived> 4078StmtResult 4079TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 4080 ExprResult LHS, RHS; 4081 { 4082 // The case value expressions are not potentially evaluated. 4083 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4084 4085 // Transform the left-hand case value. 4086 LHS = getDerived().TransformExpr(S->getLHS()); 4087 if (LHS.isInvalid()) 4088 return StmtError(); 4089 4090 // Transform the right-hand case value (for the GNU case-range extension). 4091 RHS = getDerived().TransformExpr(S->getRHS()); 4092 if (RHS.isInvalid()) 4093 return StmtError(); 4094 } 4095 4096 // Build the case statement. 4097 // Case statements are always rebuilt so that they will attached to their 4098 // transformed switch statement. 4099 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 4100 LHS.get(), 4101 S->getEllipsisLoc(), 4102 RHS.get(), 4103 S->getColonLoc()); 4104 if (Case.isInvalid()) 4105 return StmtError(); 4106 4107 // Transform the statement following the case 4108 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4109 if (SubStmt.isInvalid()) 4110 return StmtError(); 4111 4112 // Attach the body to the case statement 4113 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 4114} 4115 4116template<typename Derived> 4117StmtResult 4118TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 4119 // Transform the statement following the default case 4120 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4121 if (SubStmt.isInvalid()) 4122 return StmtError(); 4123 4124 // Default statements are always rebuilt 4125 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 4126 SubStmt.get()); 4127} 4128 4129template<typename Derived> 4130StmtResult 4131TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 4132 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4133 if (SubStmt.isInvalid()) 4134 return StmtError(); 4135 4136 // FIXME: Pass the real colon location in. 4137 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 4138 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 4139 SubStmt.get(), S->HasUnusedAttribute()); 4140} 4141 4142template<typename Derived> 4143StmtResult 4144TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 4145 // Transform the condition 4146 ExprResult Cond; 4147 VarDecl *ConditionVar = 0; 4148 if (S->getConditionVariable()) { 4149 ConditionVar 4150 = cast_or_null<VarDecl>( 4151 getDerived().TransformDefinition( 4152 S->getConditionVariable()->getLocation(), 4153 S->getConditionVariable())); 4154 if (!ConditionVar) 4155 return StmtError(); 4156 } else { 4157 Cond = getDerived().TransformExpr(S->getCond()); 4158 4159 if (Cond.isInvalid()) 4160 return StmtError(); 4161 4162 // Convert the condition to a boolean value. 4163 if (S->getCond()) { 4164 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), 4165 Cond.get()); 4166 if (CondE.isInvalid()) 4167 return StmtError(); 4168 4169 Cond = CondE.get(); 4170 } 4171 } 4172 4173 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4174 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4175 return StmtError(); 4176 4177 // Transform the "then" branch. 4178 StmtResult Then = getDerived().TransformStmt(S->getThen()); 4179 if (Then.isInvalid()) 4180 return StmtError(); 4181 4182 // Transform the "else" branch. 4183 StmtResult Else = getDerived().TransformStmt(S->getElse()); 4184 if (Else.isInvalid()) 4185 return StmtError(); 4186 4187 if (!getDerived().AlwaysRebuild() && 4188 FullCond.get() == S->getCond() && 4189 ConditionVar == S->getConditionVariable() && 4190 Then.get() == S->getThen() && 4191 Else.get() == S->getElse()) 4192 return SemaRef.Owned(S); 4193 4194 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 4195 Then.get(), 4196 S->getElseLoc(), Else.get()); 4197} 4198 4199template<typename Derived> 4200StmtResult 4201TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 4202 // Transform the condition. 4203 ExprResult Cond; 4204 VarDecl *ConditionVar = 0; 4205 if (S->getConditionVariable()) { 4206 ConditionVar 4207 = cast_or_null<VarDecl>( 4208 getDerived().TransformDefinition( 4209 S->getConditionVariable()->getLocation(), 4210 S->getConditionVariable())); 4211 if (!ConditionVar) 4212 return StmtError(); 4213 } else { 4214 Cond = getDerived().TransformExpr(S->getCond()); 4215 4216 if (Cond.isInvalid()) 4217 return StmtError(); 4218 } 4219 4220 // Rebuild the switch statement. 4221 StmtResult Switch 4222 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 4223 ConditionVar); 4224 if (Switch.isInvalid()) 4225 return StmtError(); 4226 4227 // Transform the body of the switch statement. 4228 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4229 if (Body.isInvalid()) 4230 return StmtError(); 4231 4232 // Complete the switch statement. 4233 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 4234 Body.get()); 4235} 4236 4237template<typename Derived> 4238StmtResult 4239TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 4240 // Transform the condition 4241 ExprResult Cond; 4242 VarDecl *ConditionVar = 0; 4243 if (S->getConditionVariable()) { 4244 ConditionVar 4245 = cast_or_null<VarDecl>( 4246 getDerived().TransformDefinition( 4247 S->getConditionVariable()->getLocation(), 4248 S->getConditionVariable())); 4249 if (!ConditionVar) 4250 return StmtError(); 4251 } else { 4252 Cond = getDerived().TransformExpr(S->getCond()); 4253 4254 if (Cond.isInvalid()) 4255 return StmtError(); 4256 4257 if (S->getCond()) { 4258 // Convert the condition to a boolean value. 4259 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), 4260 Cond.get()); 4261 if (CondE.isInvalid()) 4262 return StmtError(); 4263 Cond = CondE; 4264 } 4265 } 4266 4267 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4268 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4269 return StmtError(); 4270 4271 // Transform the body 4272 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4273 if (Body.isInvalid()) 4274 return StmtError(); 4275 4276 if (!getDerived().AlwaysRebuild() && 4277 FullCond.get() == S->getCond() && 4278 ConditionVar == S->getConditionVariable() && 4279 Body.get() == S->getBody()) 4280 return Owned(S); 4281 4282 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 4283 ConditionVar, Body.get()); 4284} 4285 4286template<typename Derived> 4287StmtResult 4288TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 4289 // Transform the body 4290 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4291 if (Body.isInvalid()) 4292 return StmtError(); 4293 4294 // Transform the condition 4295 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 4296 if (Cond.isInvalid()) 4297 return StmtError(); 4298 4299 if (!getDerived().AlwaysRebuild() && 4300 Cond.get() == S->getCond() && 4301 Body.get() == S->getBody()) 4302 return SemaRef.Owned(S); 4303 4304 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 4305 /*FIXME:*/S->getWhileLoc(), Cond.get(), 4306 S->getRParenLoc()); 4307} 4308 4309template<typename Derived> 4310StmtResult 4311TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 4312 // Transform the initialization statement 4313 StmtResult Init = getDerived().TransformStmt(S->getInit()); 4314 if (Init.isInvalid()) 4315 return StmtError(); 4316 4317 // Transform the condition 4318 ExprResult Cond; 4319 VarDecl *ConditionVar = 0; 4320 if (S->getConditionVariable()) { 4321 ConditionVar 4322 = cast_or_null<VarDecl>( 4323 getDerived().TransformDefinition( 4324 S->getConditionVariable()->getLocation(), 4325 S->getConditionVariable())); 4326 if (!ConditionVar) 4327 return StmtError(); 4328 } else { 4329 Cond = getDerived().TransformExpr(S->getCond()); 4330 4331 if (Cond.isInvalid()) 4332 return StmtError(); 4333 4334 if (S->getCond()) { 4335 // Convert the condition to a boolean value. 4336 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), 4337 Cond.get()); 4338 if (CondE.isInvalid()) 4339 return StmtError(); 4340 4341 Cond = CondE.get(); 4342 } 4343 } 4344 4345 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4346 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4347 return StmtError(); 4348 4349 // Transform the increment 4350 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 4351 if (Inc.isInvalid()) 4352 return StmtError(); 4353 4354 Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc.get())); 4355 if (S->getInc() && !FullInc.get()) 4356 return StmtError(); 4357 4358 // Transform the body 4359 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4360 if (Body.isInvalid()) 4361 return StmtError(); 4362 4363 if (!getDerived().AlwaysRebuild() && 4364 Init.get() == S->getInit() && 4365 FullCond.get() == S->getCond() && 4366 Inc.get() == S->getInc() && 4367 Body.get() == S->getBody()) 4368 return SemaRef.Owned(S); 4369 4370 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 4371 Init.get(), FullCond, ConditionVar, 4372 FullInc, S->getRParenLoc(), Body.get()); 4373} 4374 4375template<typename Derived> 4376StmtResult 4377TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 4378 // Goto statements must always be rebuilt, to resolve the label. 4379 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 4380 S->getLabel()); 4381} 4382 4383template<typename Derived> 4384StmtResult 4385TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 4386 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 4387 if (Target.isInvalid()) 4388 return StmtError(); 4389 4390 if (!getDerived().AlwaysRebuild() && 4391 Target.get() == S->getTarget()) 4392 return SemaRef.Owned(S); 4393 4394 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 4395 Target.get()); 4396} 4397 4398template<typename Derived> 4399StmtResult 4400TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 4401 return SemaRef.Owned(S); 4402} 4403 4404template<typename Derived> 4405StmtResult 4406TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 4407 return SemaRef.Owned(S); 4408} 4409 4410template<typename Derived> 4411StmtResult 4412TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 4413 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 4414 if (Result.isInvalid()) 4415 return StmtError(); 4416 4417 // FIXME: We always rebuild the return statement because there is no way 4418 // to tell whether the return type of the function has changed. 4419 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 4420} 4421 4422template<typename Derived> 4423StmtResult 4424TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 4425 bool DeclChanged = false; 4426 llvm::SmallVector<Decl *, 4> Decls; 4427 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 4428 D != DEnd; ++D) { 4429 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 4430 *D); 4431 if (!Transformed) 4432 return StmtError(); 4433 4434 if (Transformed != *D) 4435 DeclChanged = true; 4436 4437 Decls.push_back(Transformed); 4438 } 4439 4440 if (!getDerived().AlwaysRebuild() && !DeclChanged) 4441 return SemaRef.Owned(S); 4442 4443 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 4444 S->getStartLoc(), S->getEndLoc()); 4445} 4446 4447template<typename Derived> 4448StmtResult 4449TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 4450 assert(false && "SwitchCase is abstract and cannot be transformed"); 4451 return SemaRef.Owned(S); 4452} 4453 4454template<typename Derived> 4455StmtResult 4456TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 4457 4458 ASTOwningVector<Expr*> Constraints(getSema()); 4459 ASTOwningVector<Expr*> Exprs(getSema()); 4460 llvm::SmallVector<IdentifierInfo *, 4> Names; 4461 4462 ExprResult AsmString; 4463 ASTOwningVector<Expr*> Clobbers(getSema()); 4464 4465 bool ExprsChanged = false; 4466 4467 // Go through the outputs. 4468 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 4469 Names.push_back(S->getOutputIdentifier(I)); 4470 4471 // No need to transform the constraint literal. 4472 Constraints.push_back(S->getOutputConstraintLiteral(I)); 4473 4474 // Transform the output expr. 4475 Expr *OutputExpr = S->getOutputExpr(I); 4476 ExprResult Result = getDerived().TransformExpr(OutputExpr); 4477 if (Result.isInvalid()) 4478 return StmtError(); 4479 4480 ExprsChanged |= Result.get() != OutputExpr; 4481 4482 Exprs.push_back(Result.get()); 4483 } 4484 4485 // Go through the inputs. 4486 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 4487 Names.push_back(S->getInputIdentifier(I)); 4488 4489 // No need to transform the constraint literal. 4490 Constraints.push_back(S->getInputConstraintLiteral(I)); 4491 4492 // Transform the input expr. 4493 Expr *InputExpr = S->getInputExpr(I); 4494 ExprResult Result = getDerived().TransformExpr(InputExpr); 4495 if (Result.isInvalid()) 4496 return StmtError(); 4497 4498 ExprsChanged |= Result.get() != InputExpr; 4499 4500 Exprs.push_back(Result.get()); 4501 } 4502 4503 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 4504 return SemaRef.Owned(S); 4505 4506 // Go through the clobbers. 4507 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 4508 Clobbers.push_back(S->getClobber(I)); 4509 4510 // No need to transform the asm string literal. 4511 AsmString = SemaRef.Owned(S->getAsmString()); 4512 4513 return getDerived().RebuildAsmStmt(S->getAsmLoc(), 4514 S->isSimple(), 4515 S->isVolatile(), 4516 S->getNumOutputs(), 4517 S->getNumInputs(), 4518 Names.data(), 4519 move_arg(Constraints), 4520 move_arg(Exprs), 4521 AsmString.get(), 4522 move_arg(Clobbers), 4523 S->getRParenLoc(), 4524 S->isMSAsm()); 4525} 4526 4527 4528template<typename Derived> 4529StmtResult 4530TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 4531 // Transform the body of the @try. 4532 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 4533 if (TryBody.isInvalid()) 4534 return StmtError(); 4535 4536 // Transform the @catch statements (if present). 4537 bool AnyCatchChanged = false; 4538 ASTOwningVector<Stmt*> CatchStmts(SemaRef); 4539 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 4540 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 4541 if (Catch.isInvalid()) 4542 return StmtError(); 4543 if (Catch.get() != S->getCatchStmt(I)) 4544 AnyCatchChanged = true; 4545 CatchStmts.push_back(Catch.release()); 4546 } 4547 4548 // Transform the @finally statement (if present). 4549 StmtResult Finally; 4550 if (S->getFinallyStmt()) { 4551 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 4552 if (Finally.isInvalid()) 4553 return StmtError(); 4554 } 4555 4556 // If nothing changed, just retain this statement. 4557 if (!getDerived().AlwaysRebuild() && 4558 TryBody.get() == S->getTryBody() && 4559 !AnyCatchChanged && 4560 Finally.get() == S->getFinallyStmt()) 4561 return SemaRef.Owned(S); 4562 4563 // Build a new statement. 4564 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 4565 move_arg(CatchStmts), Finally.get()); 4566} 4567 4568template<typename Derived> 4569StmtResult 4570TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 4571 // Transform the @catch parameter, if there is one. 4572 VarDecl *Var = 0; 4573 if (VarDecl *FromVar = S->getCatchParamDecl()) { 4574 TypeSourceInfo *TSInfo = 0; 4575 if (FromVar->getTypeSourceInfo()) { 4576 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 4577 if (!TSInfo) 4578 return StmtError(); 4579 } 4580 4581 QualType T; 4582 if (TSInfo) 4583 T = TSInfo->getType(); 4584 else { 4585 T = getDerived().TransformType(FromVar->getType()); 4586 if (T.isNull()) 4587 return StmtError(); 4588 } 4589 4590 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 4591 if (!Var) 4592 return StmtError(); 4593 } 4594 4595 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 4596 if (Body.isInvalid()) 4597 return StmtError(); 4598 4599 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 4600 S->getRParenLoc(), 4601 Var, Body.get()); 4602} 4603 4604template<typename Derived> 4605StmtResult 4606TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 4607 // Transform the body. 4608 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 4609 if (Body.isInvalid()) 4610 return StmtError(); 4611 4612 // If nothing changed, just retain this statement. 4613 if (!getDerived().AlwaysRebuild() && 4614 Body.get() == S->getFinallyBody()) 4615 return SemaRef.Owned(S); 4616 4617 // Build a new statement. 4618 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 4619 Body.get()); 4620} 4621 4622template<typename Derived> 4623StmtResult 4624TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 4625 ExprResult Operand; 4626 if (S->getThrowExpr()) { 4627 Operand = getDerived().TransformExpr(S->getThrowExpr()); 4628 if (Operand.isInvalid()) 4629 return StmtError(); 4630 } 4631 4632 if (!getDerived().AlwaysRebuild() && 4633 Operand.get() == S->getThrowExpr()) 4634 return getSema().Owned(S); 4635 4636 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 4637} 4638 4639template<typename Derived> 4640StmtResult 4641TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 4642 ObjCAtSynchronizedStmt *S) { 4643 // Transform the object we are locking. 4644 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 4645 if (Object.isInvalid()) 4646 return StmtError(); 4647 4648 // Transform the body. 4649 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 4650 if (Body.isInvalid()) 4651 return StmtError(); 4652 4653 // If nothing change, just retain the current statement. 4654 if (!getDerived().AlwaysRebuild() && 4655 Object.get() == S->getSynchExpr() && 4656 Body.get() == S->getSynchBody()) 4657 return SemaRef.Owned(S); 4658 4659 // Build a new statement. 4660 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 4661 Object.get(), Body.get()); 4662} 4663 4664template<typename Derived> 4665StmtResult 4666TreeTransform<Derived>::TransformObjCForCollectionStmt( 4667 ObjCForCollectionStmt *S) { 4668 // Transform the element statement. 4669 StmtResult Element = getDerived().TransformStmt(S->getElement()); 4670 if (Element.isInvalid()) 4671 return StmtError(); 4672 4673 // Transform the collection expression. 4674 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 4675 if (Collection.isInvalid()) 4676 return StmtError(); 4677 4678 // Transform the body. 4679 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4680 if (Body.isInvalid()) 4681 return StmtError(); 4682 4683 // If nothing changed, just retain this statement. 4684 if (!getDerived().AlwaysRebuild() && 4685 Element.get() == S->getElement() && 4686 Collection.get() == S->getCollection() && 4687 Body.get() == S->getBody()) 4688 return SemaRef.Owned(S); 4689 4690 // Build a new statement. 4691 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 4692 /*FIXME:*/S->getForLoc(), 4693 Element.get(), 4694 Collection.get(), 4695 S->getRParenLoc(), 4696 Body.get()); 4697} 4698 4699 4700template<typename Derived> 4701StmtResult 4702TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 4703 // Transform the exception declaration, if any. 4704 VarDecl *Var = 0; 4705 if (S->getExceptionDecl()) { 4706 VarDecl *ExceptionDecl = S->getExceptionDecl(); 4707 TypeSourceInfo *T = getDerived().TransformType( 4708 ExceptionDecl->getTypeSourceInfo()); 4709 if (!T) 4710 return StmtError(); 4711 4712 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, 4713 ExceptionDecl->getIdentifier(), 4714 ExceptionDecl->getLocation()); 4715 if (!Var || Var->isInvalidDecl()) 4716 return StmtError(); 4717 } 4718 4719 // Transform the actual exception handler. 4720 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 4721 if (Handler.isInvalid()) 4722 return StmtError(); 4723 4724 if (!getDerived().AlwaysRebuild() && 4725 !Var && 4726 Handler.get() == S->getHandlerBlock()) 4727 return SemaRef.Owned(S); 4728 4729 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 4730 Var, 4731 Handler.get()); 4732} 4733 4734template<typename Derived> 4735StmtResult 4736TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 4737 // Transform the try block itself. 4738 StmtResult TryBlock 4739 = getDerived().TransformCompoundStmt(S->getTryBlock()); 4740 if (TryBlock.isInvalid()) 4741 return StmtError(); 4742 4743 // Transform the handlers. 4744 bool HandlerChanged = false; 4745 ASTOwningVector<Stmt*> Handlers(SemaRef); 4746 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 4747 StmtResult Handler 4748 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 4749 if (Handler.isInvalid()) 4750 return StmtError(); 4751 4752 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 4753 Handlers.push_back(Handler.takeAs<Stmt>()); 4754 } 4755 4756 if (!getDerived().AlwaysRebuild() && 4757 TryBlock.get() == S->getTryBlock() && 4758 !HandlerChanged) 4759 return SemaRef.Owned(S); 4760 4761 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 4762 move_arg(Handlers)); 4763} 4764 4765//===----------------------------------------------------------------------===// 4766// Expression transformation 4767//===----------------------------------------------------------------------===// 4768template<typename Derived> 4769ExprResult 4770TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 4771 return SemaRef.Owned(E); 4772} 4773 4774template<typename Derived> 4775ExprResult 4776TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 4777 NestedNameSpecifier *Qualifier = 0; 4778 if (E->getQualifier()) { 4779 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4780 E->getQualifierRange()); 4781 if (!Qualifier) 4782 return ExprError(); 4783 } 4784 4785 ValueDecl *ND 4786 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 4787 E->getDecl())); 4788 if (!ND) 4789 return ExprError(); 4790 4791 DeclarationNameInfo NameInfo = E->getNameInfo(); 4792 if (NameInfo.getName()) { 4793 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 4794 if (!NameInfo.getName()) 4795 return ExprError(); 4796 } 4797 4798 if (!getDerived().AlwaysRebuild() && 4799 Qualifier == E->getQualifier() && 4800 ND == E->getDecl() && 4801 NameInfo.getName() == E->getDecl()->getDeclName() && 4802 !E->hasExplicitTemplateArgs()) { 4803 4804 // Mark it referenced in the new context regardless. 4805 // FIXME: this is a bit instantiation-specific. 4806 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 4807 4808 return SemaRef.Owned(E); 4809 } 4810 4811 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 4812 if (E->hasExplicitTemplateArgs()) { 4813 TemplateArgs = &TransArgs; 4814 TransArgs.setLAngleLoc(E->getLAngleLoc()); 4815 TransArgs.setRAngleLoc(E->getRAngleLoc()); 4816 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 4817 E->getNumTemplateArgs(), 4818 TransArgs)) 4819 return ExprError(); 4820 } 4821 4822 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 4823 ND, NameInfo, TemplateArgs); 4824} 4825 4826template<typename Derived> 4827ExprResult 4828TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 4829 return SemaRef.Owned(E); 4830} 4831 4832template<typename Derived> 4833ExprResult 4834TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 4835 return SemaRef.Owned(E); 4836} 4837 4838template<typename Derived> 4839ExprResult 4840TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 4841 return SemaRef.Owned(E); 4842} 4843 4844template<typename Derived> 4845ExprResult 4846TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 4847 return SemaRef.Owned(E); 4848} 4849 4850template<typename Derived> 4851ExprResult 4852TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 4853 return SemaRef.Owned(E); 4854} 4855 4856template<typename Derived> 4857ExprResult 4858TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 4859 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4860 if (SubExpr.isInvalid()) 4861 return ExprError(); 4862 4863 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 4864 return SemaRef.Owned(E); 4865 4866 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 4867 E->getRParen()); 4868} 4869 4870template<typename Derived> 4871ExprResult 4872TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 4873 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4874 if (SubExpr.isInvalid()) 4875 return ExprError(); 4876 4877 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 4878 return SemaRef.Owned(E); 4879 4880 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 4881 E->getOpcode(), 4882 SubExpr.get()); 4883} 4884 4885template<typename Derived> 4886ExprResult 4887TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 4888 // Transform the type. 4889 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 4890 if (!Type) 4891 return ExprError(); 4892 4893 // Transform all of the components into components similar to what the 4894 // parser uses. 4895 // FIXME: It would be slightly more efficient in the non-dependent case to 4896 // just map FieldDecls, rather than requiring the rebuilder to look for 4897 // the fields again. However, __builtin_offsetof is rare enough in 4898 // template code that we don't care. 4899 bool ExprChanged = false; 4900 typedef Sema::OffsetOfComponent Component; 4901 typedef OffsetOfExpr::OffsetOfNode Node; 4902 llvm::SmallVector<Component, 4> Components; 4903 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 4904 const Node &ON = E->getComponent(I); 4905 Component Comp; 4906 Comp.isBrackets = true; 4907 Comp.LocStart = ON.getRange().getBegin(); 4908 Comp.LocEnd = ON.getRange().getEnd(); 4909 switch (ON.getKind()) { 4910 case Node::Array: { 4911 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 4912 ExprResult Index = getDerived().TransformExpr(FromIndex); 4913 if (Index.isInvalid()) 4914 return ExprError(); 4915 4916 ExprChanged = ExprChanged || Index.get() != FromIndex; 4917 Comp.isBrackets = true; 4918 Comp.U.E = Index.get(); 4919 break; 4920 } 4921 4922 case Node::Field: 4923 case Node::Identifier: 4924 Comp.isBrackets = false; 4925 Comp.U.IdentInfo = ON.getFieldName(); 4926 if (!Comp.U.IdentInfo) 4927 continue; 4928 4929 break; 4930 4931 case Node::Base: 4932 // Will be recomputed during the rebuild. 4933 continue; 4934 } 4935 4936 Components.push_back(Comp); 4937 } 4938 4939 // If nothing changed, retain the existing expression. 4940 if (!getDerived().AlwaysRebuild() && 4941 Type == E->getTypeSourceInfo() && 4942 !ExprChanged) 4943 return SemaRef.Owned(E); 4944 4945 // Build a new offsetof expression. 4946 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 4947 Components.data(), Components.size(), 4948 E->getRParenLoc()); 4949} 4950 4951template<typename Derived> 4952ExprResult 4953TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 4954 assert(getDerived().AlreadyTransformed(E->getType()) && 4955 "opaque value expression requires transformation"); 4956 return SemaRef.Owned(E); 4957} 4958 4959template<typename Derived> 4960ExprResult 4961TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 4962 if (E->isArgumentType()) { 4963 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 4964 4965 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 4966 if (!NewT) 4967 return ExprError(); 4968 4969 if (!getDerived().AlwaysRebuild() && OldT == NewT) 4970 return SemaRef.Owned(E); 4971 4972 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 4973 E->isSizeOf(), 4974 E->getSourceRange()); 4975 } 4976 4977 ExprResult SubExpr; 4978 { 4979 // C++0x [expr.sizeof]p1: 4980 // The operand is either an expression, which is an unevaluated operand 4981 // [...] 4982 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4983 4984 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 4985 if (SubExpr.isInvalid()) 4986 return ExprError(); 4987 4988 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 4989 return SemaRef.Owned(E); 4990 } 4991 4992 return getDerived().RebuildSizeOfAlignOf(SubExpr.get(), E->getOperatorLoc(), 4993 E->isSizeOf(), 4994 E->getSourceRange()); 4995} 4996 4997template<typename Derived> 4998ExprResult 4999TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 5000 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5001 if (LHS.isInvalid()) 5002 return ExprError(); 5003 5004 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5005 if (RHS.isInvalid()) 5006 return ExprError(); 5007 5008 5009 if (!getDerived().AlwaysRebuild() && 5010 LHS.get() == E->getLHS() && 5011 RHS.get() == E->getRHS()) 5012 return SemaRef.Owned(E); 5013 5014 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 5015 /*FIXME:*/E->getLHS()->getLocStart(), 5016 RHS.get(), 5017 E->getRBracketLoc()); 5018} 5019 5020template<typename Derived> 5021ExprResult 5022TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 5023 // Transform the callee. 5024 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 5025 if (Callee.isInvalid()) 5026 return ExprError(); 5027 5028 // Transform arguments. 5029 bool ArgChanged = false; 5030 ASTOwningVector<Expr*> Args(SemaRef); 5031 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 5032 &ArgChanged)) 5033 return ExprError(); 5034 5035 if (!getDerived().AlwaysRebuild() && 5036 Callee.get() == E->getCallee() && 5037 !ArgChanged) 5038 return SemaRef.Owned(E); 5039 5040 // FIXME: Wrong source location information for the '('. 5041 SourceLocation FakeLParenLoc 5042 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 5043 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 5044 move_arg(Args), 5045 E->getRParenLoc()); 5046} 5047 5048template<typename Derived> 5049ExprResult 5050TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 5051 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5052 if (Base.isInvalid()) 5053 return ExprError(); 5054 5055 NestedNameSpecifier *Qualifier = 0; 5056 if (E->hasQualifier()) { 5057 Qualifier 5058 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5059 E->getQualifierRange()); 5060 if (Qualifier == 0) 5061 return ExprError(); 5062 } 5063 5064 ValueDecl *Member 5065 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 5066 E->getMemberDecl())); 5067 if (!Member) 5068 return ExprError(); 5069 5070 NamedDecl *FoundDecl = E->getFoundDecl(); 5071 if (FoundDecl == E->getMemberDecl()) { 5072 FoundDecl = Member; 5073 } else { 5074 FoundDecl = cast_or_null<NamedDecl>( 5075 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 5076 if (!FoundDecl) 5077 return ExprError(); 5078 } 5079 5080 if (!getDerived().AlwaysRebuild() && 5081 Base.get() == E->getBase() && 5082 Qualifier == E->getQualifier() && 5083 Member == E->getMemberDecl() && 5084 FoundDecl == E->getFoundDecl() && 5085 !E->hasExplicitTemplateArgs()) { 5086 5087 // Mark it referenced in the new context regardless. 5088 // FIXME: this is a bit instantiation-specific. 5089 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member); 5090 return SemaRef.Owned(E); 5091 } 5092 5093 TemplateArgumentListInfo TransArgs; 5094 if (E->hasExplicitTemplateArgs()) { 5095 TransArgs.setLAngleLoc(E->getLAngleLoc()); 5096 TransArgs.setRAngleLoc(E->getRAngleLoc()); 5097 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 5098 E->getNumTemplateArgs(), 5099 TransArgs)) 5100 return ExprError(); 5101 } 5102 5103 // FIXME: Bogus source location for the operator 5104 SourceLocation FakeOperatorLoc 5105 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 5106 5107 // FIXME: to do this check properly, we will need to preserve the 5108 // first-qualifier-in-scope here, just in case we had a dependent 5109 // base (and therefore couldn't do the check) and a 5110 // nested-name-qualifier (and therefore could do the lookup). 5111 NamedDecl *FirstQualifierInScope = 0; 5112 5113 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 5114 E->isArrow(), 5115 Qualifier, 5116 E->getQualifierRange(), 5117 E->getMemberNameInfo(), 5118 Member, 5119 FoundDecl, 5120 (E->hasExplicitTemplateArgs() 5121 ? &TransArgs : 0), 5122 FirstQualifierInScope); 5123} 5124 5125template<typename Derived> 5126ExprResult 5127TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 5128 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5129 if (LHS.isInvalid()) 5130 return ExprError(); 5131 5132 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5133 if (RHS.isInvalid()) 5134 return ExprError(); 5135 5136 if (!getDerived().AlwaysRebuild() && 5137 LHS.get() == E->getLHS() && 5138 RHS.get() == E->getRHS()) 5139 return SemaRef.Owned(E); 5140 5141 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 5142 LHS.get(), RHS.get()); 5143} 5144 5145template<typename Derived> 5146ExprResult 5147TreeTransform<Derived>::TransformCompoundAssignOperator( 5148 CompoundAssignOperator *E) { 5149 return getDerived().TransformBinaryOperator(E); 5150} 5151 5152template<typename Derived> 5153ExprResult 5154TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 5155 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5156 if (Cond.isInvalid()) 5157 return ExprError(); 5158 5159 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5160 if (LHS.isInvalid()) 5161 return ExprError(); 5162 5163 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5164 if (RHS.isInvalid()) 5165 return ExprError(); 5166 5167 if (!getDerived().AlwaysRebuild() && 5168 Cond.get() == E->getCond() && 5169 LHS.get() == E->getLHS() && 5170 RHS.get() == E->getRHS()) 5171 return SemaRef.Owned(E); 5172 5173 return getDerived().RebuildConditionalOperator(Cond.get(), 5174 E->getQuestionLoc(), 5175 LHS.get(), 5176 E->getColonLoc(), 5177 RHS.get()); 5178} 5179 5180template<typename Derived> 5181ExprResult 5182TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 5183 // Implicit casts are eliminated during transformation, since they 5184 // will be recomputed by semantic analysis after transformation. 5185 return getDerived().TransformExpr(E->getSubExprAsWritten()); 5186} 5187 5188template<typename Derived> 5189ExprResult 5190TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 5191 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5192 if (!Type) 5193 return ExprError(); 5194 5195 ExprResult SubExpr 5196 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5197 if (SubExpr.isInvalid()) 5198 return ExprError(); 5199 5200 if (!getDerived().AlwaysRebuild() && 5201 Type == E->getTypeInfoAsWritten() && 5202 SubExpr.get() == E->getSubExpr()) 5203 return SemaRef.Owned(E); 5204 5205 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 5206 Type, 5207 E->getRParenLoc(), 5208 SubExpr.get()); 5209} 5210 5211template<typename Derived> 5212ExprResult 5213TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 5214 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 5215 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 5216 if (!NewT) 5217 return ExprError(); 5218 5219 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 5220 if (Init.isInvalid()) 5221 return ExprError(); 5222 5223 if (!getDerived().AlwaysRebuild() && 5224 OldT == NewT && 5225 Init.get() == E->getInitializer()) 5226 return SemaRef.Owned(E); 5227 5228 // Note: the expression type doesn't necessarily match the 5229 // type-as-written, but that's okay, because it should always be 5230 // derivable from the initializer. 5231 5232 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 5233 /*FIXME:*/E->getInitializer()->getLocEnd(), 5234 Init.get()); 5235} 5236 5237template<typename Derived> 5238ExprResult 5239TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 5240 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5241 if (Base.isInvalid()) 5242 return ExprError(); 5243 5244 if (!getDerived().AlwaysRebuild() && 5245 Base.get() == E->getBase()) 5246 return SemaRef.Owned(E); 5247 5248 // FIXME: Bad source location 5249 SourceLocation FakeOperatorLoc 5250 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 5251 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 5252 E->getAccessorLoc(), 5253 E->getAccessor()); 5254} 5255 5256template<typename Derived> 5257ExprResult 5258TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 5259 bool InitChanged = false; 5260 5261 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5262 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 5263 Inits, &InitChanged)) 5264 return ExprError(); 5265 5266 if (!getDerived().AlwaysRebuild() && !InitChanged) 5267 return SemaRef.Owned(E); 5268 5269 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 5270 E->getRBraceLoc(), E->getType()); 5271} 5272 5273template<typename Derived> 5274ExprResult 5275TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 5276 Designation Desig; 5277 5278 // transform the initializer value 5279 ExprResult Init = getDerived().TransformExpr(E->getInit()); 5280 if (Init.isInvalid()) 5281 return ExprError(); 5282 5283 // transform the designators. 5284 ASTOwningVector<Expr*, 4> ArrayExprs(SemaRef); 5285 bool ExprChanged = false; 5286 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 5287 DEnd = E->designators_end(); 5288 D != DEnd; ++D) { 5289 if (D->isFieldDesignator()) { 5290 Desig.AddDesignator(Designator::getField(D->getFieldName(), 5291 D->getDotLoc(), 5292 D->getFieldLoc())); 5293 continue; 5294 } 5295 5296 if (D->isArrayDesignator()) { 5297 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 5298 if (Index.isInvalid()) 5299 return ExprError(); 5300 5301 Desig.AddDesignator(Designator::getArray(Index.get(), 5302 D->getLBracketLoc())); 5303 5304 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 5305 ArrayExprs.push_back(Index.release()); 5306 continue; 5307 } 5308 5309 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 5310 ExprResult Start 5311 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 5312 if (Start.isInvalid()) 5313 return ExprError(); 5314 5315 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 5316 if (End.isInvalid()) 5317 return ExprError(); 5318 5319 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 5320 End.get(), 5321 D->getLBracketLoc(), 5322 D->getEllipsisLoc())); 5323 5324 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 5325 End.get() != E->getArrayRangeEnd(*D); 5326 5327 ArrayExprs.push_back(Start.release()); 5328 ArrayExprs.push_back(End.release()); 5329 } 5330 5331 if (!getDerived().AlwaysRebuild() && 5332 Init.get() == E->getInit() && 5333 !ExprChanged) 5334 return SemaRef.Owned(E); 5335 5336 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 5337 E->getEqualOrColonLoc(), 5338 E->usesGNUSyntax(), Init.get()); 5339} 5340 5341template<typename Derived> 5342ExprResult 5343TreeTransform<Derived>::TransformImplicitValueInitExpr( 5344 ImplicitValueInitExpr *E) { 5345 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 5346 5347 // FIXME: Will we ever have proper type location here? Will we actually 5348 // need to transform the type? 5349 QualType T = getDerived().TransformType(E->getType()); 5350 if (T.isNull()) 5351 return ExprError(); 5352 5353 if (!getDerived().AlwaysRebuild() && 5354 T == E->getType()) 5355 return SemaRef.Owned(E); 5356 5357 return getDerived().RebuildImplicitValueInitExpr(T); 5358} 5359 5360template<typename Derived> 5361ExprResult 5362TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 5363 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 5364 if (!TInfo) 5365 return ExprError(); 5366 5367 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5368 if (SubExpr.isInvalid()) 5369 return ExprError(); 5370 5371 if (!getDerived().AlwaysRebuild() && 5372 TInfo == E->getWrittenTypeInfo() && 5373 SubExpr.get() == E->getSubExpr()) 5374 return SemaRef.Owned(E); 5375 5376 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 5377 TInfo, E->getRParenLoc()); 5378} 5379 5380template<typename Derived> 5381ExprResult 5382TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 5383 bool ArgumentChanged = false; 5384 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5385 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 5386 &ArgumentChanged)) 5387 return ExprError(); 5388 5389 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 5390 move_arg(Inits), 5391 E->getRParenLoc()); 5392} 5393 5394/// \brief Transform an address-of-label expression. 5395/// 5396/// By default, the transformation of an address-of-label expression always 5397/// rebuilds the expression, so that the label identifier can be resolved to 5398/// the corresponding label statement by semantic analysis. 5399template<typename Derived> 5400ExprResult 5401TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 5402 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 5403 E->getLabel()); 5404} 5405 5406template<typename Derived> 5407ExprResult 5408TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 5409 StmtResult SubStmt 5410 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 5411 if (SubStmt.isInvalid()) 5412 return ExprError(); 5413 5414 if (!getDerived().AlwaysRebuild() && 5415 SubStmt.get() == E->getSubStmt()) 5416 return SemaRef.Owned(E); 5417 5418 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 5419 SubStmt.get(), 5420 E->getRParenLoc()); 5421} 5422 5423template<typename Derived> 5424ExprResult 5425TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 5426 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5427 if (Cond.isInvalid()) 5428 return ExprError(); 5429 5430 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5431 if (LHS.isInvalid()) 5432 return ExprError(); 5433 5434 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5435 if (RHS.isInvalid()) 5436 return ExprError(); 5437 5438 if (!getDerived().AlwaysRebuild() && 5439 Cond.get() == E->getCond() && 5440 LHS.get() == E->getLHS() && 5441 RHS.get() == E->getRHS()) 5442 return SemaRef.Owned(E); 5443 5444 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 5445 Cond.get(), LHS.get(), RHS.get(), 5446 E->getRParenLoc()); 5447} 5448 5449template<typename Derived> 5450ExprResult 5451TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 5452 return SemaRef.Owned(E); 5453} 5454 5455template<typename Derived> 5456ExprResult 5457TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 5458 switch (E->getOperator()) { 5459 case OO_New: 5460 case OO_Delete: 5461 case OO_Array_New: 5462 case OO_Array_Delete: 5463 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 5464 return ExprError(); 5465 5466 case OO_Call: { 5467 // This is a call to an object's operator(). 5468 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 5469 5470 // Transform the object itself. 5471 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 5472 if (Object.isInvalid()) 5473 return ExprError(); 5474 5475 // FIXME: Poor location information 5476 SourceLocation FakeLParenLoc 5477 = SemaRef.PP.getLocForEndOfToken( 5478 static_cast<Expr *>(Object.get())->getLocEnd()); 5479 5480 // Transform the call arguments. 5481 ASTOwningVector<Expr*> Args(SemaRef); 5482 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 5483 Args)) 5484 return ExprError(); 5485 5486 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 5487 move_arg(Args), 5488 E->getLocEnd()); 5489 } 5490 5491#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 5492 case OO_##Name: 5493#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 5494#include "clang/Basic/OperatorKinds.def" 5495 case OO_Subscript: 5496 // Handled below. 5497 break; 5498 5499 case OO_Conditional: 5500 llvm_unreachable("conditional operator is not actually overloadable"); 5501 return ExprError(); 5502 5503 case OO_None: 5504 case NUM_OVERLOADED_OPERATORS: 5505 llvm_unreachable("not an overloaded operator?"); 5506 return ExprError(); 5507 } 5508 5509 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 5510 if (Callee.isInvalid()) 5511 return ExprError(); 5512 5513 ExprResult First = getDerived().TransformExpr(E->getArg(0)); 5514 if (First.isInvalid()) 5515 return ExprError(); 5516 5517 ExprResult Second; 5518 if (E->getNumArgs() == 2) { 5519 Second = getDerived().TransformExpr(E->getArg(1)); 5520 if (Second.isInvalid()) 5521 return ExprError(); 5522 } 5523 5524 if (!getDerived().AlwaysRebuild() && 5525 Callee.get() == E->getCallee() && 5526 First.get() == E->getArg(0) && 5527 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 5528 return SemaRef.Owned(E); 5529 5530 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 5531 E->getOperatorLoc(), 5532 Callee.get(), 5533 First.get(), 5534 Second.get()); 5535} 5536 5537template<typename Derived> 5538ExprResult 5539TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 5540 return getDerived().TransformCallExpr(E); 5541} 5542 5543template<typename Derived> 5544ExprResult 5545TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 5546 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5547 if (!Type) 5548 return ExprError(); 5549 5550 ExprResult SubExpr 5551 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5552 if (SubExpr.isInvalid()) 5553 return ExprError(); 5554 5555 if (!getDerived().AlwaysRebuild() && 5556 Type == E->getTypeInfoAsWritten() && 5557 SubExpr.get() == E->getSubExpr()) 5558 return SemaRef.Owned(E); 5559 5560 // FIXME: Poor source location information here. 5561 SourceLocation FakeLAngleLoc 5562 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 5563 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 5564 SourceLocation FakeRParenLoc 5565 = SemaRef.PP.getLocForEndOfToken( 5566 E->getSubExpr()->getSourceRange().getEnd()); 5567 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 5568 E->getStmtClass(), 5569 FakeLAngleLoc, 5570 Type, 5571 FakeRAngleLoc, 5572 FakeRAngleLoc, 5573 SubExpr.get(), 5574 FakeRParenLoc); 5575} 5576 5577template<typename Derived> 5578ExprResult 5579TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 5580 return getDerived().TransformCXXNamedCastExpr(E); 5581} 5582 5583template<typename Derived> 5584ExprResult 5585TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 5586 return getDerived().TransformCXXNamedCastExpr(E); 5587} 5588 5589template<typename Derived> 5590ExprResult 5591TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 5592 CXXReinterpretCastExpr *E) { 5593 return getDerived().TransformCXXNamedCastExpr(E); 5594} 5595 5596template<typename Derived> 5597ExprResult 5598TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 5599 return getDerived().TransformCXXNamedCastExpr(E); 5600} 5601 5602template<typename Derived> 5603ExprResult 5604TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 5605 CXXFunctionalCastExpr *E) { 5606 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5607 if (!Type) 5608 return ExprError(); 5609 5610 ExprResult SubExpr 5611 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5612 if (SubExpr.isInvalid()) 5613 return ExprError(); 5614 5615 if (!getDerived().AlwaysRebuild() && 5616 Type == E->getTypeInfoAsWritten() && 5617 SubExpr.get() == E->getSubExpr()) 5618 return SemaRef.Owned(E); 5619 5620 return getDerived().RebuildCXXFunctionalCastExpr(Type, 5621 /*FIXME:*/E->getSubExpr()->getLocStart(), 5622 SubExpr.get(), 5623 E->getRParenLoc()); 5624} 5625 5626template<typename Derived> 5627ExprResult 5628TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 5629 if (E->isTypeOperand()) { 5630 TypeSourceInfo *TInfo 5631 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 5632 if (!TInfo) 5633 return ExprError(); 5634 5635 if (!getDerived().AlwaysRebuild() && 5636 TInfo == E->getTypeOperandSourceInfo()) 5637 return SemaRef.Owned(E); 5638 5639 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5640 E->getLocStart(), 5641 TInfo, 5642 E->getLocEnd()); 5643 } 5644 5645 // We don't know whether the expression is potentially evaluated until 5646 // after we perform semantic analysis, so the expression is potentially 5647 // potentially evaluated. 5648 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5649 Sema::PotentiallyPotentiallyEvaluated); 5650 5651 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 5652 if (SubExpr.isInvalid()) 5653 return ExprError(); 5654 5655 if (!getDerived().AlwaysRebuild() && 5656 SubExpr.get() == E->getExprOperand()) 5657 return SemaRef.Owned(E); 5658 5659 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5660 E->getLocStart(), 5661 SubExpr.get(), 5662 E->getLocEnd()); 5663} 5664 5665template<typename Derived> 5666ExprResult 5667TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 5668 if (E->isTypeOperand()) { 5669 TypeSourceInfo *TInfo 5670 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 5671 if (!TInfo) 5672 return ExprError(); 5673 5674 if (!getDerived().AlwaysRebuild() && 5675 TInfo == E->getTypeOperandSourceInfo()) 5676 return SemaRef.Owned(E); 5677 5678 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5679 E->getLocStart(), 5680 TInfo, 5681 E->getLocEnd()); 5682 } 5683 5684 // We don't know whether the expression is potentially evaluated until 5685 // after we perform semantic analysis, so the expression is potentially 5686 // potentially evaluated. 5687 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 5688 5689 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 5690 if (SubExpr.isInvalid()) 5691 return ExprError(); 5692 5693 if (!getDerived().AlwaysRebuild() && 5694 SubExpr.get() == E->getExprOperand()) 5695 return SemaRef.Owned(E); 5696 5697 return getDerived().RebuildCXXUuidofExpr(E->getType(), 5698 E->getLocStart(), 5699 SubExpr.get(), 5700 E->getLocEnd()); 5701} 5702 5703template<typename Derived> 5704ExprResult 5705TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 5706 return SemaRef.Owned(E); 5707} 5708 5709template<typename Derived> 5710ExprResult 5711TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 5712 CXXNullPtrLiteralExpr *E) { 5713 return SemaRef.Owned(E); 5714} 5715 5716template<typename Derived> 5717ExprResult 5718TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 5719 DeclContext *DC = getSema().getFunctionLevelDeclContext(); 5720 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC); 5721 QualType T = MD->getThisType(getSema().Context); 5722 5723 if (!getDerived().AlwaysRebuild() && T == E->getType()) 5724 return SemaRef.Owned(E); 5725 5726 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 5727} 5728 5729template<typename Derived> 5730ExprResult 5731TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 5732 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5733 if (SubExpr.isInvalid()) 5734 return ExprError(); 5735 5736 if (!getDerived().AlwaysRebuild() && 5737 SubExpr.get() == E->getSubExpr()) 5738 return SemaRef.Owned(E); 5739 5740 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get()); 5741} 5742 5743template<typename Derived> 5744ExprResult 5745TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 5746 ParmVarDecl *Param 5747 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 5748 E->getParam())); 5749 if (!Param) 5750 return ExprError(); 5751 5752 if (!getDerived().AlwaysRebuild() && 5753 Param == E->getParam()) 5754 return SemaRef.Owned(E); 5755 5756 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 5757} 5758 5759template<typename Derived> 5760ExprResult 5761TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 5762 CXXScalarValueInitExpr *E) { 5763 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 5764 if (!T) 5765 return ExprError(); 5766 5767 if (!getDerived().AlwaysRebuild() && 5768 T == E->getTypeSourceInfo()) 5769 return SemaRef.Owned(E); 5770 5771 return getDerived().RebuildCXXScalarValueInitExpr(T, 5772 /*FIXME:*/T->getTypeLoc().getEndLoc(), 5773 E->getRParenLoc()); 5774} 5775 5776template<typename Derived> 5777ExprResult 5778TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 5779 // Transform the type that we're allocating 5780 TypeSourceInfo *AllocTypeInfo 5781 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 5782 if (!AllocTypeInfo) 5783 return ExprError(); 5784 5785 // Transform the size of the array we're allocating (if any). 5786 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 5787 if (ArraySize.isInvalid()) 5788 return ExprError(); 5789 5790 // Transform the placement arguments (if any). 5791 bool ArgumentChanged = false; 5792 ASTOwningVector<Expr*> PlacementArgs(SemaRef); 5793 if (getDerived().TransformExprs(E->getPlacementArgs(), 5794 E->getNumPlacementArgs(), true, 5795 PlacementArgs, &ArgumentChanged)) 5796 return ExprError(); 5797 5798 // transform the constructor arguments (if any). 5799 ASTOwningVector<Expr*> ConstructorArgs(SemaRef); 5800 if (TransformExprs(E->getConstructorArgs(), E->getNumConstructorArgs(), true, 5801 ConstructorArgs, &ArgumentChanged)) 5802 return ExprError(); 5803 5804 // Transform constructor, new operator, and delete operator. 5805 CXXConstructorDecl *Constructor = 0; 5806 if (E->getConstructor()) { 5807 Constructor = cast_or_null<CXXConstructorDecl>( 5808 getDerived().TransformDecl(E->getLocStart(), 5809 E->getConstructor())); 5810 if (!Constructor) 5811 return ExprError(); 5812 } 5813 5814 FunctionDecl *OperatorNew = 0; 5815 if (E->getOperatorNew()) { 5816 OperatorNew = cast_or_null<FunctionDecl>( 5817 getDerived().TransformDecl(E->getLocStart(), 5818 E->getOperatorNew())); 5819 if (!OperatorNew) 5820 return ExprError(); 5821 } 5822 5823 FunctionDecl *OperatorDelete = 0; 5824 if (E->getOperatorDelete()) { 5825 OperatorDelete = cast_or_null<FunctionDecl>( 5826 getDerived().TransformDecl(E->getLocStart(), 5827 E->getOperatorDelete())); 5828 if (!OperatorDelete) 5829 return ExprError(); 5830 } 5831 5832 if (!getDerived().AlwaysRebuild() && 5833 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 5834 ArraySize.get() == E->getArraySize() && 5835 Constructor == E->getConstructor() && 5836 OperatorNew == E->getOperatorNew() && 5837 OperatorDelete == E->getOperatorDelete() && 5838 !ArgumentChanged) { 5839 // Mark any declarations we need as referenced. 5840 // FIXME: instantiation-specific. 5841 if (Constructor) 5842 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 5843 if (OperatorNew) 5844 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew); 5845 if (OperatorDelete) 5846 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 5847 return SemaRef.Owned(E); 5848 } 5849 5850 QualType AllocType = AllocTypeInfo->getType(); 5851 if (!ArraySize.get()) { 5852 // If no array size was specified, but the new expression was 5853 // instantiated with an array type (e.g., "new T" where T is 5854 // instantiated with "int[4]"), extract the outer bound from the 5855 // array type as our array size. We do this with constant and 5856 // dependently-sized array types. 5857 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 5858 if (!ArrayT) { 5859 // Do nothing 5860 } else if (const ConstantArrayType *ConsArrayT 5861 = dyn_cast<ConstantArrayType>(ArrayT)) { 5862 ArraySize 5863 = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, 5864 ConsArrayT->getSize(), 5865 SemaRef.Context.getSizeType(), 5866 /*FIXME:*/E->getLocStart())); 5867 AllocType = ConsArrayT->getElementType(); 5868 } else if (const DependentSizedArrayType *DepArrayT 5869 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 5870 if (DepArrayT->getSizeExpr()) { 5871 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); 5872 AllocType = DepArrayT->getElementType(); 5873 } 5874 } 5875 } 5876 5877 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 5878 E->isGlobalNew(), 5879 /*FIXME:*/E->getLocStart(), 5880 move_arg(PlacementArgs), 5881 /*FIXME:*/E->getLocStart(), 5882 E->getTypeIdParens(), 5883 AllocType, 5884 AllocTypeInfo, 5885 ArraySize.get(), 5886 /*FIXME:*/E->getLocStart(), 5887 move_arg(ConstructorArgs), 5888 E->getLocEnd()); 5889} 5890 5891template<typename Derived> 5892ExprResult 5893TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 5894 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 5895 if (Operand.isInvalid()) 5896 return ExprError(); 5897 5898 // Transform the delete operator, if known. 5899 FunctionDecl *OperatorDelete = 0; 5900 if (E->getOperatorDelete()) { 5901 OperatorDelete = cast_or_null<FunctionDecl>( 5902 getDerived().TransformDecl(E->getLocStart(), 5903 E->getOperatorDelete())); 5904 if (!OperatorDelete) 5905 return ExprError(); 5906 } 5907 5908 if (!getDerived().AlwaysRebuild() && 5909 Operand.get() == E->getArgument() && 5910 OperatorDelete == E->getOperatorDelete()) { 5911 // Mark any declarations we need as referenced. 5912 // FIXME: instantiation-specific. 5913 if (OperatorDelete) 5914 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 5915 5916 if (!E->getArgument()->isTypeDependent()) { 5917 QualType Destroyed = SemaRef.Context.getBaseElementType( 5918 E->getDestroyedType()); 5919 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 5920 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 5921 SemaRef.MarkDeclarationReferenced(E->getLocStart(), 5922 SemaRef.LookupDestructor(Record)); 5923 } 5924 } 5925 5926 return SemaRef.Owned(E); 5927 } 5928 5929 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 5930 E->isGlobalDelete(), 5931 E->isArrayForm(), 5932 Operand.get()); 5933} 5934 5935template<typename Derived> 5936ExprResult 5937TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 5938 CXXPseudoDestructorExpr *E) { 5939 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5940 if (Base.isInvalid()) 5941 return ExprError(); 5942 5943 ParsedType ObjectTypePtr; 5944 bool MayBePseudoDestructor = false; 5945 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 5946 E->getOperatorLoc(), 5947 E->isArrow()? tok::arrow : tok::period, 5948 ObjectTypePtr, 5949 MayBePseudoDestructor); 5950 if (Base.isInvalid()) 5951 return ExprError(); 5952 5953 QualType ObjectType = ObjectTypePtr.get(); 5954 NestedNameSpecifier *Qualifier = E->getQualifier(); 5955 if (Qualifier) { 5956 Qualifier 5957 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5958 E->getQualifierRange(), 5959 ObjectType); 5960 if (!Qualifier) 5961 return ExprError(); 5962 } 5963 5964 PseudoDestructorTypeStorage Destroyed; 5965 if (E->getDestroyedTypeInfo()) { 5966 TypeSourceInfo *DestroyedTypeInfo 5967 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 5968 ObjectType, 0, Qualifier); 5969 if (!DestroyedTypeInfo) 5970 return ExprError(); 5971 Destroyed = DestroyedTypeInfo; 5972 } else if (ObjectType->isDependentType()) { 5973 // We aren't likely to be able to resolve the identifier down to a type 5974 // now anyway, so just retain the identifier. 5975 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 5976 E->getDestroyedTypeLoc()); 5977 } else { 5978 // Look for a destructor known with the given name. 5979 CXXScopeSpec SS; 5980 if (Qualifier) { 5981 SS.setScopeRep(Qualifier); 5982 SS.setRange(E->getQualifierRange()); 5983 } 5984 5985 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 5986 *E->getDestroyedTypeIdentifier(), 5987 E->getDestroyedTypeLoc(), 5988 /*Scope=*/0, 5989 SS, ObjectTypePtr, 5990 false); 5991 if (!T) 5992 return ExprError(); 5993 5994 Destroyed 5995 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 5996 E->getDestroyedTypeLoc()); 5997 } 5998 5999 TypeSourceInfo *ScopeTypeInfo = 0; 6000 if (E->getScopeTypeInfo()) { 6001 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo()); 6002 if (!ScopeTypeInfo) 6003 return ExprError(); 6004 } 6005 6006 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 6007 E->getOperatorLoc(), 6008 E->isArrow(), 6009 Qualifier, 6010 E->getQualifierRange(), 6011 ScopeTypeInfo, 6012 E->getColonColonLoc(), 6013 E->getTildeLoc(), 6014 Destroyed); 6015} 6016 6017template<typename Derived> 6018ExprResult 6019TreeTransform<Derived>::TransformUnresolvedLookupExpr( 6020 UnresolvedLookupExpr *Old) { 6021 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName()); 6022 6023 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 6024 Sema::LookupOrdinaryName); 6025 6026 // Transform all the decls. 6027 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 6028 E = Old->decls_end(); I != E; ++I) { 6029 NamedDecl *InstD = static_cast<NamedDecl*>( 6030 getDerived().TransformDecl(Old->getNameLoc(), 6031 *I)); 6032 if (!InstD) { 6033 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 6034 // This can happen because of dependent hiding. 6035 if (isa<UsingShadowDecl>(*I)) 6036 continue; 6037 else 6038 return ExprError(); 6039 } 6040 6041 // Expand using declarations. 6042 if (isa<UsingDecl>(InstD)) { 6043 UsingDecl *UD = cast<UsingDecl>(InstD); 6044 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 6045 E = UD->shadow_end(); I != E; ++I) 6046 R.addDecl(*I); 6047 continue; 6048 } 6049 6050 R.addDecl(InstD); 6051 } 6052 6053 // Resolve a kind, but don't do any further analysis. If it's 6054 // ambiguous, the callee needs to deal with it. 6055 R.resolveKind(); 6056 6057 // Rebuild the nested-name qualifier, if present. 6058 CXXScopeSpec SS; 6059 NestedNameSpecifier *Qualifier = 0; 6060 if (Old->getQualifier()) { 6061 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 6062 Old->getQualifierRange()); 6063 if (!Qualifier) 6064 return ExprError(); 6065 6066 SS.setScopeRep(Qualifier); 6067 SS.setRange(Old->getQualifierRange()); 6068 } 6069 6070 if (Old->getNamingClass()) { 6071 CXXRecordDecl *NamingClass 6072 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 6073 Old->getNameLoc(), 6074 Old->getNamingClass())); 6075 if (!NamingClass) 6076 return ExprError(); 6077 6078 R.setNamingClass(NamingClass); 6079 } 6080 6081 // If we have no template arguments, it's a normal declaration name. 6082 if (!Old->hasExplicitTemplateArgs()) 6083 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 6084 6085 // If we have template arguments, rebuild them, then rebuild the 6086 // templateid expression. 6087 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 6088 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 6089 Old->getNumTemplateArgs(), 6090 TransArgs)) 6091 return ExprError(); 6092 6093 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(), 6094 TransArgs); 6095} 6096 6097template<typename Derived> 6098ExprResult 6099TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 6100 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 6101 if (!T) 6102 return ExprError(); 6103 6104 if (!getDerived().AlwaysRebuild() && 6105 T == E->getQueriedTypeSourceInfo()) 6106 return SemaRef.Owned(E); 6107 6108 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 6109 E->getLocStart(), 6110 T, 6111 E->getLocEnd()); 6112} 6113 6114template<typename Derived> 6115ExprResult 6116TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 6117 TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); 6118 if (!LhsT) 6119 return ExprError(); 6120 6121 TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); 6122 if (!RhsT) 6123 return ExprError(); 6124 6125 if (!getDerived().AlwaysRebuild() && 6126 LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) 6127 return SemaRef.Owned(E); 6128 6129 return getDerived().RebuildBinaryTypeTrait(E->getTrait(), 6130 E->getLocStart(), 6131 LhsT, RhsT, 6132 E->getLocEnd()); 6133} 6134 6135template<typename Derived> 6136ExprResult 6137TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 6138 DependentScopeDeclRefExpr *E) { 6139 NestedNameSpecifier *NNS 6140 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 6141 E->getQualifierRange()); 6142 if (!NNS) 6143 return ExprError(); 6144 6145 // TODO: If this is a conversion-function-id, verify that the 6146 // destination type name (if present) resolves the same way after 6147 // instantiation as it did in the local scope. 6148 6149 DeclarationNameInfo NameInfo 6150 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 6151 if (!NameInfo.getName()) 6152 return ExprError(); 6153 6154 if (!E->hasExplicitTemplateArgs()) { 6155 if (!getDerived().AlwaysRebuild() && 6156 NNS == E->getQualifier() && 6157 // Note: it is sufficient to compare the Name component of NameInfo: 6158 // if name has not changed, DNLoc has not changed either. 6159 NameInfo.getName() == E->getDeclName()) 6160 return SemaRef.Owned(E); 6161 6162 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 6163 E->getQualifierRange(), 6164 NameInfo, 6165 /*TemplateArgs*/ 0); 6166 } 6167 6168 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6169 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6170 E->getNumTemplateArgs(), 6171 TransArgs)) 6172 return ExprError(); 6173 6174 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 6175 E->getQualifierRange(), 6176 NameInfo, 6177 &TransArgs); 6178} 6179 6180template<typename Derived> 6181ExprResult 6182TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 6183 // CXXConstructExprs are always implicit, so when we have a 6184 // 1-argument construction we just transform that argument. 6185 if (E->getNumArgs() == 1 || 6186 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) 6187 return getDerived().TransformExpr(E->getArg(0)); 6188 6189 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 6190 6191 QualType T = getDerived().TransformType(E->getType()); 6192 if (T.isNull()) 6193 return ExprError(); 6194 6195 CXXConstructorDecl *Constructor 6196 = cast_or_null<CXXConstructorDecl>( 6197 getDerived().TransformDecl(E->getLocStart(), 6198 E->getConstructor())); 6199 if (!Constructor) 6200 return ExprError(); 6201 6202 bool ArgumentChanged = false; 6203 ASTOwningVector<Expr*> Args(SemaRef); 6204 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6205 &ArgumentChanged)) 6206 return ExprError(); 6207 6208 if (!getDerived().AlwaysRebuild() && 6209 T == E->getType() && 6210 Constructor == E->getConstructor() && 6211 !ArgumentChanged) { 6212 // Mark the constructor as referenced. 6213 // FIXME: Instantiation-specific 6214 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6215 return SemaRef.Owned(E); 6216 } 6217 6218 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 6219 Constructor, E->isElidable(), 6220 move_arg(Args), 6221 E->requiresZeroInitialization(), 6222 E->getConstructionKind(), 6223 E->getParenRange()); 6224} 6225 6226/// \brief Transform a C++ temporary-binding expression. 6227/// 6228/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 6229/// transform the subexpression and return that. 6230template<typename Derived> 6231ExprResult 6232TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 6233 return getDerived().TransformExpr(E->getSubExpr()); 6234} 6235 6236/// \brief Transform a C++ expression that contains cleanups that should 6237/// be run after the expression is evaluated. 6238/// 6239/// Since ExprWithCleanups nodes are implicitly generated, we 6240/// just transform the subexpression and return that. 6241template<typename Derived> 6242ExprResult 6243TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 6244 return getDerived().TransformExpr(E->getSubExpr()); 6245} 6246 6247template<typename Derived> 6248ExprResult 6249TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 6250 CXXTemporaryObjectExpr *E) { 6251 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6252 if (!T) 6253 return ExprError(); 6254 6255 CXXConstructorDecl *Constructor 6256 = cast_or_null<CXXConstructorDecl>( 6257 getDerived().TransformDecl(E->getLocStart(), 6258 E->getConstructor())); 6259 if (!Constructor) 6260 return ExprError(); 6261 6262 bool ArgumentChanged = false; 6263 ASTOwningVector<Expr*> Args(SemaRef); 6264 Args.reserve(E->getNumArgs()); 6265 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6266 &ArgumentChanged)) 6267 return ExprError(); 6268 6269 if (!getDerived().AlwaysRebuild() && 6270 T == E->getTypeSourceInfo() && 6271 Constructor == E->getConstructor() && 6272 !ArgumentChanged) { 6273 // FIXME: Instantiation-specific 6274 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6275 return SemaRef.MaybeBindToTemporary(E); 6276 } 6277 6278 return getDerived().RebuildCXXTemporaryObjectExpr(T, 6279 /*FIXME:*/T->getTypeLoc().getEndLoc(), 6280 move_arg(Args), 6281 E->getLocEnd()); 6282} 6283 6284template<typename Derived> 6285ExprResult 6286TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 6287 CXXUnresolvedConstructExpr *E) { 6288 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6289 if (!T) 6290 return ExprError(); 6291 6292 bool ArgumentChanged = false; 6293 ASTOwningVector<Expr*> Args(SemaRef); 6294 Args.reserve(E->arg_size()); 6295 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 6296 &ArgumentChanged)) 6297 return ExprError(); 6298 6299 if (!getDerived().AlwaysRebuild() && 6300 T == E->getTypeSourceInfo() && 6301 !ArgumentChanged) 6302 return SemaRef.Owned(E); 6303 6304 // FIXME: we're faking the locations of the commas 6305 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 6306 E->getLParenLoc(), 6307 move_arg(Args), 6308 E->getRParenLoc()); 6309} 6310 6311template<typename Derived> 6312ExprResult 6313TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 6314 CXXDependentScopeMemberExpr *E) { 6315 // Transform the base of the expression. 6316 ExprResult Base((Expr*) 0); 6317 Expr *OldBase; 6318 QualType BaseType; 6319 QualType ObjectType; 6320 if (!E->isImplicitAccess()) { 6321 OldBase = E->getBase(); 6322 Base = getDerived().TransformExpr(OldBase); 6323 if (Base.isInvalid()) 6324 return ExprError(); 6325 6326 // Start the member reference and compute the object's type. 6327 ParsedType ObjectTy; 6328 bool MayBePseudoDestructor = false; 6329 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 6330 E->getOperatorLoc(), 6331 E->isArrow()? tok::arrow : tok::period, 6332 ObjectTy, 6333 MayBePseudoDestructor); 6334 if (Base.isInvalid()) 6335 return ExprError(); 6336 6337 ObjectType = ObjectTy.get(); 6338 BaseType = ((Expr*) Base.get())->getType(); 6339 } else { 6340 OldBase = 0; 6341 BaseType = getDerived().TransformType(E->getBaseType()); 6342 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 6343 } 6344 6345 // Transform the first part of the nested-name-specifier that qualifies 6346 // the member name. 6347 NamedDecl *FirstQualifierInScope 6348 = getDerived().TransformFirstQualifierInScope( 6349 E->getFirstQualifierFoundInScope(), 6350 E->getQualifierRange().getBegin()); 6351 6352 NestedNameSpecifier *Qualifier = 0; 6353 if (E->getQualifier()) { 6354 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 6355 E->getQualifierRange(), 6356 ObjectType, 6357 FirstQualifierInScope); 6358 if (!Qualifier) 6359 return ExprError(); 6360 } 6361 6362 // TODO: If this is a conversion-function-id, verify that the 6363 // destination type name (if present) resolves the same way after 6364 // instantiation as it did in the local scope. 6365 6366 DeclarationNameInfo NameInfo 6367 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 6368 if (!NameInfo.getName()) 6369 return ExprError(); 6370 6371 if (!E->hasExplicitTemplateArgs()) { 6372 // This is a reference to a member without an explicitly-specified 6373 // template argument list. Optimize for this common case. 6374 if (!getDerived().AlwaysRebuild() && 6375 Base.get() == OldBase && 6376 BaseType == E->getBaseType() && 6377 Qualifier == E->getQualifier() && 6378 NameInfo.getName() == E->getMember() && 6379 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 6380 return SemaRef.Owned(E); 6381 6382 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6383 BaseType, 6384 E->isArrow(), 6385 E->getOperatorLoc(), 6386 Qualifier, 6387 E->getQualifierRange(), 6388 FirstQualifierInScope, 6389 NameInfo, 6390 /*TemplateArgs*/ 0); 6391 } 6392 6393 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6394 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6395 E->getNumTemplateArgs(), 6396 TransArgs)) 6397 return ExprError(); 6398 6399 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6400 BaseType, 6401 E->isArrow(), 6402 E->getOperatorLoc(), 6403 Qualifier, 6404 E->getQualifierRange(), 6405 FirstQualifierInScope, 6406 NameInfo, 6407 &TransArgs); 6408} 6409 6410template<typename Derived> 6411ExprResult 6412TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 6413 // Transform the base of the expression. 6414 ExprResult Base((Expr*) 0); 6415 QualType BaseType; 6416 if (!Old->isImplicitAccess()) { 6417 Base = getDerived().TransformExpr(Old->getBase()); 6418 if (Base.isInvalid()) 6419 return ExprError(); 6420 BaseType = ((Expr*) Base.get())->getType(); 6421 } else { 6422 BaseType = getDerived().TransformType(Old->getBaseType()); 6423 } 6424 6425 NestedNameSpecifier *Qualifier = 0; 6426 if (Old->getQualifier()) { 6427 Qualifier 6428 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 6429 Old->getQualifierRange()); 6430 if (Qualifier == 0) 6431 return ExprError(); 6432 } 6433 6434 LookupResult R(SemaRef, Old->getMemberNameInfo(), 6435 Sema::LookupOrdinaryName); 6436 6437 // Transform all the decls. 6438 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 6439 E = Old->decls_end(); I != E; ++I) { 6440 NamedDecl *InstD = static_cast<NamedDecl*>( 6441 getDerived().TransformDecl(Old->getMemberLoc(), 6442 *I)); 6443 if (!InstD) { 6444 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 6445 // This can happen because of dependent hiding. 6446 if (isa<UsingShadowDecl>(*I)) 6447 continue; 6448 else 6449 return ExprError(); 6450 } 6451 6452 // Expand using declarations. 6453 if (isa<UsingDecl>(InstD)) { 6454 UsingDecl *UD = cast<UsingDecl>(InstD); 6455 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 6456 E = UD->shadow_end(); I != E; ++I) 6457 R.addDecl(*I); 6458 continue; 6459 } 6460 6461 R.addDecl(InstD); 6462 } 6463 6464 R.resolveKind(); 6465 6466 // Determine the naming class. 6467 if (Old->getNamingClass()) { 6468 CXXRecordDecl *NamingClass 6469 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 6470 Old->getMemberLoc(), 6471 Old->getNamingClass())); 6472 if (!NamingClass) 6473 return ExprError(); 6474 6475 R.setNamingClass(NamingClass); 6476 } 6477 6478 TemplateArgumentListInfo TransArgs; 6479 if (Old->hasExplicitTemplateArgs()) { 6480 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 6481 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 6482 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 6483 Old->getNumTemplateArgs(), 6484 TransArgs)) 6485 return ExprError(); 6486 } 6487 6488 // FIXME: to do this check properly, we will need to preserve the 6489 // first-qualifier-in-scope here, just in case we had a dependent 6490 // base (and therefore couldn't do the check) and a 6491 // nested-name-qualifier (and therefore could do the lookup). 6492 NamedDecl *FirstQualifierInScope = 0; 6493 6494 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 6495 BaseType, 6496 Old->getOperatorLoc(), 6497 Old->isArrow(), 6498 Qualifier, 6499 Old->getQualifierRange(), 6500 FirstQualifierInScope, 6501 R, 6502 (Old->hasExplicitTemplateArgs() 6503 ? &TransArgs : 0)); 6504} 6505 6506template<typename Derived> 6507ExprResult 6508TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 6509 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 6510 if (SubExpr.isInvalid()) 6511 return ExprError(); 6512 6513 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 6514 return SemaRef.Owned(E); 6515 6516 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 6517} 6518 6519template<typename Derived> 6520ExprResult 6521TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 6522 llvm_unreachable("pack expansion expression in unhandled context"); 6523 return ExprError(); 6524} 6525 6526template<typename Derived> 6527ExprResult 6528TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 6529 // If E is not value-dependent, then nothing will change when we transform it. 6530 // Note: This is an instantiation-centric view. 6531 if (!E->isValueDependent()) 6532 return SemaRef.Owned(E); 6533 6534 // Note: None of the implementations of TryExpandParameterPacks can ever 6535 // produce a diagnostic when given only a single unexpanded parameter pack, 6536 // so 6537 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 6538 bool ShouldExpand = false; 6539 unsigned NumExpansions = 0; 6540 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 6541 &Unexpanded, 1, 6542 ShouldExpand, NumExpansions)) 6543 return ExprError(); 6544 6545 if (!ShouldExpand) 6546 return SemaRef.Owned(E); 6547 6548 // We now know the length of the parameter pack, so build a new expression 6549 // that stores that length. 6550 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), 6551 E->getPackLoc(), E->getRParenLoc(), 6552 NumExpansions); 6553} 6554 6555template<typename Derived> 6556ExprResult 6557TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 6558 return SemaRef.Owned(E); 6559} 6560 6561template<typename Derived> 6562ExprResult 6563TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 6564 TypeSourceInfo *EncodedTypeInfo 6565 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 6566 if (!EncodedTypeInfo) 6567 return ExprError(); 6568 6569 if (!getDerived().AlwaysRebuild() && 6570 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 6571 return SemaRef.Owned(E); 6572 6573 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 6574 EncodedTypeInfo, 6575 E->getRParenLoc()); 6576} 6577 6578template<typename Derived> 6579ExprResult 6580TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 6581 // Transform arguments. 6582 bool ArgChanged = false; 6583 ASTOwningVector<Expr*> Args(SemaRef); 6584 Args.reserve(E->getNumArgs()); 6585 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 6586 &ArgChanged)) 6587 return ExprError(); 6588 6589 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 6590 // Class message: transform the receiver type. 6591 TypeSourceInfo *ReceiverTypeInfo 6592 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 6593 if (!ReceiverTypeInfo) 6594 return ExprError(); 6595 6596 // If nothing changed, just retain the existing message send. 6597 if (!getDerived().AlwaysRebuild() && 6598 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 6599 return SemaRef.Owned(E); 6600 6601 // Build a new class message send. 6602 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 6603 E->getSelector(), 6604 E->getSelectorLoc(), 6605 E->getMethodDecl(), 6606 E->getLeftLoc(), 6607 move_arg(Args), 6608 E->getRightLoc()); 6609 } 6610 6611 // Instance message: transform the receiver 6612 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 6613 "Only class and instance messages may be instantiated"); 6614 ExprResult Receiver 6615 = getDerived().TransformExpr(E->getInstanceReceiver()); 6616 if (Receiver.isInvalid()) 6617 return ExprError(); 6618 6619 // If nothing changed, just retain the existing message send. 6620 if (!getDerived().AlwaysRebuild() && 6621 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 6622 return SemaRef.Owned(E); 6623 6624 // Build a new instance message send. 6625 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 6626 E->getSelector(), 6627 E->getSelectorLoc(), 6628 E->getMethodDecl(), 6629 E->getLeftLoc(), 6630 move_arg(Args), 6631 E->getRightLoc()); 6632} 6633 6634template<typename Derived> 6635ExprResult 6636TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 6637 return SemaRef.Owned(E); 6638} 6639 6640template<typename Derived> 6641ExprResult 6642TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 6643 return SemaRef.Owned(E); 6644} 6645 6646template<typename Derived> 6647ExprResult 6648TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 6649 // Transform the base expression. 6650 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6651 if (Base.isInvalid()) 6652 return ExprError(); 6653 6654 // We don't need to transform the ivar; it will never change. 6655 6656 // If nothing changed, just retain the existing expression. 6657 if (!getDerived().AlwaysRebuild() && 6658 Base.get() == E->getBase()) 6659 return SemaRef.Owned(E); 6660 6661 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 6662 E->getLocation(), 6663 E->isArrow(), E->isFreeIvar()); 6664} 6665 6666template<typename Derived> 6667ExprResult 6668TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 6669 // 'super' and types never change. Property never changes. Just 6670 // retain the existing expression. 6671 if (!E->isObjectReceiver()) 6672 return SemaRef.Owned(E); 6673 6674 // Transform the base expression. 6675 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6676 if (Base.isInvalid()) 6677 return ExprError(); 6678 6679 // We don't need to transform the property; it will never change. 6680 6681 // If nothing changed, just retain the existing expression. 6682 if (!getDerived().AlwaysRebuild() && 6683 Base.get() == E->getBase()) 6684 return SemaRef.Owned(E); 6685 6686 if (E->isExplicitProperty()) 6687 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 6688 E->getExplicitProperty(), 6689 E->getLocation()); 6690 6691 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 6692 E->getType(), 6693 E->getImplicitPropertyGetter(), 6694 E->getImplicitPropertySetter(), 6695 E->getLocation()); 6696} 6697 6698template<typename Derived> 6699ExprResult 6700TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 6701 // Transform the base expression. 6702 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6703 if (Base.isInvalid()) 6704 return ExprError(); 6705 6706 // If nothing changed, just retain the existing expression. 6707 if (!getDerived().AlwaysRebuild() && 6708 Base.get() == E->getBase()) 6709 return SemaRef.Owned(E); 6710 6711 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 6712 E->isArrow()); 6713} 6714 6715template<typename Derived> 6716ExprResult 6717TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 6718 bool ArgumentChanged = false; 6719 ASTOwningVector<Expr*> SubExprs(SemaRef); 6720 SubExprs.reserve(E->getNumSubExprs()); 6721 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 6722 SubExprs, &ArgumentChanged)) 6723 return ExprError(); 6724 6725 if (!getDerived().AlwaysRebuild() && 6726 !ArgumentChanged) 6727 return SemaRef.Owned(E); 6728 6729 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 6730 move_arg(SubExprs), 6731 E->getRParenLoc()); 6732} 6733 6734template<typename Derived> 6735ExprResult 6736TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 6737 SourceLocation CaretLoc(E->getExprLoc()); 6738 6739 SemaRef.ActOnBlockStart(CaretLoc, /*Scope=*/0); 6740 BlockScopeInfo *CurBlock = SemaRef.getCurBlock(); 6741 CurBlock->TheDecl->setIsVariadic(E->getBlockDecl()->isVariadic()); 6742 llvm::SmallVector<ParmVarDecl*, 4> Params; 6743 llvm::SmallVector<QualType, 4> ParamTypes; 6744 6745 // Parameter substitution. 6746 const BlockDecl *BD = E->getBlockDecl(); 6747 for (BlockDecl::param_const_iterator P = BD->param_begin(), 6748 EN = BD->param_end(); P != EN; ++P) { 6749 ParmVarDecl *OldParm = (*P); 6750 ParmVarDecl *NewParm = getDerived().TransformFunctionTypeParam(OldParm); 6751 QualType NewType = NewParm->getType(); 6752 Params.push_back(NewParm); 6753 ParamTypes.push_back(NewParm->getType()); 6754 } 6755 6756 const FunctionType *BExprFunctionType = E->getFunctionType(); 6757 QualType BExprResultType = BExprFunctionType->getResultType(); 6758 if (!BExprResultType.isNull()) { 6759 if (!BExprResultType->isDependentType()) 6760 CurBlock->ReturnType = BExprResultType; 6761 else if (BExprResultType != SemaRef.Context.DependentTy) 6762 CurBlock->ReturnType = getDerived().TransformType(BExprResultType); 6763 } 6764 6765 QualType FunctionType = getDerived().RebuildFunctionProtoType( 6766 CurBlock->ReturnType, 6767 ParamTypes.data(), 6768 ParamTypes.size(), 6769 BD->isVariadic(), 6770 0, 6771 BExprFunctionType->getExtInfo()); 6772 CurBlock->FunctionType = FunctionType; 6773 6774 // Set the parameters on the block decl. 6775 if (!Params.empty()) 6776 CurBlock->TheDecl->setParams(Params.data(), Params.size()); 6777 6778 // Transform the body 6779 StmtResult Body = getDerived().TransformStmt(E->getBody()); 6780 if (Body.isInvalid()) 6781 return ExprError(); 6782 6783 return SemaRef.ActOnBlockStmtExpr(CaretLoc, Body.get(), /*Scope=*/0); 6784} 6785 6786template<typename Derived> 6787ExprResult 6788TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 6789 NestedNameSpecifier *Qualifier = 0; 6790 6791 ValueDecl *ND 6792 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 6793 E->getDecl())); 6794 if (!ND) 6795 return ExprError(); 6796 6797 if (!getDerived().AlwaysRebuild() && 6798 ND == E->getDecl()) { 6799 // Mark it referenced in the new context regardless. 6800 // FIXME: this is a bit instantiation-specific. 6801 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 6802 6803 return SemaRef.Owned(E); 6804 } 6805 6806 DeclarationNameInfo NameInfo(E->getDecl()->getDeclName(), E->getLocation()); 6807 return getDerived().RebuildDeclRefExpr(Qualifier, SourceLocation(), 6808 ND, NameInfo, 0); 6809} 6810 6811//===----------------------------------------------------------------------===// 6812// Type reconstruction 6813//===----------------------------------------------------------------------===// 6814 6815template<typename Derived> 6816QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 6817 SourceLocation Star) { 6818 return SemaRef.BuildPointerType(PointeeType, Star, 6819 getDerived().getBaseEntity()); 6820} 6821 6822template<typename Derived> 6823QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 6824 SourceLocation Star) { 6825 return SemaRef.BuildBlockPointerType(PointeeType, Star, 6826 getDerived().getBaseEntity()); 6827} 6828 6829template<typename Derived> 6830QualType 6831TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 6832 bool WrittenAsLValue, 6833 SourceLocation Sigil) { 6834 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 6835 Sigil, getDerived().getBaseEntity()); 6836} 6837 6838template<typename Derived> 6839QualType 6840TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 6841 QualType ClassType, 6842 SourceLocation Sigil) { 6843 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 6844 Sigil, getDerived().getBaseEntity()); 6845} 6846 6847template<typename Derived> 6848QualType 6849TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 6850 ArrayType::ArraySizeModifier SizeMod, 6851 const llvm::APInt *Size, 6852 Expr *SizeExpr, 6853 unsigned IndexTypeQuals, 6854 SourceRange BracketsRange) { 6855 if (SizeExpr || !Size) 6856 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 6857 IndexTypeQuals, BracketsRange, 6858 getDerived().getBaseEntity()); 6859 6860 QualType Types[] = { 6861 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 6862 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 6863 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 6864 }; 6865 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 6866 QualType SizeType; 6867 for (unsigned I = 0; I != NumTypes; ++I) 6868 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 6869 SizeType = Types[I]; 6870 break; 6871 } 6872 6873 IntegerLiteral ArraySize(SemaRef.Context, *Size, SizeType, 6874 /*FIXME*/BracketsRange.getBegin()); 6875 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 6876 IndexTypeQuals, BracketsRange, 6877 getDerived().getBaseEntity()); 6878} 6879 6880template<typename Derived> 6881QualType 6882TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 6883 ArrayType::ArraySizeModifier SizeMod, 6884 const llvm::APInt &Size, 6885 unsigned IndexTypeQuals, 6886 SourceRange BracketsRange) { 6887 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 6888 IndexTypeQuals, BracketsRange); 6889} 6890 6891template<typename Derived> 6892QualType 6893TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 6894 ArrayType::ArraySizeModifier SizeMod, 6895 unsigned IndexTypeQuals, 6896 SourceRange BracketsRange) { 6897 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 6898 IndexTypeQuals, BracketsRange); 6899} 6900 6901template<typename Derived> 6902QualType 6903TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 6904 ArrayType::ArraySizeModifier SizeMod, 6905 Expr *SizeExpr, 6906 unsigned IndexTypeQuals, 6907 SourceRange BracketsRange) { 6908 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 6909 SizeExpr, 6910 IndexTypeQuals, BracketsRange); 6911} 6912 6913template<typename Derived> 6914QualType 6915TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 6916 ArrayType::ArraySizeModifier SizeMod, 6917 Expr *SizeExpr, 6918 unsigned IndexTypeQuals, 6919 SourceRange BracketsRange) { 6920 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 6921 SizeExpr, 6922 IndexTypeQuals, BracketsRange); 6923} 6924 6925template<typename Derived> 6926QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 6927 unsigned NumElements, 6928 VectorType::VectorKind VecKind) { 6929 // FIXME: semantic checking! 6930 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 6931} 6932 6933template<typename Derived> 6934QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 6935 unsigned NumElements, 6936 SourceLocation AttributeLoc) { 6937 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 6938 NumElements, true); 6939 IntegerLiteral *VectorSize 6940 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 6941 AttributeLoc); 6942 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 6943} 6944 6945template<typename Derived> 6946QualType 6947TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 6948 Expr *SizeExpr, 6949 SourceLocation AttributeLoc) { 6950 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 6951} 6952 6953template<typename Derived> 6954QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 6955 QualType *ParamTypes, 6956 unsigned NumParamTypes, 6957 bool Variadic, 6958 unsigned Quals, 6959 const FunctionType::ExtInfo &Info) { 6960 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 6961 Quals, 6962 getDerived().getBaseLocation(), 6963 getDerived().getBaseEntity(), 6964 Info); 6965} 6966 6967template<typename Derived> 6968QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 6969 return SemaRef.Context.getFunctionNoProtoType(T); 6970} 6971 6972template<typename Derived> 6973QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 6974 assert(D && "no decl found"); 6975 if (D->isInvalidDecl()) return QualType(); 6976 6977 // FIXME: Doesn't account for ObjCInterfaceDecl! 6978 TypeDecl *Ty; 6979 if (isa<UsingDecl>(D)) { 6980 UsingDecl *Using = cast<UsingDecl>(D); 6981 assert(Using->isTypeName() && 6982 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 6983 6984 // A valid resolved using typename decl points to exactly one type decl. 6985 assert(++Using->shadow_begin() == Using->shadow_end()); 6986 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 6987 6988 } else { 6989 assert(isa<UnresolvedUsingTypenameDecl>(D) && 6990 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 6991 Ty = cast<UnresolvedUsingTypenameDecl>(D); 6992 } 6993 6994 return SemaRef.Context.getTypeDeclType(Ty); 6995} 6996 6997template<typename Derived> 6998QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 6999 SourceLocation Loc) { 7000 return SemaRef.BuildTypeofExprType(E, Loc); 7001} 7002 7003template<typename Derived> 7004QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 7005 return SemaRef.Context.getTypeOfType(Underlying); 7006} 7007 7008template<typename Derived> 7009QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 7010 SourceLocation Loc) { 7011 return SemaRef.BuildDecltypeType(E, Loc); 7012} 7013 7014template<typename Derived> 7015QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 7016 TemplateName Template, 7017 SourceLocation TemplateNameLoc, 7018 const TemplateArgumentListInfo &TemplateArgs) { 7019 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 7020} 7021 7022template<typename Derived> 7023NestedNameSpecifier * 7024TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7025 SourceRange Range, 7026 IdentifierInfo &II, 7027 QualType ObjectType, 7028 NamedDecl *FirstQualifierInScope) { 7029 CXXScopeSpec SS; 7030 // FIXME: The source location information is all wrong. 7031 SS.setRange(Range); 7032 SS.setScopeRep(Prefix); 7033 return static_cast<NestedNameSpecifier *>( 7034 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 7035 Range.getEnd(), II, 7036 ObjectType, 7037 FirstQualifierInScope, 7038 false, false)); 7039} 7040 7041template<typename Derived> 7042NestedNameSpecifier * 7043TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7044 SourceRange Range, 7045 NamespaceDecl *NS) { 7046 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 7047} 7048 7049template<typename Derived> 7050NestedNameSpecifier * 7051TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7052 SourceRange Range, 7053 bool TemplateKW, 7054 QualType T) { 7055 if (T->isDependentType() || T->isRecordType() || 7056 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 7057 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 7058 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 7059 T.getTypePtr()); 7060 } 7061 7062 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 7063 return 0; 7064} 7065 7066template<typename Derived> 7067TemplateName 7068TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7069 bool TemplateKW, 7070 TemplateDecl *Template) { 7071 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 7072 Template); 7073} 7074 7075template<typename Derived> 7076TemplateName 7077TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7078 SourceRange QualifierRange, 7079 const IdentifierInfo &II, 7080 QualType ObjectType, 7081 NamedDecl *FirstQualifierInScope) { 7082 CXXScopeSpec SS; 7083 SS.setRange(QualifierRange); 7084 SS.setScopeRep(Qualifier); 7085 UnqualifiedId Name; 7086 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 7087 Sema::TemplateTy Template; 7088 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7089 /*FIXME:*/getDerived().getBaseLocation(), 7090 SS, 7091 Name, 7092 ParsedType::make(ObjectType), 7093 /*EnteringContext=*/false, 7094 Template); 7095 return Template.get(); 7096} 7097 7098template<typename Derived> 7099TemplateName 7100TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7101 OverloadedOperatorKind Operator, 7102 QualType ObjectType) { 7103 CXXScopeSpec SS; 7104 SS.setRange(SourceRange(getDerived().getBaseLocation())); 7105 SS.setScopeRep(Qualifier); 7106 UnqualifiedId Name; 7107 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 7108 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 7109 Operator, SymbolLocations); 7110 Sema::TemplateTy Template; 7111 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7112 /*FIXME:*/getDerived().getBaseLocation(), 7113 SS, 7114 Name, 7115 ParsedType::make(ObjectType), 7116 /*EnteringContext=*/false, 7117 Template); 7118 return Template.template getAsVal<TemplateName>(); 7119} 7120 7121template<typename Derived> 7122ExprResult 7123TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 7124 SourceLocation OpLoc, 7125 Expr *OrigCallee, 7126 Expr *First, 7127 Expr *Second) { 7128 Expr *Callee = OrigCallee->IgnoreParenCasts(); 7129 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 7130 7131 // Determine whether this should be a builtin operation. 7132 if (Op == OO_Subscript) { 7133 if (!First->getType()->isOverloadableType() && 7134 !Second->getType()->isOverloadableType()) 7135 return getSema().CreateBuiltinArraySubscriptExpr(First, 7136 Callee->getLocStart(), 7137 Second, OpLoc); 7138 } else if (Op == OO_Arrow) { 7139 // -> is never a builtin operation. 7140 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 7141 } else if (Second == 0 || isPostIncDec) { 7142 if (!First->getType()->isOverloadableType()) { 7143 // The argument is not of overloadable type, so try to create a 7144 // built-in unary operation. 7145 UnaryOperatorKind Opc 7146 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7147 7148 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 7149 } 7150 } else { 7151 if (!First->getType()->isOverloadableType() && 7152 !Second->getType()->isOverloadableType()) { 7153 // Neither of the arguments is an overloadable type, so try to 7154 // create a built-in binary operation. 7155 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7156 ExprResult Result 7157 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 7158 if (Result.isInvalid()) 7159 return ExprError(); 7160 7161 return move(Result); 7162 } 7163 } 7164 7165 // Compute the transformed set of functions (and function templates) to be 7166 // used during overload resolution. 7167 UnresolvedSet<16> Functions; 7168 7169 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 7170 assert(ULE->requiresADL()); 7171 7172 // FIXME: Do we have to check 7173 // IsAcceptableNonMemberOperatorCandidate for each of these? 7174 Functions.append(ULE->decls_begin(), ULE->decls_end()); 7175 } else { 7176 Functions.addDecl(cast<DeclRefExpr>(Callee)->getDecl()); 7177 } 7178 7179 // Add any functions found via argument-dependent lookup. 7180 Expr *Args[2] = { First, Second }; 7181 unsigned NumArgs = 1 + (Second != 0); 7182 7183 // Create the overloaded operator invocation for unary operators. 7184 if (NumArgs == 1 || isPostIncDec) { 7185 UnaryOperatorKind Opc 7186 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7187 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 7188 } 7189 7190 if (Op == OO_Subscript) 7191 return SemaRef.CreateOverloadedArraySubscriptExpr(Callee->getLocStart(), 7192 OpLoc, 7193 First, 7194 Second); 7195 7196 // Create the overloaded operator invocation for binary operators. 7197 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7198 ExprResult Result 7199 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 7200 if (Result.isInvalid()) 7201 return ExprError(); 7202 7203 return move(Result); 7204} 7205 7206template<typename Derived> 7207ExprResult 7208TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 7209 SourceLocation OperatorLoc, 7210 bool isArrow, 7211 NestedNameSpecifier *Qualifier, 7212 SourceRange QualifierRange, 7213 TypeSourceInfo *ScopeType, 7214 SourceLocation CCLoc, 7215 SourceLocation TildeLoc, 7216 PseudoDestructorTypeStorage Destroyed) { 7217 CXXScopeSpec SS; 7218 if (Qualifier) { 7219 SS.setRange(QualifierRange); 7220 SS.setScopeRep(Qualifier); 7221 } 7222 7223 QualType BaseType = Base->getType(); 7224 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 7225 (!isArrow && !BaseType->getAs<RecordType>()) || 7226 (isArrow && BaseType->getAs<PointerType>() && 7227 !BaseType->getAs<PointerType>()->getPointeeType() 7228 ->template getAs<RecordType>())){ 7229 // This pseudo-destructor expression is still a pseudo-destructor. 7230 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 7231 isArrow? tok::arrow : tok::period, 7232 SS, ScopeType, CCLoc, TildeLoc, 7233 Destroyed, 7234 /*FIXME?*/true); 7235 } 7236 7237 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 7238 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 7239 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 7240 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 7241 NameInfo.setNamedTypeInfo(DestroyedType); 7242 7243 // FIXME: the ScopeType should be tacked onto SS. 7244 7245 return getSema().BuildMemberReferenceExpr(Base, BaseType, 7246 OperatorLoc, isArrow, 7247 SS, /*FIXME: FirstQualifier*/ 0, 7248 NameInfo, 7249 /*TemplateArgs*/ 0); 7250} 7251 7252} // end namespace clang 7253 7254#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 7255