TreeTransform.h revision 711c52bb20d0c69063b52a99826fb7d2835501f1
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 llvm_unreachable("Unsupported pack expansion of templates"); 2127 2128 case TemplateArgument::Null: 2129 case TemplateArgument::Integral: 2130 case TemplateArgument::Declaration: 2131 case TemplateArgument::Pack: 2132 llvm_unreachable("Pack expansion pattern has no parameter packs"); 2133 2134 case TemplateArgument::Type: 2135 if (TypeSourceInfo *Expansion 2136 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(), 2137 EllipsisLoc)) 2138 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()), 2139 Expansion); 2140 break; 2141 } 2142 2143 return TemplateArgumentLoc(); 2144 } 2145 2146 /// \brief Build a new expression pack expansion. 2147 /// 2148 /// By default, performs semantic analysis to build a new pack expansion 2149 /// for an expression. Subclasses may override this routine to provide 2150 /// different behavior. 2151 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { 2152 return getSema().ActOnPackExpansion(Pattern, EllipsisLoc); 2153 } 2154 2155private: 2156 QualType TransformTypeInObjectScope(QualType T, 2157 QualType ObjectType, 2158 NamedDecl *FirstQualifierInScope, 2159 NestedNameSpecifier *Prefix); 2160 2161 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *T, 2162 QualType ObjectType, 2163 NamedDecl *FirstQualifierInScope, 2164 NestedNameSpecifier *Prefix); 2165}; 2166 2167template<typename Derived> 2168StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 2169 if (!S) 2170 return SemaRef.Owned(S); 2171 2172 switch (S->getStmtClass()) { 2173 case Stmt::NoStmtClass: break; 2174 2175 // Transform individual statement nodes 2176#define STMT(Node, Parent) \ 2177 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 2178#define EXPR(Node, Parent) 2179#include "clang/AST/StmtNodes.inc" 2180 2181 // Transform expressions by calling TransformExpr. 2182#define STMT(Node, Parent) 2183#define ABSTRACT_STMT(Stmt) 2184#define EXPR(Node, Parent) case Stmt::Node##Class: 2185#include "clang/AST/StmtNodes.inc" 2186 { 2187 ExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 2188 if (E.isInvalid()) 2189 return StmtError(); 2190 2191 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E.take())); 2192 } 2193 } 2194 2195 return SemaRef.Owned(S); 2196} 2197 2198 2199template<typename Derived> 2200ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { 2201 if (!E) 2202 return SemaRef.Owned(E); 2203 2204 switch (E->getStmtClass()) { 2205 case Stmt::NoStmtClass: break; 2206#define STMT(Node, Parent) case Stmt::Node##Class: break; 2207#define ABSTRACT_STMT(Stmt) 2208#define EXPR(Node, Parent) \ 2209 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 2210#include "clang/AST/StmtNodes.inc" 2211 } 2212 2213 return SemaRef.Owned(E); 2214} 2215 2216template<typename Derived> 2217bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, 2218 unsigned NumInputs, 2219 bool IsCall, 2220 llvm::SmallVectorImpl<Expr *> &Outputs, 2221 bool *ArgChanged) { 2222 for (unsigned I = 0; I != NumInputs; ++I) { 2223 // If requested, drop call arguments that need to be dropped. 2224 if (IsCall && getDerived().DropCallArgument(Inputs[I])) { 2225 if (ArgChanged) 2226 *ArgChanged = true; 2227 2228 break; 2229 } 2230 2231 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Inputs[I])) { 2232 Expr *Pattern = Expansion->getPattern(); 2233 2234 llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2235 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 2236 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 2237 2238 // Determine whether the set of unexpanded parameter packs can and should 2239 // be expanded. 2240 bool Expand = true; 2241 unsigned NumExpansions = 0; 2242 if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), 2243 Pattern->getSourceRange(), 2244 Unexpanded.data(), 2245 Unexpanded.size(), 2246 Expand, NumExpansions)) 2247 return true; 2248 2249 if (!Expand) { 2250 // The transform has determined that we should perform a simple 2251 // transformation on the pack expansion, producing another pack 2252 // expansion. 2253 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2254 ExprResult OutPattern = getDerived().TransformExpr(Pattern); 2255 if (OutPattern.isInvalid()) 2256 return true; 2257 2258 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(), 2259 Expansion->getEllipsisLoc()); 2260 if (Out.isInvalid()) 2261 return true; 2262 2263 if (ArgChanged) 2264 *ArgChanged = true; 2265 Outputs.push_back(Out.get()); 2266 continue; 2267 } 2268 2269 // The transform has determined that we should perform an elementwise 2270 // expansion of the pattern. Do so. 2271 for (unsigned I = 0; I != NumExpansions; ++I) { 2272 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2273 ExprResult Out = getDerived().TransformExpr(Pattern); 2274 if (Out.isInvalid()) 2275 return true; 2276 2277 if (ArgChanged) 2278 *ArgChanged = true; 2279 Outputs.push_back(Out.get()); 2280 } 2281 2282 continue; 2283 } 2284 2285 ExprResult Result = getDerived().TransformExpr(Inputs[I]); 2286 if (Result.isInvalid()) 2287 return true; 2288 2289 if (Result.get() != Inputs[I] && ArgChanged) 2290 *ArgChanged = true; 2291 2292 Outputs.push_back(Result.get()); 2293 } 2294 2295 return false; 2296} 2297 2298template<typename Derived> 2299NestedNameSpecifier * 2300TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 2301 SourceRange Range, 2302 QualType ObjectType, 2303 NamedDecl *FirstQualifierInScope) { 2304 NestedNameSpecifier *Prefix = NNS->getPrefix(); 2305 2306 // Transform the prefix of this nested name specifier. 2307 if (Prefix) { 2308 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, 2309 ObjectType, 2310 FirstQualifierInScope); 2311 if (!Prefix) 2312 return 0; 2313 } 2314 2315 switch (NNS->getKind()) { 2316 case NestedNameSpecifier::Identifier: 2317 if (Prefix) { 2318 // The object type and qualifier-in-scope really apply to the 2319 // leftmost entity. 2320 ObjectType = QualType(); 2321 FirstQualifierInScope = 0; 2322 } 2323 2324 assert((Prefix || !ObjectType.isNull()) && 2325 "Identifier nested-name-specifier with no prefix or object type"); 2326 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && 2327 ObjectType.isNull()) 2328 return NNS; 2329 2330 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 2331 *NNS->getAsIdentifier(), 2332 ObjectType, 2333 FirstQualifierInScope); 2334 2335 case NestedNameSpecifier::Namespace: { 2336 NamespaceDecl *NS 2337 = cast_or_null<NamespaceDecl>( 2338 getDerived().TransformDecl(Range.getBegin(), 2339 NNS->getAsNamespace())); 2340 if (!getDerived().AlwaysRebuild() && 2341 Prefix == NNS->getPrefix() && 2342 NS == NNS->getAsNamespace()) 2343 return NNS; 2344 2345 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 2346 } 2347 2348 case NestedNameSpecifier::Global: 2349 // There is no meaningful transformation that one could perform on the 2350 // global scope. 2351 return NNS; 2352 2353 case NestedNameSpecifier::TypeSpecWithTemplate: 2354 case NestedNameSpecifier::TypeSpec: { 2355 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName()); 2356 QualType T = TransformTypeInObjectScope(QualType(NNS->getAsType(), 0), 2357 ObjectType, 2358 FirstQualifierInScope, 2359 Prefix); 2360 if (T.isNull()) 2361 return 0; 2362 2363 if (!getDerived().AlwaysRebuild() && 2364 Prefix == NNS->getPrefix() && 2365 T == QualType(NNS->getAsType(), 0)) 2366 return NNS; 2367 2368 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 2369 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 2370 T); 2371 } 2372 } 2373 2374 // Required to silence a GCC warning 2375 return 0; 2376} 2377 2378template<typename Derived> 2379DeclarationNameInfo 2380TreeTransform<Derived> 2381::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) { 2382 DeclarationName Name = NameInfo.getName(); 2383 if (!Name) 2384 return DeclarationNameInfo(); 2385 2386 switch (Name.getNameKind()) { 2387 case DeclarationName::Identifier: 2388 case DeclarationName::ObjCZeroArgSelector: 2389 case DeclarationName::ObjCOneArgSelector: 2390 case DeclarationName::ObjCMultiArgSelector: 2391 case DeclarationName::CXXOperatorName: 2392 case DeclarationName::CXXLiteralOperatorName: 2393 case DeclarationName::CXXUsingDirective: 2394 return NameInfo; 2395 2396 case DeclarationName::CXXConstructorName: 2397 case DeclarationName::CXXDestructorName: 2398 case DeclarationName::CXXConversionFunctionName: { 2399 TypeSourceInfo *NewTInfo; 2400 CanQualType NewCanTy; 2401 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) { 2402 NewTInfo = getDerived().TransformType(OldTInfo); 2403 if (!NewTInfo) 2404 return DeclarationNameInfo(); 2405 NewCanTy = SemaRef.Context.getCanonicalType(NewTInfo->getType()); 2406 } 2407 else { 2408 NewTInfo = 0; 2409 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name); 2410 QualType NewT = getDerived().TransformType(Name.getCXXNameType()); 2411 if (NewT.isNull()) 2412 return DeclarationNameInfo(); 2413 NewCanTy = SemaRef.Context.getCanonicalType(NewT); 2414 } 2415 2416 DeclarationName NewName 2417 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Name.getNameKind(), 2418 NewCanTy); 2419 DeclarationNameInfo NewNameInfo(NameInfo); 2420 NewNameInfo.setName(NewName); 2421 NewNameInfo.setNamedTypeInfo(NewTInfo); 2422 return NewNameInfo; 2423 } 2424 } 2425 2426 assert(0 && "Unknown name kind."); 2427 return DeclarationNameInfo(); 2428} 2429 2430template<typename Derived> 2431TemplateName 2432TreeTransform<Derived>::TransformTemplateName(TemplateName Name, 2433 QualType ObjectType, 2434 NamedDecl *FirstQualifierInScope) { 2435 SourceLocation Loc = getDerived().getBaseLocation(); 2436 2437 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 2438 NestedNameSpecifier *NNS 2439 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 2440 /*FIXME*/ SourceRange(Loc), 2441 ObjectType, 2442 FirstQualifierInScope); 2443 if (!NNS) 2444 return TemplateName(); 2445 2446 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 2447 TemplateDecl *TransTemplate 2448 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template)); 2449 if (!TransTemplate) 2450 return TemplateName(); 2451 2452 if (!getDerived().AlwaysRebuild() && 2453 NNS == QTN->getQualifier() && 2454 TransTemplate == Template) 2455 return Name; 2456 2457 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 2458 TransTemplate); 2459 } 2460 2461 // These should be getting filtered out before they make it into the AST. 2462 llvm_unreachable("overloaded template name survived to here"); 2463 } 2464 2465 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 2466 NestedNameSpecifier *NNS = DTN->getQualifier(); 2467 if (NNS) { 2468 NNS = getDerived().TransformNestedNameSpecifier(NNS, 2469 /*FIXME:*/SourceRange(Loc), 2470 ObjectType, 2471 FirstQualifierInScope); 2472 if (!NNS) return TemplateName(); 2473 2474 // These apply to the scope specifier, not the template. 2475 ObjectType = QualType(); 2476 FirstQualifierInScope = 0; 2477 } 2478 2479 if (!getDerived().AlwaysRebuild() && 2480 NNS == DTN->getQualifier() && 2481 ObjectType.isNull()) 2482 return Name; 2483 2484 if (DTN->isIdentifier()) { 2485 // FIXME: Bad range 2486 SourceRange QualifierRange(getDerived().getBaseLocation()); 2487 return getDerived().RebuildTemplateName(NNS, QualifierRange, 2488 *DTN->getIdentifier(), 2489 ObjectType, 2490 FirstQualifierInScope); 2491 } 2492 2493 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(), 2494 ObjectType); 2495 } 2496 2497 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 2498 TemplateDecl *TransTemplate 2499 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template)); 2500 if (!TransTemplate) 2501 return TemplateName(); 2502 2503 if (!getDerived().AlwaysRebuild() && 2504 TransTemplate == Template) 2505 return Name; 2506 2507 return TemplateName(TransTemplate); 2508 } 2509 2510 // These should be getting filtered out before they reach the AST. 2511 llvm_unreachable("overloaded function decl survived to here"); 2512 return TemplateName(); 2513} 2514 2515template<typename Derived> 2516void TreeTransform<Derived>::InventTemplateArgumentLoc( 2517 const TemplateArgument &Arg, 2518 TemplateArgumentLoc &Output) { 2519 SourceLocation Loc = getDerived().getBaseLocation(); 2520 switch (Arg.getKind()) { 2521 case TemplateArgument::Null: 2522 llvm_unreachable("null template argument in TreeTransform"); 2523 break; 2524 2525 case TemplateArgument::Type: 2526 Output = TemplateArgumentLoc(Arg, 2527 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 2528 2529 break; 2530 2531 case TemplateArgument::Template: 2532 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc); 2533 break; 2534 2535 case TemplateArgument::Expression: 2536 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 2537 break; 2538 2539 case TemplateArgument::Declaration: 2540 case TemplateArgument::Integral: 2541 case TemplateArgument::Pack: 2542 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 2543 break; 2544 } 2545} 2546 2547template<typename Derived> 2548bool TreeTransform<Derived>::TransformTemplateArgument( 2549 const TemplateArgumentLoc &Input, 2550 TemplateArgumentLoc &Output) { 2551 const TemplateArgument &Arg = Input.getArgument(); 2552 switch (Arg.getKind()) { 2553 case TemplateArgument::Null: 2554 case TemplateArgument::Integral: 2555 Output = Input; 2556 return false; 2557 2558 case TemplateArgument::Type: { 2559 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 2560 if (DI == NULL) 2561 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 2562 2563 DI = getDerived().TransformType(DI); 2564 if (!DI) return true; 2565 2566 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 2567 return false; 2568 } 2569 2570 case TemplateArgument::Declaration: { 2571 // FIXME: we should never have to transform one of these. 2572 DeclarationName Name; 2573 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) 2574 Name = ND->getDeclName(); 2575 TemporaryBase Rebase(*this, Input.getLocation(), Name); 2576 Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl()); 2577 if (!D) return true; 2578 2579 Expr *SourceExpr = Input.getSourceDeclExpression(); 2580 if (SourceExpr) { 2581 EnterExpressionEvaluationContext Unevaluated(getSema(), 2582 Sema::Unevaluated); 2583 ExprResult E = getDerived().TransformExpr(SourceExpr); 2584 SourceExpr = (E.isInvalid() ? 0 : E.take()); 2585 } 2586 2587 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr); 2588 return false; 2589 } 2590 2591 case TemplateArgument::Template: { 2592 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName()); 2593 TemplateName Template 2594 = getDerived().TransformTemplateName(Arg.getAsTemplate()); 2595 if (Template.isNull()) 2596 return true; 2597 2598 Output = TemplateArgumentLoc(TemplateArgument(Template), 2599 Input.getTemplateQualifierRange(), 2600 Input.getTemplateNameLoc()); 2601 return false; 2602 } 2603 2604 case TemplateArgument::Expression: { 2605 // Template argument expressions are not potentially evaluated. 2606 EnterExpressionEvaluationContext Unevaluated(getSema(), 2607 Sema::Unevaluated); 2608 2609 Expr *InputExpr = Input.getSourceExpression(); 2610 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 2611 2612 ExprResult E 2613 = getDerived().TransformExpr(InputExpr); 2614 if (E.isInvalid()) return true; 2615 Output = TemplateArgumentLoc(TemplateArgument(E.take()), E.take()); 2616 return false; 2617 } 2618 2619 case TemplateArgument::Pack: { 2620 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 2621 TransformedArgs.reserve(Arg.pack_size()); 2622 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 2623 AEnd = Arg.pack_end(); 2624 A != AEnd; ++A) { 2625 2626 // FIXME: preserve source information here when we start 2627 // caring about parameter packs. 2628 2629 TemplateArgumentLoc InputArg; 2630 TemplateArgumentLoc OutputArg; 2631 getDerived().InventTemplateArgumentLoc(*A, InputArg); 2632 if (getDerived().TransformTemplateArgument(InputArg, OutputArg)) 2633 return true; 2634 2635 TransformedArgs.push_back(OutputArg.getArgument()); 2636 } 2637 2638 TemplateArgument *TransformedArgsPtr 2639 = new (getSema().Context) TemplateArgument[TransformedArgs.size()]; 2640 std::copy(TransformedArgs.begin(), TransformedArgs.end(), 2641 TransformedArgsPtr); 2642 Output = TemplateArgumentLoc(TemplateArgument(TransformedArgsPtr, 2643 TransformedArgs.size()), 2644 Input.getLocInfo()); 2645 return false; 2646 } 2647 } 2648 2649 // Work around bogus GCC warning 2650 return true; 2651} 2652 2653/// \brief Iterator adaptor that invents template argument location information 2654/// for each of the template arguments in its underlying iterator. 2655template<typename Derived, typename InputIterator> 2656class TemplateArgumentLocInventIterator { 2657 TreeTransform<Derived> &Self; 2658 InputIterator Iter; 2659 2660public: 2661 typedef TemplateArgumentLoc value_type; 2662 typedef TemplateArgumentLoc reference; 2663 typedef typename std::iterator_traits<InputIterator>::difference_type 2664 difference_type; 2665 typedef std::input_iterator_tag iterator_category; 2666 2667 class pointer { 2668 TemplateArgumentLoc Arg; 2669 2670 public: 2671 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 2672 2673 const TemplateArgumentLoc *operator->() const { return &Arg; } 2674 }; 2675 2676 TemplateArgumentLocInventIterator() { } 2677 2678 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self, 2679 InputIterator Iter) 2680 : Self(Self), Iter(Iter) { } 2681 2682 TemplateArgumentLocInventIterator &operator++() { 2683 ++Iter; 2684 return *this; 2685 } 2686 2687 TemplateArgumentLocInventIterator operator++(int) { 2688 TemplateArgumentLocInventIterator Old(*this); 2689 ++(*this); 2690 return Old; 2691 } 2692 2693 reference operator*() const { 2694 TemplateArgumentLoc Result; 2695 Self.InventTemplateArgumentLoc(*Iter, Result); 2696 return Result; 2697 } 2698 2699 pointer operator->() const { return pointer(**this); } 2700 2701 friend bool operator==(const TemplateArgumentLocInventIterator &X, 2702 const TemplateArgumentLocInventIterator &Y) { 2703 return X.Iter == Y.Iter; 2704 } 2705 2706 friend bool operator!=(const TemplateArgumentLocInventIterator &X, 2707 const TemplateArgumentLocInventIterator &Y) { 2708 return X.Iter != Y.Iter; 2709 } 2710}; 2711 2712template<typename Derived> 2713template<typename InputIterator> 2714bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, 2715 InputIterator Last, 2716 TemplateArgumentListInfo &Outputs) { 2717 for (; First != Last; ++First) { 2718 TemplateArgumentLoc Out; 2719 TemplateArgumentLoc In = *First; 2720 2721 if (In.getArgument().getKind() == TemplateArgument::Pack) { 2722 // Unpack argument packs, which we translate them into separate 2723 // arguments. 2724 // FIXME: We could do much better if we could guarantee that the 2725 // TemplateArgumentLocInfo for the pack expansion would be usable for 2726 // all of the template arguments in the argument pack. 2727 typedef TemplateArgumentLocInventIterator<Derived, 2728 TemplateArgument::pack_iterator> 2729 PackLocIterator; 2730 if (TransformTemplateArguments(PackLocIterator(*this, 2731 In.getArgument().pack_begin()), 2732 PackLocIterator(*this, 2733 In.getArgument().pack_end()), 2734 Outputs)) 2735 return true; 2736 2737 continue; 2738 } 2739 2740 if (In.getArgument().isPackExpansion()) { 2741 // We have a pack expansion, for which we will be substituting into 2742 // the pattern. 2743 SourceLocation Ellipsis; 2744 TemplateArgumentLoc Pattern 2745 = In.getPackExpansionPattern(Ellipsis, getSema().Context); 2746 2747 llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded; 2748 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded); 2749 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?"); 2750 2751 // Determine whether the set of unexpanded parameter packs can and should 2752 // be expanded. 2753 bool Expand = true; 2754 unsigned NumExpansions = 0; 2755 if (getDerived().TryExpandParameterPacks(Ellipsis, 2756 Pattern.getSourceRange(), 2757 Unexpanded.data(), 2758 Unexpanded.size(), 2759 Expand, NumExpansions)) 2760 return true; 2761 2762 if (!Expand) { 2763 // The transform has determined that we should perform a simple 2764 // transformation on the pack expansion, producing another pack 2765 // expansion. 2766 TemplateArgumentLoc OutPattern; 2767 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1); 2768 if (getDerived().TransformTemplateArgument(Pattern, OutPattern)) 2769 return true; 2770 2771 Out = getDerived().RebuildPackExpansion(OutPattern, Ellipsis); 2772 if (Out.getArgument().isNull()) 2773 return true; 2774 2775 Outputs.addArgument(Out); 2776 continue; 2777 } 2778 2779 // The transform has determined that we should perform an elementwise 2780 // expansion of the pattern. Do so. 2781 for (unsigned I = 0; I != NumExpansions; ++I) { 2782 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I); 2783 2784 if (getDerived().TransformTemplateArgument(Pattern, Out)) 2785 return true; 2786 2787 Outputs.addArgument(Out); 2788 } 2789 2790 continue; 2791 } 2792 2793 // The simple case: 2794 if (getDerived().TransformTemplateArgument(In, Out)) 2795 return true; 2796 2797 Outputs.addArgument(Out); 2798 } 2799 2800 return false; 2801 2802} 2803 2804//===----------------------------------------------------------------------===// 2805// Type transformation 2806//===----------------------------------------------------------------------===// 2807 2808template<typename Derived> 2809QualType TreeTransform<Derived>::TransformType(QualType T) { 2810 if (getDerived().AlreadyTransformed(T)) 2811 return T; 2812 2813 // Temporary workaround. All of these transformations should 2814 // eventually turn into transformations on TypeLocs. 2815 TypeSourceInfo *DI = getSema().Context.CreateTypeSourceInfo(T); 2816 DI->getTypeLoc().initialize(getDerived().getBaseLocation()); 2817 2818 TypeSourceInfo *NewDI = getDerived().TransformType(DI); 2819 2820 if (!NewDI) 2821 return QualType(); 2822 2823 return NewDI->getType(); 2824} 2825 2826template<typename Derived> 2827TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI) { 2828 if (getDerived().AlreadyTransformed(DI->getType())) 2829 return DI; 2830 2831 TypeLocBuilder TLB; 2832 2833 TypeLoc TL = DI->getTypeLoc(); 2834 TLB.reserve(TL.getFullDataSize()); 2835 2836 QualType Result = getDerived().TransformType(TLB, TL); 2837 if (Result.isNull()) 2838 return 0; 2839 2840 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 2841} 2842 2843template<typename Derived> 2844QualType 2845TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 2846 switch (T.getTypeLocClass()) { 2847#define ABSTRACT_TYPELOC(CLASS, PARENT) 2848#define TYPELOC(CLASS, PARENT) \ 2849 case TypeLoc::CLASS: \ 2850 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T)); 2851#include "clang/AST/TypeLocNodes.def" 2852 } 2853 2854 llvm_unreachable("unhandled type loc!"); 2855 return QualType(); 2856} 2857 2858/// FIXME: By default, this routine adds type qualifiers only to types 2859/// that can have qualifiers, and silently suppresses those qualifiers 2860/// that are not permitted (e.g., qualifiers on reference or function 2861/// types). This is the right thing for template instantiation, but 2862/// probably not for other clients. 2863template<typename Derived> 2864QualType 2865TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 2866 QualifiedTypeLoc T) { 2867 Qualifiers Quals = T.getType().getLocalQualifiers(); 2868 2869 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 2870 if (Result.isNull()) 2871 return QualType(); 2872 2873 // Silently suppress qualifiers if the result type can't be qualified. 2874 // FIXME: this is the right thing for template instantiation, but 2875 // probably not for other clients. 2876 if (Result->isFunctionType() || Result->isReferenceType()) 2877 return Result; 2878 2879 if (!Quals.empty()) { 2880 Result = SemaRef.BuildQualifiedType(Result, T.getBeginLoc(), Quals); 2881 TLB.push<QualifiedTypeLoc>(Result); 2882 // No location information to preserve. 2883 } 2884 2885 return Result; 2886} 2887 2888/// \brief Transforms a type that was written in a scope specifier, 2889/// given an object type, the results of unqualified lookup, and 2890/// an already-instantiated prefix. 2891/// 2892/// The object type is provided iff the scope specifier qualifies the 2893/// member of a dependent member-access expression. The prefix is 2894/// provided iff the the scope specifier in which this appears has a 2895/// prefix. 2896/// 2897/// This is private to TreeTransform. 2898template<typename Derived> 2899QualType 2900TreeTransform<Derived>::TransformTypeInObjectScope(QualType T, 2901 QualType ObjectType, 2902 NamedDecl *UnqualLookup, 2903 NestedNameSpecifier *Prefix) { 2904 if (getDerived().AlreadyTransformed(T)) 2905 return T; 2906 2907 TypeSourceInfo *TSI = 2908 SemaRef.Context.getTrivialTypeSourceInfo(T, getBaseLocation()); 2909 2910 TSI = getDerived().TransformTypeInObjectScope(TSI, ObjectType, 2911 UnqualLookup, Prefix); 2912 if (!TSI) return QualType(); 2913 return TSI->getType(); 2914} 2915 2916template<typename Derived> 2917TypeSourceInfo * 2918TreeTransform<Derived>::TransformTypeInObjectScope(TypeSourceInfo *TSI, 2919 QualType ObjectType, 2920 NamedDecl *UnqualLookup, 2921 NestedNameSpecifier *Prefix) { 2922 // TODO: in some cases, we might be some verification to do here. 2923 if (ObjectType.isNull()) 2924 return getDerived().TransformType(TSI); 2925 2926 QualType T = TSI->getType(); 2927 if (getDerived().AlreadyTransformed(T)) 2928 return TSI; 2929 2930 TypeLocBuilder TLB; 2931 QualType Result; 2932 2933 if (isa<TemplateSpecializationType>(T)) { 2934 TemplateSpecializationTypeLoc TL 2935 = cast<TemplateSpecializationTypeLoc>(TSI->getTypeLoc()); 2936 2937 TemplateName Template = 2938 getDerived().TransformTemplateName(TL.getTypePtr()->getTemplateName(), 2939 ObjectType, UnqualLookup); 2940 if (Template.isNull()) return 0; 2941 2942 Result = getDerived() 2943 .TransformTemplateSpecializationType(TLB, TL, Template); 2944 } else if (isa<DependentTemplateSpecializationType>(T)) { 2945 DependentTemplateSpecializationTypeLoc TL 2946 = cast<DependentTemplateSpecializationTypeLoc>(TSI->getTypeLoc()); 2947 2948 Result = getDerived() 2949 .TransformDependentTemplateSpecializationType(TLB, TL, Prefix); 2950 } else { 2951 // Nothing special needs to be done for these. 2952 Result = getDerived().TransformType(TLB, TSI->getTypeLoc()); 2953 } 2954 2955 if (Result.isNull()) return 0; 2956 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 2957} 2958 2959template <class TyLoc> static inline 2960QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 2961 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 2962 NewT.setNameLoc(T.getNameLoc()); 2963 return T.getType(); 2964} 2965 2966template<typename Derived> 2967QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 2968 BuiltinTypeLoc T) { 2969 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 2970 NewT.setBuiltinLoc(T.getBuiltinLoc()); 2971 if (T.needsExtraLocalData()) 2972 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 2973 return T.getType(); 2974} 2975 2976template<typename Derived> 2977QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 2978 ComplexTypeLoc T) { 2979 // FIXME: recurse? 2980 return TransformTypeSpecType(TLB, T); 2981} 2982 2983template<typename Derived> 2984QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 2985 PointerTypeLoc TL) { 2986 QualType PointeeType 2987 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2988 if (PointeeType.isNull()) 2989 return QualType(); 2990 2991 QualType Result = TL.getType(); 2992 if (PointeeType->getAs<ObjCObjectType>()) { 2993 // A dependent pointer type 'T *' has is being transformed such 2994 // that an Objective-C class type is being replaced for 'T'. The 2995 // resulting pointer type is an ObjCObjectPointerType, not a 2996 // PointerType. 2997 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType); 2998 2999 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 3000 NewT.setStarLoc(TL.getStarLoc()); 3001 return Result; 3002 } 3003 3004 if (getDerived().AlwaysRebuild() || 3005 PointeeType != TL.getPointeeLoc().getType()) { 3006 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 3007 if (Result.isNull()) 3008 return QualType(); 3009 } 3010 3011 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 3012 NewT.setSigilLoc(TL.getSigilLoc()); 3013 return Result; 3014} 3015 3016template<typename Derived> 3017QualType 3018TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 3019 BlockPointerTypeLoc TL) { 3020 QualType PointeeType 3021 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3022 if (PointeeType.isNull()) 3023 return QualType(); 3024 3025 QualType Result = TL.getType(); 3026 if (getDerived().AlwaysRebuild() || 3027 PointeeType != TL.getPointeeLoc().getType()) { 3028 Result = getDerived().RebuildBlockPointerType(PointeeType, 3029 TL.getSigilLoc()); 3030 if (Result.isNull()) 3031 return QualType(); 3032 } 3033 3034 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(Result); 3035 NewT.setSigilLoc(TL.getSigilLoc()); 3036 return Result; 3037} 3038 3039/// Transforms a reference type. Note that somewhat paradoxically we 3040/// don't care whether the type itself is an l-value type or an r-value 3041/// type; we only care if the type was *written* as an l-value type 3042/// or an r-value type. 3043template<typename Derived> 3044QualType 3045TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 3046 ReferenceTypeLoc TL) { 3047 const ReferenceType *T = TL.getTypePtr(); 3048 3049 // Note that this works with the pointee-as-written. 3050 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3051 if (PointeeType.isNull()) 3052 return QualType(); 3053 3054 QualType Result = TL.getType(); 3055 if (getDerived().AlwaysRebuild() || 3056 PointeeType != T->getPointeeTypeAsWritten()) { 3057 Result = getDerived().RebuildReferenceType(PointeeType, 3058 T->isSpelledAsLValue(), 3059 TL.getSigilLoc()); 3060 if (Result.isNull()) 3061 return QualType(); 3062 } 3063 3064 // r-value references can be rebuilt as l-value references. 3065 ReferenceTypeLoc NewTL; 3066 if (isa<LValueReferenceType>(Result)) 3067 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 3068 else 3069 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 3070 NewTL.setSigilLoc(TL.getSigilLoc()); 3071 3072 return Result; 3073} 3074 3075template<typename Derived> 3076QualType 3077TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 3078 LValueReferenceTypeLoc TL) { 3079 return TransformReferenceType(TLB, TL); 3080} 3081 3082template<typename Derived> 3083QualType 3084TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 3085 RValueReferenceTypeLoc TL) { 3086 return TransformReferenceType(TLB, TL); 3087} 3088 3089template<typename Derived> 3090QualType 3091TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 3092 MemberPointerTypeLoc TL) { 3093 MemberPointerType *T = TL.getTypePtr(); 3094 3095 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 3096 if (PointeeType.isNull()) 3097 return QualType(); 3098 3099 // TODO: preserve source information for this. 3100 QualType ClassType 3101 = getDerived().TransformType(QualType(T->getClass(), 0)); 3102 if (ClassType.isNull()) 3103 return QualType(); 3104 3105 QualType Result = TL.getType(); 3106 if (getDerived().AlwaysRebuild() || 3107 PointeeType != T->getPointeeType() || 3108 ClassType != QualType(T->getClass(), 0)) { 3109 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType, 3110 TL.getStarLoc()); 3111 if (Result.isNull()) 3112 return QualType(); 3113 } 3114 3115 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 3116 NewTL.setSigilLoc(TL.getSigilLoc()); 3117 3118 return Result; 3119} 3120 3121template<typename Derived> 3122QualType 3123TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 3124 ConstantArrayTypeLoc TL) { 3125 ConstantArrayType *T = TL.getTypePtr(); 3126 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3127 if (ElementType.isNull()) 3128 return QualType(); 3129 3130 QualType Result = TL.getType(); 3131 if (getDerived().AlwaysRebuild() || 3132 ElementType != T->getElementType()) { 3133 Result = getDerived().RebuildConstantArrayType(ElementType, 3134 T->getSizeModifier(), 3135 T->getSize(), 3136 T->getIndexTypeCVRQualifiers(), 3137 TL.getBracketsRange()); 3138 if (Result.isNull()) 3139 return QualType(); 3140 } 3141 3142 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 3143 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3144 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3145 3146 Expr *Size = TL.getSizeExpr(); 3147 if (Size) { 3148 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3149 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 3150 } 3151 NewTL.setSizeExpr(Size); 3152 3153 return Result; 3154} 3155 3156template<typename Derived> 3157QualType TreeTransform<Derived>::TransformIncompleteArrayType( 3158 TypeLocBuilder &TLB, 3159 IncompleteArrayTypeLoc TL) { 3160 IncompleteArrayType *T = TL.getTypePtr(); 3161 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3162 if (ElementType.isNull()) 3163 return QualType(); 3164 3165 QualType Result = TL.getType(); 3166 if (getDerived().AlwaysRebuild() || 3167 ElementType != T->getElementType()) { 3168 Result = getDerived().RebuildIncompleteArrayType(ElementType, 3169 T->getSizeModifier(), 3170 T->getIndexTypeCVRQualifiers(), 3171 TL.getBracketsRange()); 3172 if (Result.isNull()) 3173 return QualType(); 3174 } 3175 3176 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 3177 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3178 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3179 NewTL.setSizeExpr(0); 3180 3181 return Result; 3182} 3183 3184template<typename Derived> 3185QualType 3186TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 3187 VariableArrayTypeLoc TL) { 3188 VariableArrayType *T = TL.getTypePtr(); 3189 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3190 if (ElementType.isNull()) 3191 return QualType(); 3192 3193 // Array bounds are not potentially evaluated contexts 3194 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3195 3196 ExprResult SizeResult 3197 = getDerived().TransformExpr(T->getSizeExpr()); 3198 if (SizeResult.isInvalid()) 3199 return QualType(); 3200 3201 Expr *Size = SizeResult.take(); 3202 3203 QualType Result = TL.getType(); 3204 if (getDerived().AlwaysRebuild() || 3205 ElementType != T->getElementType() || 3206 Size != T->getSizeExpr()) { 3207 Result = getDerived().RebuildVariableArrayType(ElementType, 3208 T->getSizeModifier(), 3209 Size, 3210 T->getIndexTypeCVRQualifiers(), 3211 TL.getBracketsRange()); 3212 if (Result.isNull()) 3213 return QualType(); 3214 } 3215 3216 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 3217 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3218 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3219 NewTL.setSizeExpr(Size); 3220 3221 return Result; 3222} 3223 3224template<typename Derived> 3225QualType 3226TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 3227 DependentSizedArrayTypeLoc TL) { 3228 DependentSizedArrayType *T = TL.getTypePtr(); 3229 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 3230 if (ElementType.isNull()) 3231 return QualType(); 3232 3233 // Array bounds are not potentially evaluated contexts 3234 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3235 3236 ExprResult SizeResult 3237 = getDerived().TransformExpr(T->getSizeExpr()); 3238 if (SizeResult.isInvalid()) 3239 return QualType(); 3240 3241 Expr *Size = static_cast<Expr*>(SizeResult.get()); 3242 3243 QualType Result = TL.getType(); 3244 if (getDerived().AlwaysRebuild() || 3245 ElementType != T->getElementType() || 3246 Size != T->getSizeExpr()) { 3247 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 3248 T->getSizeModifier(), 3249 Size, 3250 T->getIndexTypeCVRQualifiers(), 3251 TL.getBracketsRange()); 3252 if (Result.isNull()) 3253 return QualType(); 3254 } 3255 else SizeResult.take(); 3256 3257 // We might have any sort of array type now, but fortunately they 3258 // all have the same location layout. 3259 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 3260 NewTL.setLBracketLoc(TL.getLBracketLoc()); 3261 NewTL.setRBracketLoc(TL.getRBracketLoc()); 3262 NewTL.setSizeExpr(Size); 3263 3264 return Result; 3265} 3266 3267template<typename Derived> 3268QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 3269 TypeLocBuilder &TLB, 3270 DependentSizedExtVectorTypeLoc TL) { 3271 DependentSizedExtVectorType *T = TL.getTypePtr(); 3272 3273 // FIXME: ext vector locs should be nested 3274 QualType ElementType = getDerived().TransformType(T->getElementType()); 3275 if (ElementType.isNull()) 3276 return QualType(); 3277 3278 // Vector sizes are not potentially evaluated contexts 3279 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3280 3281 ExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 3282 if (Size.isInvalid()) 3283 return QualType(); 3284 3285 QualType Result = TL.getType(); 3286 if (getDerived().AlwaysRebuild() || 3287 ElementType != T->getElementType() || 3288 Size.get() != T->getSizeExpr()) { 3289 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 3290 Size.take(), 3291 T->getAttributeLoc()); 3292 if (Result.isNull()) 3293 return QualType(); 3294 } 3295 3296 // Result might be dependent or not. 3297 if (isa<DependentSizedExtVectorType>(Result)) { 3298 DependentSizedExtVectorTypeLoc NewTL 3299 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 3300 NewTL.setNameLoc(TL.getNameLoc()); 3301 } else { 3302 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3303 NewTL.setNameLoc(TL.getNameLoc()); 3304 } 3305 3306 return Result; 3307} 3308 3309template<typename Derived> 3310QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 3311 VectorTypeLoc TL) { 3312 VectorType *T = TL.getTypePtr(); 3313 QualType ElementType = getDerived().TransformType(T->getElementType()); 3314 if (ElementType.isNull()) 3315 return QualType(); 3316 3317 QualType Result = TL.getType(); 3318 if (getDerived().AlwaysRebuild() || 3319 ElementType != T->getElementType()) { 3320 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 3321 T->getVectorKind()); 3322 if (Result.isNull()) 3323 return QualType(); 3324 } 3325 3326 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 3327 NewTL.setNameLoc(TL.getNameLoc()); 3328 3329 return Result; 3330} 3331 3332template<typename Derived> 3333QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 3334 ExtVectorTypeLoc TL) { 3335 VectorType *T = TL.getTypePtr(); 3336 QualType ElementType = getDerived().TransformType(T->getElementType()); 3337 if (ElementType.isNull()) 3338 return QualType(); 3339 3340 QualType Result = TL.getType(); 3341 if (getDerived().AlwaysRebuild() || 3342 ElementType != T->getElementType()) { 3343 Result = getDerived().RebuildExtVectorType(ElementType, 3344 T->getNumElements(), 3345 /*FIXME*/ SourceLocation()); 3346 if (Result.isNull()) 3347 return QualType(); 3348 } 3349 3350 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 3351 NewTL.setNameLoc(TL.getNameLoc()); 3352 3353 return Result; 3354} 3355 3356template<typename Derived> 3357ParmVarDecl * 3358TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm) { 3359 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 3360 TypeSourceInfo *NewDI = getDerived().TransformType(OldDI); 3361 if (!NewDI) 3362 return 0; 3363 3364 if (NewDI == OldDI) 3365 return OldParm; 3366 else 3367 return ParmVarDecl::Create(SemaRef.Context, 3368 OldParm->getDeclContext(), 3369 OldParm->getLocation(), 3370 OldParm->getIdentifier(), 3371 NewDI->getType(), 3372 NewDI, 3373 OldParm->getStorageClass(), 3374 OldParm->getStorageClassAsWritten(), 3375 /* DefArg */ NULL); 3376} 3377 3378template<typename Derived> 3379bool TreeTransform<Derived>:: 3380 TransformFunctionTypeParams(FunctionProtoTypeLoc TL, 3381 llvm::SmallVectorImpl<QualType> &PTypes, 3382 llvm::SmallVectorImpl<ParmVarDecl*> &PVars) { 3383 FunctionProtoType *T = TL.getTypePtr(); 3384 3385 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3386 ParmVarDecl *OldParm = TL.getArg(i); 3387 3388 QualType NewType; 3389 ParmVarDecl *NewParm; 3390 3391 if (OldParm) { 3392 NewParm = getDerived().TransformFunctionTypeParam(OldParm); 3393 if (!NewParm) 3394 return true; 3395 NewType = NewParm->getType(); 3396 3397 // Deal with the possibility that we don't have a parameter 3398 // declaration for this parameter. 3399 } else { 3400 NewParm = 0; 3401 3402 QualType OldType = T->getArgType(i); 3403 NewType = getDerived().TransformType(OldType); 3404 if (NewType.isNull()) 3405 return true; 3406 } 3407 3408 PTypes.push_back(NewType); 3409 PVars.push_back(NewParm); 3410 } 3411 3412 return false; 3413} 3414 3415template<typename Derived> 3416QualType 3417TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 3418 FunctionProtoTypeLoc TL) { 3419 // Transform the parameters and return type. 3420 // 3421 // We instantiate in source order, with the return type first followed by 3422 // the parameters, because users tend to expect this (even if they shouldn't 3423 // rely on it!). 3424 // 3425 // When the function has a trailing return type, we instantiate the 3426 // parameters before the return type, since the return type can then refer 3427 // to the parameters themselves (via decltype, sizeof, etc.). 3428 // 3429 llvm::SmallVector<QualType, 4> ParamTypes; 3430 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 3431 FunctionProtoType *T = TL.getTypePtr(); 3432 3433 QualType ResultType; 3434 3435 if (TL.getTrailingReturn()) { 3436 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls)) 3437 return QualType(); 3438 3439 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3440 if (ResultType.isNull()) 3441 return QualType(); 3442 } 3443 else { 3444 ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3445 if (ResultType.isNull()) 3446 return QualType(); 3447 3448 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls)) 3449 return QualType(); 3450 } 3451 3452 QualType Result = TL.getType(); 3453 if (getDerived().AlwaysRebuild() || 3454 ResultType != T->getResultType() || 3455 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 3456 Result = getDerived().RebuildFunctionProtoType(ResultType, 3457 ParamTypes.data(), 3458 ParamTypes.size(), 3459 T->isVariadic(), 3460 T->getTypeQuals(), 3461 T->getExtInfo()); 3462 if (Result.isNull()) 3463 return QualType(); 3464 } 3465 3466 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 3467 NewTL.setLParenLoc(TL.getLParenLoc()); 3468 NewTL.setRParenLoc(TL.getRParenLoc()); 3469 NewTL.setTrailingReturn(TL.getTrailingReturn()); 3470 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 3471 NewTL.setArg(i, ParamDecls[i]); 3472 3473 return Result; 3474} 3475 3476template<typename Derived> 3477QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 3478 TypeLocBuilder &TLB, 3479 FunctionNoProtoTypeLoc TL) { 3480 FunctionNoProtoType *T = TL.getTypePtr(); 3481 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 3482 if (ResultType.isNull()) 3483 return QualType(); 3484 3485 QualType Result = TL.getType(); 3486 if (getDerived().AlwaysRebuild() || 3487 ResultType != T->getResultType()) 3488 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 3489 3490 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 3491 NewTL.setLParenLoc(TL.getLParenLoc()); 3492 NewTL.setRParenLoc(TL.getRParenLoc()); 3493 NewTL.setTrailingReturn(false); 3494 3495 return Result; 3496} 3497 3498template<typename Derived> QualType 3499TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 3500 UnresolvedUsingTypeLoc TL) { 3501 UnresolvedUsingType *T = TL.getTypePtr(); 3502 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 3503 if (!D) 3504 return QualType(); 3505 3506 QualType Result = TL.getType(); 3507 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 3508 Result = getDerived().RebuildUnresolvedUsingType(D); 3509 if (Result.isNull()) 3510 return QualType(); 3511 } 3512 3513 // We might get an arbitrary type spec type back. We should at 3514 // least always get a type spec type, though. 3515 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 3516 NewTL.setNameLoc(TL.getNameLoc()); 3517 3518 return Result; 3519} 3520 3521template<typename Derived> 3522QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 3523 TypedefTypeLoc TL) { 3524 TypedefType *T = TL.getTypePtr(); 3525 TypedefDecl *Typedef 3526 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3527 T->getDecl())); 3528 if (!Typedef) 3529 return QualType(); 3530 3531 QualType Result = TL.getType(); 3532 if (getDerived().AlwaysRebuild() || 3533 Typedef != T->getDecl()) { 3534 Result = getDerived().RebuildTypedefType(Typedef); 3535 if (Result.isNull()) 3536 return QualType(); 3537 } 3538 3539 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 3540 NewTL.setNameLoc(TL.getNameLoc()); 3541 3542 return Result; 3543} 3544 3545template<typename Derived> 3546QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 3547 TypeOfExprTypeLoc TL) { 3548 // typeof expressions are not potentially evaluated contexts 3549 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3550 3551 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 3552 if (E.isInvalid()) 3553 return QualType(); 3554 3555 QualType Result = TL.getType(); 3556 if (getDerived().AlwaysRebuild() || 3557 E.get() != TL.getUnderlyingExpr()) { 3558 Result = getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc()); 3559 if (Result.isNull()) 3560 return QualType(); 3561 } 3562 else E.take(); 3563 3564 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 3565 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3566 NewTL.setLParenLoc(TL.getLParenLoc()); 3567 NewTL.setRParenLoc(TL.getRParenLoc()); 3568 3569 return Result; 3570} 3571 3572template<typename Derived> 3573QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 3574 TypeOfTypeLoc TL) { 3575 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 3576 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 3577 if (!New_Under_TI) 3578 return QualType(); 3579 3580 QualType Result = TL.getType(); 3581 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 3582 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 3583 if (Result.isNull()) 3584 return QualType(); 3585 } 3586 3587 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 3588 NewTL.setTypeofLoc(TL.getTypeofLoc()); 3589 NewTL.setLParenLoc(TL.getLParenLoc()); 3590 NewTL.setRParenLoc(TL.getRParenLoc()); 3591 NewTL.setUnderlyingTInfo(New_Under_TI); 3592 3593 return Result; 3594} 3595 3596template<typename Derived> 3597QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 3598 DecltypeTypeLoc TL) { 3599 DecltypeType *T = TL.getTypePtr(); 3600 3601 // decltype expressions are not potentially evaluated contexts 3602 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 3603 3604 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 3605 if (E.isInvalid()) 3606 return QualType(); 3607 3608 QualType Result = TL.getType(); 3609 if (getDerived().AlwaysRebuild() || 3610 E.get() != T->getUnderlyingExpr()) { 3611 Result = getDerived().RebuildDecltypeType(E.get(), TL.getNameLoc()); 3612 if (Result.isNull()) 3613 return QualType(); 3614 } 3615 else E.take(); 3616 3617 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 3618 NewTL.setNameLoc(TL.getNameLoc()); 3619 3620 return Result; 3621} 3622 3623template<typename Derived> 3624QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 3625 RecordTypeLoc TL) { 3626 RecordType *T = TL.getTypePtr(); 3627 RecordDecl *Record 3628 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3629 T->getDecl())); 3630 if (!Record) 3631 return QualType(); 3632 3633 QualType Result = TL.getType(); 3634 if (getDerived().AlwaysRebuild() || 3635 Record != T->getDecl()) { 3636 Result = getDerived().RebuildRecordType(Record); 3637 if (Result.isNull()) 3638 return QualType(); 3639 } 3640 3641 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 3642 NewTL.setNameLoc(TL.getNameLoc()); 3643 3644 return Result; 3645} 3646 3647template<typename Derived> 3648QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 3649 EnumTypeLoc TL) { 3650 EnumType *T = TL.getTypePtr(); 3651 EnumDecl *Enum 3652 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 3653 T->getDecl())); 3654 if (!Enum) 3655 return QualType(); 3656 3657 QualType Result = TL.getType(); 3658 if (getDerived().AlwaysRebuild() || 3659 Enum != T->getDecl()) { 3660 Result = getDerived().RebuildEnumType(Enum); 3661 if (Result.isNull()) 3662 return QualType(); 3663 } 3664 3665 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 3666 NewTL.setNameLoc(TL.getNameLoc()); 3667 3668 return Result; 3669} 3670 3671template<typename Derived> 3672QualType TreeTransform<Derived>::TransformInjectedClassNameType( 3673 TypeLocBuilder &TLB, 3674 InjectedClassNameTypeLoc TL) { 3675 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 3676 TL.getTypePtr()->getDecl()); 3677 if (!D) return QualType(); 3678 3679 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 3680 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 3681 return T; 3682} 3683 3684 3685template<typename Derived> 3686QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 3687 TypeLocBuilder &TLB, 3688 TemplateTypeParmTypeLoc TL) { 3689 return TransformTypeSpecType(TLB, TL); 3690} 3691 3692template<typename Derived> 3693QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 3694 TypeLocBuilder &TLB, 3695 SubstTemplateTypeParmTypeLoc TL) { 3696 return TransformTypeSpecType(TLB, TL); 3697} 3698 3699template<typename Derived> 3700QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3701 TypeLocBuilder &TLB, 3702 TemplateSpecializationTypeLoc TL) { 3703 const TemplateSpecializationType *T = TL.getTypePtr(); 3704 3705 TemplateName Template 3706 = getDerived().TransformTemplateName(T->getTemplateName()); 3707 if (Template.isNull()) 3708 return QualType(); 3709 3710 return getDerived().TransformTemplateSpecializationType(TLB, TL, Template); 3711} 3712 3713namespace { 3714 /// \brief Simple iterator that traverses the template arguments in a 3715 /// container that provides a \c getArgLoc() member function. 3716 /// 3717 /// This iterator is intended to be used with the iterator form of 3718 /// \c TreeTransform<Derived>::TransformTemplateArguments(). 3719 template<typename ArgLocContainer> 3720 class TemplateArgumentLocContainerIterator { 3721 ArgLocContainer *Container; 3722 unsigned Index; 3723 3724 public: 3725 typedef TemplateArgumentLoc value_type; 3726 typedef TemplateArgumentLoc reference; 3727 typedef int difference_type; 3728 typedef std::input_iterator_tag iterator_category; 3729 3730 class pointer { 3731 TemplateArgumentLoc Arg; 3732 3733 public: 3734 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { } 3735 3736 const TemplateArgumentLoc *operator->() const { 3737 return &Arg; 3738 } 3739 }; 3740 3741 3742 TemplateArgumentLocContainerIterator() {} 3743 3744 TemplateArgumentLocContainerIterator(ArgLocContainer &Container, 3745 unsigned Index) 3746 : Container(&Container), Index(Index) { } 3747 3748 TemplateArgumentLocContainerIterator &operator++() { 3749 ++Index; 3750 return *this; 3751 } 3752 3753 TemplateArgumentLocContainerIterator operator++(int) { 3754 TemplateArgumentLocContainerIterator Old(*this); 3755 ++(*this); 3756 return Old; 3757 } 3758 3759 TemplateArgumentLoc operator*() const { 3760 return Container->getArgLoc(Index); 3761 } 3762 3763 pointer operator->() const { 3764 return pointer(Container->getArgLoc(Index)); 3765 } 3766 3767 friend bool operator==(const TemplateArgumentLocContainerIterator &X, 3768 const TemplateArgumentLocContainerIterator &Y) { 3769 return X.Container == Y.Container && X.Index == Y.Index; 3770 } 3771 3772 friend bool operator!=(const TemplateArgumentLocContainerIterator &X, 3773 const TemplateArgumentLocContainerIterator &Y) { 3774 return !(X == Y); 3775 } 3776 }; 3777} 3778 3779 3780template <typename Derived> 3781QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3782 TypeLocBuilder &TLB, 3783 TemplateSpecializationTypeLoc TL, 3784 TemplateName Template) { 3785 TemplateArgumentListInfo NewTemplateArgs; 3786 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 3787 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 3788 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc> 3789 ArgIterator; 3790 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 3791 ArgIterator(TL, TL.getNumArgs()), 3792 NewTemplateArgs)) 3793 return QualType(); 3794 3795 // FIXME: maybe don't rebuild if all the template arguments are the same. 3796 3797 QualType Result = 3798 getDerived().RebuildTemplateSpecializationType(Template, 3799 TL.getTemplateNameLoc(), 3800 NewTemplateArgs); 3801 3802 if (!Result.isNull()) { 3803 TemplateSpecializationTypeLoc NewTL 3804 = TLB.push<TemplateSpecializationTypeLoc>(Result); 3805 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 3806 NewTL.setLAngleLoc(TL.getLAngleLoc()); 3807 NewTL.setRAngleLoc(TL.getRAngleLoc()); 3808 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 3809 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 3810 } 3811 3812 return Result; 3813} 3814 3815template<typename Derived> 3816QualType 3817TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 3818 ElaboratedTypeLoc TL) { 3819 ElaboratedType *T = TL.getTypePtr(); 3820 3821 NestedNameSpecifier *NNS = 0; 3822 // NOTE: the qualifier in an ElaboratedType is optional. 3823 if (T->getQualifier() != 0) { 3824 NNS = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3825 TL.getQualifierRange()); 3826 if (!NNS) 3827 return QualType(); 3828 } 3829 3830 QualType NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc()); 3831 if (NamedT.isNull()) 3832 return QualType(); 3833 3834 QualType Result = TL.getType(); 3835 if (getDerived().AlwaysRebuild() || 3836 NNS != T->getQualifier() || 3837 NamedT != T->getNamedType()) { 3838 Result = getDerived().RebuildElaboratedType(TL.getKeywordLoc(), 3839 T->getKeyword(), NNS, NamedT); 3840 if (Result.isNull()) 3841 return QualType(); 3842 } 3843 3844 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3845 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3846 NewTL.setQualifierRange(TL.getQualifierRange()); 3847 3848 return Result; 3849} 3850 3851template<typename Derived> 3852QualType 3853TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, 3854 ParenTypeLoc TL) { 3855 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc()); 3856 if (Inner.isNull()) 3857 return QualType(); 3858 3859 QualType Result = TL.getType(); 3860 if (getDerived().AlwaysRebuild() || 3861 Inner != TL.getInnerLoc().getType()) { 3862 Result = getDerived().RebuildParenType(Inner); 3863 if (Result.isNull()) 3864 return QualType(); 3865 } 3866 3867 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result); 3868 NewTL.setLParenLoc(TL.getLParenLoc()); 3869 NewTL.setRParenLoc(TL.getRParenLoc()); 3870 return Result; 3871} 3872 3873template<typename Derived> 3874QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 3875 DependentNameTypeLoc TL) { 3876 DependentNameType *T = TL.getTypePtr(); 3877 3878 NestedNameSpecifier *NNS 3879 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3880 TL.getQualifierRange()); 3881 if (!NNS) 3882 return QualType(); 3883 3884 QualType Result 3885 = getDerived().RebuildDependentNameType(T->getKeyword(), NNS, 3886 T->getIdentifier(), 3887 TL.getKeywordLoc(), 3888 TL.getQualifierRange(), 3889 TL.getNameLoc()); 3890 if (Result.isNull()) 3891 return QualType(); 3892 3893 if (const ElaboratedType* ElabT = Result->getAs<ElaboratedType>()) { 3894 QualType NamedT = ElabT->getNamedType(); 3895 TLB.pushTypeSpec(NamedT).setNameLoc(TL.getNameLoc()); 3896 3897 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3898 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3899 NewTL.setQualifierRange(TL.getQualifierRange()); 3900 } else { 3901 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 3902 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3903 NewTL.setQualifierRange(TL.getQualifierRange()); 3904 NewTL.setNameLoc(TL.getNameLoc()); 3905 } 3906 return Result; 3907} 3908 3909template<typename Derived> 3910QualType TreeTransform<Derived>:: 3911 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 3912 DependentTemplateSpecializationTypeLoc TL) { 3913 DependentTemplateSpecializationType *T = TL.getTypePtr(); 3914 3915 NestedNameSpecifier *NNS 3916 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3917 TL.getQualifierRange()); 3918 if (!NNS) 3919 return QualType(); 3920 3921 return getDerived() 3922 .TransformDependentTemplateSpecializationType(TLB, TL, NNS); 3923} 3924 3925template<typename Derived> 3926QualType TreeTransform<Derived>:: 3927 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB, 3928 DependentTemplateSpecializationTypeLoc TL, 3929 NestedNameSpecifier *NNS) { 3930 DependentTemplateSpecializationType *T = TL.getTypePtr(); 3931 3932 TemplateArgumentListInfo NewTemplateArgs; 3933 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 3934 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 3935 3936 typedef TemplateArgumentLocContainerIterator< 3937 DependentTemplateSpecializationTypeLoc> ArgIterator; 3938 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0), 3939 ArgIterator(TL, TL.getNumArgs()), 3940 NewTemplateArgs)) 3941 return QualType(); 3942 3943 QualType Result 3944 = getDerived().RebuildDependentTemplateSpecializationType(T->getKeyword(), 3945 NNS, 3946 TL.getQualifierRange(), 3947 T->getIdentifier(), 3948 TL.getNameLoc(), 3949 NewTemplateArgs); 3950 if (Result.isNull()) 3951 return QualType(); 3952 3953 if (const ElaboratedType *ElabT = dyn_cast<ElaboratedType>(Result)) { 3954 QualType NamedT = ElabT->getNamedType(); 3955 3956 // Copy information relevant to the template specialization. 3957 TemplateSpecializationTypeLoc NamedTL 3958 = TLB.push<TemplateSpecializationTypeLoc>(NamedT); 3959 NamedTL.setLAngleLoc(TL.getLAngleLoc()); 3960 NamedTL.setRAngleLoc(TL.getRAngleLoc()); 3961 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3962 NamedTL.setArgLocInfo(I, TL.getArgLocInfo(I)); 3963 3964 // Copy information relevant to the elaborated type. 3965 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 3966 NewTL.setKeywordLoc(TL.getKeywordLoc()); 3967 NewTL.setQualifierRange(TL.getQualifierRange()); 3968 } else { 3969 TypeLoc NewTL(Result, TL.getOpaqueData()); 3970 TLB.pushFullCopy(NewTL); 3971 } 3972 return Result; 3973} 3974 3975template<typename Derived> 3976QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB, 3977 PackExpansionTypeLoc TL) { 3978 // FIXME: Implement! 3979 getSema().Diag(TL.getEllipsisLoc(), 3980 diag::err_pack_expansion_instantiation_unsupported); 3981 return QualType(); 3982} 3983 3984template<typename Derived> 3985QualType 3986TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 3987 ObjCInterfaceTypeLoc TL) { 3988 // ObjCInterfaceType is never dependent. 3989 TLB.pushFullCopy(TL); 3990 return TL.getType(); 3991} 3992 3993template<typename Derived> 3994QualType 3995TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB, 3996 ObjCObjectTypeLoc TL) { 3997 // ObjCObjectType is never dependent. 3998 TLB.pushFullCopy(TL); 3999 return TL.getType(); 4000} 4001 4002template<typename Derived> 4003QualType 4004TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 4005 ObjCObjectPointerTypeLoc TL) { 4006 // ObjCObjectPointerType is never dependent. 4007 TLB.pushFullCopy(TL); 4008 return TL.getType(); 4009} 4010 4011//===----------------------------------------------------------------------===// 4012// Statement transformation 4013//===----------------------------------------------------------------------===// 4014template<typename Derived> 4015StmtResult 4016TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 4017 return SemaRef.Owned(S); 4018} 4019 4020template<typename Derived> 4021StmtResult 4022TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 4023 return getDerived().TransformCompoundStmt(S, false); 4024} 4025 4026template<typename Derived> 4027StmtResult 4028TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 4029 bool IsStmtExpr) { 4030 bool SubStmtInvalid = false; 4031 bool SubStmtChanged = false; 4032 ASTOwningVector<Stmt*> Statements(getSema()); 4033 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 4034 B != BEnd; ++B) { 4035 StmtResult Result = getDerived().TransformStmt(*B); 4036 if (Result.isInvalid()) { 4037 // Immediately fail if this was a DeclStmt, since it's very 4038 // likely that this will cause problems for future statements. 4039 if (isa<DeclStmt>(*B)) 4040 return StmtError(); 4041 4042 // Otherwise, just keep processing substatements and fail later. 4043 SubStmtInvalid = true; 4044 continue; 4045 } 4046 4047 SubStmtChanged = SubStmtChanged || Result.get() != *B; 4048 Statements.push_back(Result.takeAs<Stmt>()); 4049 } 4050 4051 if (SubStmtInvalid) 4052 return StmtError(); 4053 4054 if (!getDerived().AlwaysRebuild() && 4055 !SubStmtChanged) 4056 return SemaRef.Owned(S); 4057 4058 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 4059 move_arg(Statements), 4060 S->getRBracLoc(), 4061 IsStmtExpr); 4062} 4063 4064template<typename Derived> 4065StmtResult 4066TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 4067 ExprResult LHS, RHS; 4068 { 4069 // The case value expressions are not potentially evaluated. 4070 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4071 4072 // Transform the left-hand case value. 4073 LHS = getDerived().TransformExpr(S->getLHS()); 4074 if (LHS.isInvalid()) 4075 return StmtError(); 4076 4077 // Transform the right-hand case value (for the GNU case-range extension). 4078 RHS = getDerived().TransformExpr(S->getRHS()); 4079 if (RHS.isInvalid()) 4080 return StmtError(); 4081 } 4082 4083 // Build the case statement. 4084 // Case statements are always rebuilt so that they will attached to their 4085 // transformed switch statement. 4086 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 4087 LHS.get(), 4088 S->getEllipsisLoc(), 4089 RHS.get(), 4090 S->getColonLoc()); 4091 if (Case.isInvalid()) 4092 return StmtError(); 4093 4094 // Transform the statement following the case 4095 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4096 if (SubStmt.isInvalid()) 4097 return StmtError(); 4098 4099 // Attach the body to the case statement 4100 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get()); 4101} 4102 4103template<typename Derived> 4104StmtResult 4105TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 4106 // Transform the statement following the default case 4107 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4108 if (SubStmt.isInvalid()) 4109 return StmtError(); 4110 4111 // Default statements are always rebuilt 4112 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 4113 SubStmt.get()); 4114} 4115 4116template<typename Derived> 4117StmtResult 4118TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 4119 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 4120 if (SubStmt.isInvalid()) 4121 return StmtError(); 4122 4123 // FIXME: Pass the real colon location in. 4124 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 4125 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 4126 SubStmt.get(), S->HasUnusedAttribute()); 4127} 4128 4129template<typename Derived> 4130StmtResult 4131TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 4132 // Transform the condition 4133 ExprResult Cond; 4134 VarDecl *ConditionVar = 0; 4135 if (S->getConditionVariable()) { 4136 ConditionVar 4137 = cast_or_null<VarDecl>( 4138 getDerived().TransformDefinition( 4139 S->getConditionVariable()->getLocation(), 4140 S->getConditionVariable())); 4141 if (!ConditionVar) 4142 return StmtError(); 4143 } else { 4144 Cond = getDerived().TransformExpr(S->getCond()); 4145 4146 if (Cond.isInvalid()) 4147 return StmtError(); 4148 4149 // Convert the condition to a boolean value. 4150 if (S->getCond()) { 4151 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getIfLoc(), 4152 Cond.get()); 4153 if (CondE.isInvalid()) 4154 return StmtError(); 4155 4156 Cond = CondE.get(); 4157 } 4158 } 4159 4160 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4161 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4162 return StmtError(); 4163 4164 // Transform the "then" branch. 4165 StmtResult Then = getDerived().TransformStmt(S->getThen()); 4166 if (Then.isInvalid()) 4167 return StmtError(); 4168 4169 // Transform the "else" branch. 4170 StmtResult Else = getDerived().TransformStmt(S->getElse()); 4171 if (Else.isInvalid()) 4172 return StmtError(); 4173 4174 if (!getDerived().AlwaysRebuild() && 4175 FullCond.get() == S->getCond() && 4176 ConditionVar == S->getConditionVariable() && 4177 Then.get() == S->getThen() && 4178 Else.get() == S->getElse()) 4179 return SemaRef.Owned(S); 4180 4181 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 4182 Then.get(), 4183 S->getElseLoc(), Else.get()); 4184} 4185 4186template<typename Derived> 4187StmtResult 4188TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 4189 // Transform the condition. 4190 ExprResult Cond; 4191 VarDecl *ConditionVar = 0; 4192 if (S->getConditionVariable()) { 4193 ConditionVar 4194 = cast_or_null<VarDecl>( 4195 getDerived().TransformDefinition( 4196 S->getConditionVariable()->getLocation(), 4197 S->getConditionVariable())); 4198 if (!ConditionVar) 4199 return StmtError(); 4200 } else { 4201 Cond = getDerived().TransformExpr(S->getCond()); 4202 4203 if (Cond.isInvalid()) 4204 return StmtError(); 4205 } 4206 4207 // Rebuild the switch statement. 4208 StmtResult Switch 4209 = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(), 4210 ConditionVar); 4211 if (Switch.isInvalid()) 4212 return StmtError(); 4213 4214 // Transform the body of the switch statement. 4215 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4216 if (Body.isInvalid()) 4217 return StmtError(); 4218 4219 // Complete the switch statement. 4220 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(), 4221 Body.get()); 4222} 4223 4224template<typename Derived> 4225StmtResult 4226TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 4227 // Transform the condition 4228 ExprResult Cond; 4229 VarDecl *ConditionVar = 0; 4230 if (S->getConditionVariable()) { 4231 ConditionVar 4232 = cast_or_null<VarDecl>( 4233 getDerived().TransformDefinition( 4234 S->getConditionVariable()->getLocation(), 4235 S->getConditionVariable())); 4236 if (!ConditionVar) 4237 return StmtError(); 4238 } else { 4239 Cond = getDerived().TransformExpr(S->getCond()); 4240 4241 if (Cond.isInvalid()) 4242 return StmtError(); 4243 4244 if (S->getCond()) { 4245 // Convert the condition to a boolean value. 4246 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getWhileLoc(), 4247 Cond.get()); 4248 if (CondE.isInvalid()) 4249 return StmtError(); 4250 Cond = CondE; 4251 } 4252 } 4253 4254 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4255 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4256 return StmtError(); 4257 4258 // Transform the body 4259 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4260 if (Body.isInvalid()) 4261 return StmtError(); 4262 4263 if (!getDerived().AlwaysRebuild() && 4264 FullCond.get() == S->getCond() && 4265 ConditionVar == S->getConditionVariable() && 4266 Body.get() == S->getBody()) 4267 return Owned(S); 4268 4269 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, 4270 ConditionVar, Body.get()); 4271} 4272 4273template<typename Derived> 4274StmtResult 4275TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 4276 // Transform the body 4277 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4278 if (Body.isInvalid()) 4279 return StmtError(); 4280 4281 // Transform the condition 4282 ExprResult Cond = getDerived().TransformExpr(S->getCond()); 4283 if (Cond.isInvalid()) 4284 return StmtError(); 4285 4286 if (!getDerived().AlwaysRebuild() && 4287 Cond.get() == S->getCond() && 4288 Body.get() == S->getBody()) 4289 return SemaRef.Owned(S); 4290 4291 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(), 4292 /*FIXME:*/S->getWhileLoc(), Cond.get(), 4293 S->getRParenLoc()); 4294} 4295 4296template<typename Derived> 4297StmtResult 4298TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 4299 // Transform the initialization statement 4300 StmtResult Init = getDerived().TransformStmt(S->getInit()); 4301 if (Init.isInvalid()) 4302 return StmtError(); 4303 4304 // Transform the condition 4305 ExprResult Cond; 4306 VarDecl *ConditionVar = 0; 4307 if (S->getConditionVariable()) { 4308 ConditionVar 4309 = cast_or_null<VarDecl>( 4310 getDerived().TransformDefinition( 4311 S->getConditionVariable()->getLocation(), 4312 S->getConditionVariable())); 4313 if (!ConditionVar) 4314 return StmtError(); 4315 } else { 4316 Cond = getDerived().TransformExpr(S->getCond()); 4317 4318 if (Cond.isInvalid()) 4319 return StmtError(); 4320 4321 if (S->getCond()) { 4322 // Convert the condition to a boolean value. 4323 ExprResult CondE = getSema().ActOnBooleanCondition(0, S->getForLoc(), 4324 Cond.get()); 4325 if (CondE.isInvalid()) 4326 return StmtError(); 4327 4328 Cond = CondE.get(); 4329 } 4330 } 4331 4332 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take())); 4333 if (!S->getConditionVariable() && S->getCond() && !FullCond.get()) 4334 return StmtError(); 4335 4336 // Transform the increment 4337 ExprResult Inc = getDerived().TransformExpr(S->getInc()); 4338 if (Inc.isInvalid()) 4339 return StmtError(); 4340 4341 Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc.get())); 4342 if (S->getInc() && !FullInc.get()) 4343 return StmtError(); 4344 4345 // Transform the body 4346 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4347 if (Body.isInvalid()) 4348 return StmtError(); 4349 4350 if (!getDerived().AlwaysRebuild() && 4351 Init.get() == S->getInit() && 4352 FullCond.get() == S->getCond() && 4353 Inc.get() == S->getInc() && 4354 Body.get() == S->getBody()) 4355 return SemaRef.Owned(S); 4356 4357 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 4358 Init.get(), FullCond, ConditionVar, 4359 FullInc, S->getRParenLoc(), Body.get()); 4360} 4361 4362template<typename Derived> 4363StmtResult 4364TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 4365 // Goto statements must always be rebuilt, to resolve the label. 4366 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 4367 S->getLabel()); 4368} 4369 4370template<typename Derived> 4371StmtResult 4372TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 4373 ExprResult Target = getDerived().TransformExpr(S->getTarget()); 4374 if (Target.isInvalid()) 4375 return StmtError(); 4376 4377 if (!getDerived().AlwaysRebuild() && 4378 Target.get() == S->getTarget()) 4379 return SemaRef.Owned(S); 4380 4381 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 4382 Target.get()); 4383} 4384 4385template<typename Derived> 4386StmtResult 4387TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 4388 return SemaRef.Owned(S); 4389} 4390 4391template<typename Derived> 4392StmtResult 4393TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 4394 return SemaRef.Owned(S); 4395} 4396 4397template<typename Derived> 4398StmtResult 4399TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 4400 ExprResult Result = getDerived().TransformExpr(S->getRetValue()); 4401 if (Result.isInvalid()) 4402 return StmtError(); 4403 4404 // FIXME: We always rebuild the return statement because there is no way 4405 // to tell whether the return type of the function has changed. 4406 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get()); 4407} 4408 4409template<typename Derived> 4410StmtResult 4411TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 4412 bool DeclChanged = false; 4413 llvm::SmallVector<Decl *, 4> Decls; 4414 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 4415 D != DEnd; ++D) { 4416 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 4417 *D); 4418 if (!Transformed) 4419 return StmtError(); 4420 4421 if (Transformed != *D) 4422 DeclChanged = true; 4423 4424 Decls.push_back(Transformed); 4425 } 4426 4427 if (!getDerived().AlwaysRebuild() && !DeclChanged) 4428 return SemaRef.Owned(S); 4429 4430 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 4431 S->getStartLoc(), S->getEndLoc()); 4432} 4433 4434template<typename Derived> 4435StmtResult 4436TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 4437 assert(false && "SwitchCase is abstract and cannot be transformed"); 4438 return SemaRef.Owned(S); 4439} 4440 4441template<typename Derived> 4442StmtResult 4443TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 4444 4445 ASTOwningVector<Expr*> Constraints(getSema()); 4446 ASTOwningVector<Expr*> Exprs(getSema()); 4447 llvm::SmallVector<IdentifierInfo *, 4> Names; 4448 4449 ExprResult AsmString; 4450 ASTOwningVector<Expr*> Clobbers(getSema()); 4451 4452 bool ExprsChanged = false; 4453 4454 // Go through the outputs. 4455 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 4456 Names.push_back(S->getOutputIdentifier(I)); 4457 4458 // No need to transform the constraint literal. 4459 Constraints.push_back(S->getOutputConstraintLiteral(I)); 4460 4461 // Transform the output expr. 4462 Expr *OutputExpr = S->getOutputExpr(I); 4463 ExprResult Result = getDerived().TransformExpr(OutputExpr); 4464 if (Result.isInvalid()) 4465 return StmtError(); 4466 4467 ExprsChanged |= Result.get() != OutputExpr; 4468 4469 Exprs.push_back(Result.get()); 4470 } 4471 4472 // Go through the inputs. 4473 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 4474 Names.push_back(S->getInputIdentifier(I)); 4475 4476 // No need to transform the constraint literal. 4477 Constraints.push_back(S->getInputConstraintLiteral(I)); 4478 4479 // Transform the input expr. 4480 Expr *InputExpr = S->getInputExpr(I); 4481 ExprResult Result = getDerived().TransformExpr(InputExpr); 4482 if (Result.isInvalid()) 4483 return StmtError(); 4484 4485 ExprsChanged |= Result.get() != InputExpr; 4486 4487 Exprs.push_back(Result.get()); 4488 } 4489 4490 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 4491 return SemaRef.Owned(S); 4492 4493 // Go through the clobbers. 4494 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 4495 Clobbers.push_back(S->getClobber(I)); 4496 4497 // No need to transform the asm string literal. 4498 AsmString = SemaRef.Owned(S->getAsmString()); 4499 4500 return getDerived().RebuildAsmStmt(S->getAsmLoc(), 4501 S->isSimple(), 4502 S->isVolatile(), 4503 S->getNumOutputs(), 4504 S->getNumInputs(), 4505 Names.data(), 4506 move_arg(Constraints), 4507 move_arg(Exprs), 4508 AsmString.get(), 4509 move_arg(Clobbers), 4510 S->getRParenLoc(), 4511 S->isMSAsm()); 4512} 4513 4514 4515template<typename Derived> 4516StmtResult 4517TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 4518 // Transform the body of the @try. 4519 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody()); 4520 if (TryBody.isInvalid()) 4521 return StmtError(); 4522 4523 // Transform the @catch statements (if present). 4524 bool AnyCatchChanged = false; 4525 ASTOwningVector<Stmt*> CatchStmts(SemaRef); 4526 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) { 4527 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I)); 4528 if (Catch.isInvalid()) 4529 return StmtError(); 4530 if (Catch.get() != S->getCatchStmt(I)) 4531 AnyCatchChanged = true; 4532 CatchStmts.push_back(Catch.release()); 4533 } 4534 4535 // Transform the @finally statement (if present). 4536 StmtResult Finally; 4537 if (S->getFinallyStmt()) { 4538 Finally = getDerived().TransformStmt(S->getFinallyStmt()); 4539 if (Finally.isInvalid()) 4540 return StmtError(); 4541 } 4542 4543 // If nothing changed, just retain this statement. 4544 if (!getDerived().AlwaysRebuild() && 4545 TryBody.get() == S->getTryBody() && 4546 !AnyCatchChanged && 4547 Finally.get() == S->getFinallyStmt()) 4548 return SemaRef.Owned(S); 4549 4550 // Build a new statement. 4551 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(), 4552 move_arg(CatchStmts), Finally.get()); 4553} 4554 4555template<typename Derived> 4556StmtResult 4557TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 4558 // Transform the @catch parameter, if there is one. 4559 VarDecl *Var = 0; 4560 if (VarDecl *FromVar = S->getCatchParamDecl()) { 4561 TypeSourceInfo *TSInfo = 0; 4562 if (FromVar->getTypeSourceInfo()) { 4563 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo()); 4564 if (!TSInfo) 4565 return StmtError(); 4566 } 4567 4568 QualType T; 4569 if (TSInfo) 4570 T = TSInfo->getType(); 4571 else { 4572 T = getDerived().TransformType(FromVar->getType()); 4573 if (T.isNull()) 4574 return StmtError(); 4575 } 4576 4577 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T); 4578 if (!Var) 4579 return StmtError(); 4580 } 4581 4582 StmtResult Body = getDerived().TransformStmt(S->getCatchBody()); 4583 if (Body.isInvalid()) 4584 return StmtError(); 4585 4586 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 4587 S->getRParenLoc(), 4588 Var, Body.get()); 4589} 4590 4591template<typename Derived> 4592StmtResult 4593TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 4594 // Transform the body. 4595 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody()); 4596 if (Body.isInvalid()) 4597 return StmtError(); 4598 4599 // If nothing changed, just retain this statement. 4600 if (!getDerived().AlwaysRebuild() && 4601 Body.get() == S->getFinallyBody()) 4602 return SemaRef.Owned(S); 4603 4604 // Build a new statement. 4605 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(), 4606 Body.get()); 4607} 4608 4609template<typename Derived> 4610StmtResult 4611TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 4612 ExprResult Operand; 4613 if (S->getThrowExpr()) { 4614 Operand = getDerived().TransformExpr(S->getThrowExpr()); 4615 if (Operand.isInvalid()) 4616 return StmtError(); 4617 } 4618 4619 if (!getDerived().AlwaysRebuild() && 4620 Operand.get() == S->getThrowExpr()) 4621 return getSema().Owned(S); 4622 4623 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get()); 4624} 4625 4626template<typename Derived> 4627StmtResult 4628TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 4629 ObjCAtSynchronizedStmt *S) { 4630 // Transform the object we are locking. 4631 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr()); 4632 if (Object.isInvalid()) 4633 return StmtError(); 4634 4635 // Transform the body. 4636 StmtResult Body = getDerived().TransformStmt(S->getSynchBody()); 4637 if (Body.isInvalid()) 4638 return StmtError(); 4639 4640 // If nothing change, just retain the current statement. 4641 if (!getDerived().AlwaysRebuild() && 4642 Object.get() == S->getSynchExpr() && 4643 Body.get() == S->getSynchBody()) 4644 return SemaRef.Owned(S); 4645 4646 // Build a new statement. 4647 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(), 4648 Object.get(), Body.get()); 4649} 4650 4651template<typename Derived> 4652StmtResult 4653TreeTransform<Derived>::TransformObjCForCollectionStmt( 4654 ObjCForCollectionStmt *S) { 4655 // Transform the element statement. 4656 StmtResult Element = getDerived().TransformStmt(S->getElement()); 4657 if (Element.isInvalid()) 4658 return StmtError(); 4659 4660 // Transform the collection expression. 4661 ExprResult Collection = getDerived().TransformExpr(S->getCollection()); 4662 if (Collection.isInvalid()) 4663 return StmtError(); 4664 4665 // Transform the body. 4666 StmtResult Body = getDerived().TransformStmt(S->getBody()); 4667 if (Body.isInvalid()) 4668 return StmtError(); 4669 4670 // If nothing changed, just retain this statement. 4671 if (!getDerived().AlwaysRebuild() && 4672 Element.get() == S->getElement() && 4673 Collection.get() == S->getCollection() && 4674 Body.get() == S->getBody()) 4675 return SemaRef.Owned(S); 4676 4677 // Build a new statement. 4678 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(), 4679 /*FIXME:*/S->getForLoc(), 4680 Element.get(), 4681 Collection.get(), 4682 S->getRParenLoc(), 4683 Body.get()); 4684} 4685 4686 4687template<typename Derived> 4688StmtResult 4689TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 4690 // Transform the exception declaration, if any. 4691 VarDecl *Var = 0; 4692 if (S->getExceptionDecl()) { 4693 VarDecl *ExceptionDecl = S->getExceptionDecl(); 4694 TypeSourceInfo *T = getDerived().TransformType( 4695 ExceptionDecl->getTypeSourceInfo()); 4696 if (!T) 4697 return StmtError(); 4698 4699 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, T, 4700 ExceptionDecl->getIdentifier(), 4701 ExceptionDecl->getLocation()); 4702 if (!Var || Var->isInvalidDecl()) 4703 return StmtError(); 4704 } 4705 4706 // Transform the actual exception handler. 4707 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 4708 if (Handler.isInvalid()) 4709 return StmtError(); 4710 4711 if (!getDerived().AlwaysRebuild() && 4712 !Var && 4713 Handler.get() == S->getHandlerBlock()) 4714 return SemaRef.Owned(S); 4715 4716 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 4717 Var, 4718 Handler.get()); 4719} 4720 4721template<typename Derived> 4722StmtResult 4723TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 4724 // Transform the try block itself. 4725 StmtResult TryBlock 4726 = getDerived().TransformCompoundStmt(S->getTryBlock()); 4727 if (TryBlock.isInvalid()) 4728 return StmtError(); 4729 4730 // Transform the handlers. 4731 bool HandlerChanged = false; 4732 ASTOwningVector<Stmt*> Handlers(SemaRef); 4733 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 4734 StmtResult Handler 4735 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 4736 if (Handler.isInvalid()) 4737 return StmtError(); 4738 4739 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 4740 Handlers.push_back(Handler.takeAs<Stmt>()); 4741 } 4742 4743 if (!getDerived().AlwaysRebuild() && 4744 TryBlock.get() == S->getTryBlock() && 4745 !HandlerChanged) 4746 return SemaRef.Owned(S); 4747 4748 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(), 4749 move_arg(Handlers)); 4750} 4751 4752//===----------------------------------------------------------------------===// 4753// Expression transformation 4754//===----------------------------------------------------------------------===// 4755template<typename Derived> 4756ExprResult 4757TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 4758 return SemaRef.Owned(E); 4759} 4760 4761template<typename Derived> 4762ExprResult 4763TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 4764 NestedNameSpecifier *Qualifier = 0; 4765 if (E->getQualifier()) { 4766 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4767 E->getQualifierRange()); 4768 if (!Qualifier) 4769 return ExprError(); 4770 } 4771 4772 ValueDecl *ND 4773 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 4774 E->getDecl())); 4775 if (!ND) 4776 return ExprError(); 4777 4778 DeclarationNameInfo NameInfo = E->getNameInfo(); 4779 if (NameInfo.getName()) { 4780 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo); 4781 if (!NameInfo.getName()) 4782 return ExprError(); 4783 } 4784 4785 if (!getDerived().AlwaysRebuild() && 4786 Qualifier == E->getQualifier() && 4787 ND == E->getDecl() && 4788 NameInfo.getName() == E->getDecl()->getDeclName() && 4789 !E->hasExplicitTemplateArgs()) { 4790 4791 // Mark it referenced in the new context regardless. 4792 // FIXME: this is a bit instantiation-specific. 4793 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 4794 4795 return SemaRef.Owned(E); 4796 } 4797 4798 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 4799 if (E->hasExplicitTemplateArgs()) { 4800 TemplateArgs = &TransArgs; 4801 TransArgs.setLAngleLoc(E->getLAngleLoc()); 4802 TransArgs.setRAngleLoc(E->getRAngleLoc()); 4803 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 4804 E->getNumTemplateArgs(), 4805 TransArgs)) 4806 return ExprError(); 4807 } 4808 4809 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 4810 ND, NameInfo, TemplateArgs); 4811} 4812 4813template<typename Derived> 4814ExprResult 4815TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 4816 return SemaRef.Owned(E); 4817} 4818 4819template<typename Derived> 4820ExprResult 4821TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 4822 return SemaRef.Owned(E); 4823} 4824 4825template<typename Derived> 4826ExprResult 4827TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 4828 return SemaRef.Owned(E); 4829} 4830 4831template<typename Derived> 4832ExprResult 4833TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 4834 return SemaRef.Owned(E); 4835} 4836 4837template<typename Derived> 4838ExprResult 4839TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 4840 return SemaRef.Owned(E); 4841} 4842 4843template<typename Derived> 4844ExprResult 4845TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 4846 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4847 if (SubExpr.isInvalid()) 4848 return ExprError(); 4849 4850 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 4851 return SemaRef.Owned(E); 4852 4853 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(), 4854 E->getRParen()); 4855} 4856 4857template<typename Derived> 4858ExprResult 4859TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 4860 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4861 if (SubExpr.isInvalid()) 4862 return ExprError(); 4863 4864 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 4865 return SemaRef.Owned(E); 4866 4867 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 4868 E->getOpcode(), 4869 SubExpr.get()); 4870} 4871 4872template<typename Derived> 4873ExprResult 4874TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) { 4875 // Transform the type. 4876 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo()); 4877 if (!Type) 4878 return ExprError(); 4879 4880 // Transform all of the components into components similar to what the 4881 // parser uses. 4882 // FIXME: It would be slightly more efficient in the non-dependent case to 4883 // just map FieldDecls, rather than requiring the rebuilder to look for 4884 // the fields again. However, __builtin_offsetof is rare enough in 4885 // template code that we don't care. 4886 bool ExprChanged = false; 4887 typedef Sema::OffsetOfComponent Component; 4888 typedef OffsetOfExpr::OffsetOfNode Node; 4889 llvm::SmallVector<Component, 4> Components; 4890 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) { 4891 const Node &ON = E->getComponent(I); 4892 Component Comp; 4893 Comp.isBrackets = true; 4894 Comp.LocStart = ON.getRange().getBegin(); 4895 Comp.LocEnd = ON.getRange().getEnd(); 4896 switch (ON.getKind()) { 4897 case Node::Array: { 4898 Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex()); 4899 ExprResult Index = getDerived().TransformExpr(FromIndex); 4900 if (Index.isInvalid()) 4901 return ExprError(); 4902 4903 ExprChanged = ExprChanged || Index.get() != FromIndex; 4904 Comp.isBrackets = true; 4905 Comp.U.E = Index.get(); 4906 break; 4907 } 4908 4909 case Node::Field: 4910 case Node::Identifier: 4911 Comp.isBrackets = false; 4912 Comp.U.IdentInfo = ON.getFieldName(); 4913 if (!Comp.U.IdentInfo) 4914 continue; 4915 4916 break; 4917 4918 case Node::Base: 4919 // Will be recomputed during the rebuild. 4920 continue; 4921 } 4922 4923 Components.push_back(Comp); 4924 } 4925 4926 // If nothing changed, retain the existing expression. 4927 if (!getDerived().AlwaysRebuild() && 4928 Type == E->getTypeSourceInfo() && 4929 !ExprChanged) 4930 return SemaRef.Owned(E); 4931 4932 // Build a new offsetof expression. 4933 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, 4934 Components.data(), Components.size(), 4935 E->getRParenLoc()); 4936} 4937 4938template<typename Derived> 4939ExprResult 4940TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) { 4941 assert(getDerived().AlreadyTransformed(E->getType()) && 4942 "opaque value expression requires transformation"); 4943 return SemaRef.Owned(E); 4944} 4945 4946template<typename Derived> 4947ExprResult 4948TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 4949 if (E->isArgumentType()) { 4950 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 4951 4952 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 4953 if (!NewT) 4954 return ExprError(); 4955 4956 if (!getDerived().AlwaysRebuild() && OldT == NewT) 4957 return SemaRef.Owned(E); 4958 4959 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 4960 E->isSizeOf(), 4961 E->getSourceRange()); 4962 } 4963 4964 ExprResult SubExpr; 4965 { 4966 // C++0x [expr.sizeof]p1: 4967 // The operand is either an expression, which is an unevaluated operand 4968 // [...] 4969 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 4970 4971 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 4972 if (SubExpr.isInvalid()) 4973 return ExprError(); 4974 4975 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 4976 return SemaRef.Owned(E); 4977 } 4978 4979 return getDerived().RebuildSizeOfAlignOf(SubExpr.get(), E->getOperatorLoc(), 4980 E->isSizeOf(), 4981 E->getSourceRange()); 4982} 4983 4984template<typename Derived> 4985ExprResult 4986TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 4987 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4988 if (LHS.isInvalid()) 4989 return ExprError(); 4990 4991 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4992 if (RHS.isInvalid()) 4993 return ExprError(); 4994 4995 4996 if (!getDerived().AlwaysRebuild() && 4997 LHS.get() == E->getLHS() && 4998 RHS.get() == E->getRHS()) 4999 return SemaRef.Owned(E); 5000 5001 return getDerived().RebuildArraySubscriptExpr(LHS.get(), 5002 /*FIXME:*/E->getLHS()->getLocStart(), 5003 RHS.get(), 5004 E->getRBracketLoc()); 5005} 5006 5007template<typename Derived> 5008ExprResult 5009TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 5010 // Transform the callee. 5011 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 5012 if (Callee.isInvalid()) 5013 return ExprError(); 5014 5015 // Transform arguments. 5016 bool ArgChanged = false; 5017 ASTOwningVector<Expr*> Args(SemaRef); 5018 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 5019 &ArgChanged)) 5020 return ExprError(); 5021 5022 if (!getDerived().AlwaysRebuild() && 5023 Callee.get() == E->getCallee() && 5024 !ArgChanged) 5025 return SemaRef.Owned(E); 5026 5027 // FIXME: Wrong source location information for the '('. 5028 SourceLocation FakeLParenLoc 5029 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 5030 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc, 5031 move_arg(Args), 5032 E->getRParenLoc()); 5033} 5034 5035template<typename Derived> 5036ExprResult 5037TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 5038 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5039 if (Base.isInvalid()) 5040 return ExprError(); 5041 5042 NestedNameSpecifier *Qualifier = 0; 5043 if (E->hasQualifier()) { 5044 Qualifier 5045 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5046 E->getQualifierRange()); 5047 if (Qualifier == 0) 5048 return ExprError(); 5049 } 5050 5051 ValueDecl *Member 5052 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 5053 E->getMemberDecl())); 5054 if (!Member) 5055 return ExprError(); 5056 5057 NamedDecl *FoundDecl = E->getFoundDecl(); 5058 if (FoundDecl == E->getMemberDecl()) { 5059 FoundDecl = Member; 5060 } else { 5061 FoundDecl = cast_or_null<NamedDecl>( 5062 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 5063 if (!FoundDecl) 5064 return ExprError(); 5065 } 5066 5067 if (!getDerived().AlwaysRebuild() && 5068 Base.get() == E->getBase() && 5069 Qualifier == E->getQualifier() && 5070 Member == E->getMemberDecl() && 5071 FoundDecl == E->getFoundDecl() && 5072 !E->hasExplicitTemplateArgs()) { 5073 5074 // Mark it referenced in the new context regardless. 5075 // FIXME: this is a bit instantiation-specific. 5076 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member); 5077 return SemaRef.Owned(E); 5078 } 5079 5080 TemplateArgumentListInfo TransArgs; 5081 if (E->hasExplicitTemplateArgs()) { 5082 TransArgs.setLAngleLoc(E->getLAngleLoc()); 5083 TransArgs.setRAngleLoc(E->getRAngleLoc()); 5084 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 5085 E->getNumTemplateArgs(), 5086 TransArgs)) 5087 return ExprError(); 5088 } 5089 5090 // FIXME: Bogus source location for the operator 5091 SourceLocation FakeOperatorLoc 5092 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 5093 5094 // FIXME: to do this check properly, we will need to preserve the 5095 // first-qualifier-in-scope here, just in case we had a dependent 5096 // base (and therefore couldn't do the check) and a 5097 // nested-name-qualifier (and therefore could do the lookup). 5098 NamedDecl *FirstQualifierInScope = 0; 5099 5100 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc, 5101 E->isArrow(), 5102 Qualifier, 5103 E->getQualifierRange(), 5104 E->getMemberNameInfo(), 5105 Member, 5106 FoundDecl, 5107 (E->hasExplicitTemplateArgs() 5108 ? &TransArgs : 0), 5109 FirstQualifierInScope); 5110} 5111 5112template<typename Derived> 5113ExprResult 5114TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 5115 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5116 if (LHS.isInvalid()) 5117 return ExprError(); 5118 5119 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5120 if (RHS.isInvalid()) 5121 return ExprError(); 5122 5123 if (!getDerived().AlwaysRebuild() && 5124 LHS.get() == E->getLHS() && 5125 RHS.get() == E->getRHS()) 5126 return SemaRef.Owned(E); 5127 5128 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 5129 LHS.get(), RHS.get()); 5130} 5131 5132template<typename Derived> 5133ExprResult 5134TreeTransform<Derived>::TransformCompoundAssignOperator( 5135 CompoundAssignOperator *E) { 5136 return getDerived().TransformBinaryOperator(E); 5137} 5138 5139template<typename Derived> 5140ExprResult 5141TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 5142 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5143 if (Cond.isInvalid()) 5144 return ExprError(); 5145 5146 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5147 if (LHS.isInvalid()) 5148 return ExprError(); 5149 5150 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5151 if (RHS.isInvalid()) 5152 return ExprError(); 5153 5154 if (!getDerived().AlwaysRebuild() && 5155 Cond.get() == E->getCond() && 5156 LHS.get() == E->getLHS() && 5157 RHS.get() == E->getRHS()) 5158 return SemaRef.Owned(E); 5159 5160 return getDerived().RebuildConditionalOperator(Cond.get(), 5161 E->getQuestionLoc(), 5162 LHS.get(), 5163 E->getColonLoc(), 5164 RHS.get()); 5165} 5166 5167template<typename Derived> 5168ExprResult 5169TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 5170 // Implicit casts are eliminated during transformation, since they 5171 // will be recomputed by semantic analysis after transformation. 5172 return getDerived().TransformExpr(E->getSubExprAsWritten()); 5173} 5174 5175template<typename Derived> 5176ExprResult 5177TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 5178 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5179 if (!Type) 5180 return ExprError(); 5181 5182 ExprResult SubExpr 5183 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5184 if (SubExpr.isInvalid()) 5185 return ExprError(); 5186 5187 if (!getDerived().AlwaysRebuild() && 5188 Type == E->getTypeInfoAsWritten() && 5189 SubExpr.get() == E->getSubExpr()) 5190 return SemaRef.Owned(E); 5191 5192 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 5193 Type, 5194 E->getRParenLoc(), 5195 SubExpr.get()); 5196} 5197 5198template<typename Derived> 5199ExprResult 5200TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 5201 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 5202 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 5203 if (!NewT) 5204 return ExprError(); 5205 5206 ExprResult Init = getDerived().TransformExpr(E->getInitializer()); 5207 if (Init.isInvalid()) 5208 return ExprError(); 5209 5210 if (!getDerived().AlwaysRebuild() && 5211 OldT == NewT && 5212 Init.get() == E->getInitializer()) 5213 return SemaRef.Owned(E); 5214 5215 // Note: the expression type doesn't necessarily match the 5216 // type-as-written, but that's okay, because it should always be 5217 // derivable from the initializer. 5218 5219 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 5220 /*FIXME:*/E->getInitializer()->getLocEnd(), 5221 Init.get()); 5222} 5223 5224template<typename Derived> 5225ExprResult 5226TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 5227 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5228 if (Base.isInvalid()) 5229 return ExprError(); 5230 5231 if (!getDerived().AlwaysRebuild() && 5232 Base.get() == E->getBase()) 5233 return SemaRef.Owned(E); 5234 5235 // FIXME: Bad source location 5236 SourceLocation FakeOperatorLoc 5237 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 5238 return getDerived().RebuildExtVectorElementExpr(Base.get(), FakeOperatorLoc, 5239 E->getAccessorLoc(), 5240 E->getAccessor()); 5241} 5242 5243template<typename Derived> 5244ExprResult 5245TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 5246 bool InitChanged = false; 5247 5248 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5249 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false, 5250 Inits, &InitChanged)) 5251 return ExprError(); 5252 5253 if (!getDerived().AlwaysRebuild() && !InitChanged) 5254 return SemaRef.Owned(E); 5255 5256 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 5257 E->getRBraceLoc(), E->getType()); 5258} 5259 5260template<typename Derived> 5261ExprResult 5262TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 5263 Designation Desig; 5264 5265 // transform the initializer value 5266 ExprResult Init = getDerived().TransformExpr(E->getInit()); 5267 if (Init.isInvalid()) 5268 return ExprError(); 5269 5270 // transform the designators. 5271 ASTOwningVector<Expr*, 4> ArrayExprs(SemaRef); 5272 bool ExprChanged = false; 5273 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 5274 DEnd = E->designators_end(); 5275 D != DEnd; ++D) { 5276 if (D->isFieldDesignator()) { 5277 Desig.AddDesignator(Designator::getField(D->getFieldName(), 5278 D->getDotLoc(), 5279 D->getFieldLoc())); 5280 continue; 5281 } 5282 5283 if (D->isArrayDesignator()) { 5284 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 5285 if (Index.isInvalid()) 5286 return ExprError(); 5287 5288 Desig.AddDesignator(Designator::getArray(Index.get(), 5289 D->getLBracketLoc())); 5290 5291 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 5292 ArrayExprs.push_back(Index.release()); 5293 continue; 5294 } 5295 5296 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 5297 ExprResult Start 5298 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 5299 if (Start.isInvalid()) 5300 return ExprError(); 5301 5302 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 5303 if (End.isInvalid()) 5304 return ExprError(); 5305 5306 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 5307 End.get(), 5308 D->getLBracketLoc(), 5309 D->getEllipsisLoc())); 5310 5311 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 5312 End.get() != E->getArrayRangeEnd(*D); 5313 5314 ArrayExprs.push_back(Start.release()); 5315 ArrayExprs.push_back(End.release()); 5316 } 5317 5318 if (!getDerived().AlwaysRebuild() && 5319 Init.get() == E->getInit() && 5320 !ExprChanged) 5321 return SemaRef.Owned(E); 5322 5323 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 5324 E->getEqualOrColonLoc(), 5325 E->usesGNUSyntax(), Init.get()); 5326} 5327 5328template<typename Derived> 5329ExprResult 5330TreeTransform<Derived>::TransformImplicitValueInitExpr( 5331 ImplicitValueInitExpr *E) { 5332 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 5333 5334 // FIXME: Will we ever have proper type location here? Will we actually 5335 // need to transform the type? 5336 QualType T = getDerived().TransformType(E->getType()); 5337 if (T.isNull()) 5338 return ExprError(); 5339 5340 if (!getDerived().AlwaysRebuild() && 5341 T == E->getType()) 5342 return SemaRef.Owned(E); 5343 5344 return getDerived().RebuildImplicitValueInitExpr(T); 5345} 5346 5347template<typename Derived> 5348ExprResult 5349TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 5350 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo()); 5351 if (!TInfo) 5352 return ExprError(); 5353 5354 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5355 if (SubExpr.isInvalid()) 5356 return ExprError(); 5357 5358 if (!getDerived().AlwaysRebuild() && 5359 TInfo == E->getWrittenTypeInfo() && 5360 SubExpr.get() == E->getSubExpr()) 5361 return SemaRef.Owned(E); 5362 5363 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(), 5364 TInfo, E->getRParenLoc()); 5365} 5366 5367template<typename Derived> 5368ExprResult 5369TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 5370 bool ArgumentChanged = false; 5371 ASTOwningVector<Expr*, 4> Inits(SemaRef); 5372 if (TransformExprs(E->getExprs(), E->getNumExprs(), true, Inits, 5373 &ArgumentChanged)) 5374 return ExprError(); 5375 5376 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 5377 move_arg(Inits), 5378 E->getRParenLoc()); 5379} 5380 5381/// \brief Transform an address-of-label expression. 5382/// 5383/// By default, the transformation of an address-of-label expression always 5384/// rebuilds the expression, so that the label identifier can be resolved to 5385/// the corresponding label statement by semantic analysis. 5386template<typename Derived> 5387ExprResult 5388TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 5389 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 5390 E->getLabel()); 5391} 5392 5393template<typename Derived> 5394ExprResult 5395TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 5396 StmtResult SubStmt 5397 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 5398 if (SubStmt.isInvalid()) 5399 return ExprError(); 5400 5401 if (!getDerived().AlwaysRebuild() && 5402 SubStmt.get() == E->getSubStmt()) 5403 return SemaRef.Owned(E); 5404 5405 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 5406 SubStmt.get(), 5407 E->getRParenLoc()); 5408} 5409 5410template<typename Derived> 5411ExprResult 5412TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 5413 ExprResult Cond = getDerived().TransformExpr(E->getCond()); 5414 if (Cond.isInvalid()) 5415 return ExprError(); 5416 5417 ExprResult LHS = getDerived().TransformExpr(E->getLHS()); 5418 if (LHS.isInvalid()) 5419 return ExprError(); 5420 5421 ExprResult RHS = getDerived().TransformExpr(E->getRHS()); 5422 if (RHS.isInvalid()) 5423 return ExprError(); 5424 5425 if (!getDerived().AlwaysRebuild() && 5426 Cond.get() == E->getCond() && 5427 LHS.get() == E->getLHS() && 5428 RHS.get() == E->getRHS()) 5429 return SemaRef.Owned(E); 5430 5431 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 5432 Cond.get(), LHS.get(), RHS.get(), 5433 E->getRParenLoc()); 5434} 5435 5436template<typename Derived> 5437ExprResult 5438TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 5439 return SemaRef.Owned(E); 5440} 5441 5442template<typename Derived> 5443ExprResult 5444TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 5445 switch (E->getOperator()) { 5446 case OO_New: 5447 case OO_Delete: 5448 case OO_Array_New: 5449 case OO_Array_Delete: 5450 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 5451 return ExprError(); 5452 5453 case OO_Call: { 5454 // This is a call to an object's operator(). 5455 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 5456 5457 // Transform the object itself. 5458 ExprResult Object = getDerived().TransformExpr(E->getArg(0)); 5459 if (Object.isInvalid()) 5460 return ExprError(); 5461 5462 // FIXME: Poor location information 5463 SourceLocation FakeLParenLoc 5464 = SemaRef.PP.getLocForEndOfToken( 5465 static_cast<Expr *>(Object.get())->getLocEnd()); 5466 5467 // Transform the call arguments. 5468 ASTOwningVector<Expr*> Args(SemaRef); 5469 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true, 5470 Args)) 5471 return ExprError(); 5472 5473 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, 5474 move_arg(Args), 5475 E->getLocEnd()); 5476 } 5477 5478#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 5479 case OO_##Name: 5480#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 5481#include "clang/Basic/OperatorKinds.def" 5482 case OO_Subscript: 5483 // Handled below. 5484 break; 5485 5486 case OO_Conditional: 5487 llvm_unreachable("conditional operator is not actually overloadable"); 5488 return ExprError(); 5489 5490 case OO_None: 5491 case NUM_OVERLOADED_OPERATORS: 5492 llvm_unreachable("not an overloaded operator?"); 5493 return ExprError(); 5494 } 5495 5496 ExprResult Callee = getDerived().TransformExpr(E->getCallee()); 5497 if (Callee.isInvalid()) 5498 return ExprError(); 5499 5500 ExprResult First = getDerived().TransformExpr(E->getArg(0)); 5501 if (First.isInvalid()) 5502 return ExprError(); 5503 5504 ExprResult Second; 5505 if (E->getNumArgs() == 2) { 5506 Second = getDerived().TransformExpr(E->getArg(1)); 5507 if (Second.isInvalid()) 5508 return ExprError(); 5509 } 5510 5511 if (!getDerived().AlwaysRebuild() && 5512 Callee.get() == E->getCallee() && 5513 First.get() == E->getArg(0) && 5514 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 5515 return SemaRef.Owned(E); 5516 5517 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 5518 E->getOperatorLoc(), 5519 Callee.get(), 5520 First.get(), 5521 Second.get()); 5522} 5523 5524template<typename Derived> 5525ExprResult 5526TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 5527 return getDerived().TransformCallExpr(E); 5528} 5529 5530template<typename Derived> 5531ExprResult 5532TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 5533 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5534 if (!Type) 5535 return ExprError(); 5536 5537 ExprResult SubExpr 5538 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5539 if (SubExpr.isInvalid()) 5540 return ExprError(); 5541 5542 if (!getDerived().AlwaysRebuild() && 5543 Type == E->getTypeInfoAsWritten() && 5544 SubExpr.get() == E->getSubExpr()) 5545 return SemaRef.Owned(E); 5546 5547 // FIXME: Poor source location information here. 5548 SourceLocation FakeLAngleLoc 5549 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 5550 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 5551 SourceLocation FakeRParenLoc 5552 = SemaRef.PP.getLocForEndOfToken( 5553 E->getSubExpr()->getSourceRange().getEnd()); 5554 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 5555 E->getStmtClass(), 5556 FakeLAngleLoc, 5557 Type, 5558 FakeRAngleLoc, 5559 FakeRAngleLoc, 5560 SubExpr.get(), 5561 FakeRParenLoc); 5562} 5563 5564template<typename Derived> 5565ExprResult 5566TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 5567 return getDerived().TransformCXXNamedCastExpr(E); 5568} 5569 5570template<typename Derived> 5571ExprResult 5572TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 5573 return getDerived().TransformCXXNamedCastExpr(E); 5574} 5575 5576template<typename Derived> 5577ExprResult 5578TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 5579 CXXReinterpretCastExpr *E) { 5580 return getDerived().TransformCXXNamedCastExpr(E); 5581} 5582 5583template<typename Derived> 5584ExprResult 5585TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 5586 return getDerived().TransformCXXNamedCastExpr(E); 5587} 5588 5589template<typename Derived> 5590ExprResult 5591TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 5592 CXXFunctionalCastExpr *E) { 5593 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten()); 5594 if (!Type) 5595 return ExprError(); 5596 5597 ExprResult SubExpr 5598 = getDerived().TransformExpr(E->getSubExprAsWritten()); 5599 if (SubExpr.isInvalid()) 5600 return ExprError(); 5601 5602 if (!getDerived().AlwaysRebuild() && 5603 Type == E->getTypeInfoAsWritten() && 5604 SubExpr.get() == E->getSubExpr()) 5605 return SemaRef.Owned(E); 5606 5607 return getDerived().RebuildCXXFunctionalCastExpr(Type, 5608 /*FIXME:*/E->getSubExpr()->getLocStart(), 5609 SubExpr.get(), 5610 E->getRParenLoc()); 5611} 5612 5613template<typename Derived> 5614ExprResult 5615TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 5616 if (E->isTypeOperand()) { 5617 TypeSourceInfo *TInfo 5618 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 5619 if (!TInfo) 5620 return ExprError(); 5621 5622 if (!getDerived().AlwaysRebuild() && 5623 TInfo == E->getTypeOperandSourceInfo()) 5624 return SemaRef.Owned(E); 5625 5626 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5627 E->getLocStart(), 5628 TInfo, 5629 E->getLocEnd()); 5630 } 5631 5632 // We don't know whether the expression is potentially evaluated until 5633 // after we perform semantic analysis, so the expression is potentially 5634 // potentially evaluated. 5635 EnterExpressionEvaluationContext Unevaluated(SemaRef, 5636 Sema::PotentiallyPotentiallyEvaluated); 5637 5638 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 5639 if (SubExpr.isInvalid()) 5640 return ExprError(); 5641 5642 if (!getDerived().AlwaysRebuild() && 5643 SubExpr.get() == E->getExprOperand()) 5644 return SemaRef.Owned(E); 5645 5646 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5647 E->getLocStart(), 5648 SubExpr.get(), 5649 E->getLocEnd()); 5650} 5651 5652template<typename Derived> 5653ExprResult 5654TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) { 5655 if (E->isTypeOperand()) { 5656 TypeSourceInfo *TInfo 5657 = getDerived().TransformType(E->getTypeOperandSourceInfo()); 5658 if (!TInfo) 5659 return ExprError(); 5660 5661 if (!getDerived().AlwaysRebuild() && 5662 TInfo == E->getTypeOperandSourceInfo()) 5663 return SemaRef.Owned(E); 5664 5665 return getDerived().RebuildCXXTypeidExpr(E->getType(), 5666 E->getLocStart(), 5667 TInfo, 5668 E->getLocEnd()); 5669 } 5670 5671 // We don't know whether the expression is potentially evaluated until 5672 // after we perform semantic analysis, so the expression is potentially 5673 // potentially evaluated. 5674 EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated); 5675 5676 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 5677 if (SubExpr.isInvalid()) 5678 return ExprError(); 5679 5680 if (!getDerived().AlwaysRebuild() && 5681 SubExpr.get() == E->getExprOperand()) 5682 return SemaRef.Owned(E); 5683 5684 return getDerived().RebuildCXXUuidofExpr(E->getType(), 5685 E->getLocStart(), 5686 SubExpr.get(), 5687 E->getLocEnd()); 5688} 5689 5690template<typename Derived> 5691ExprResult 5692TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 5693 return SemaRef.Owned(E); 5694} 5695 5696template<typename Derived> 5697ExprResult 5698TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 5699 CXXNullPtrLiteralExpr *E) { 5700 return SemaRef.Owned(E); 5701} 5702 5703template<typename Derived> 5704ExprResult 5705TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 5706 DeclContext *DC = getSema().getFunctionLevelDeclContext(); 5707 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC); 5708 QualType T = MD->getThisType(getSema().Context); 5709 5710 if (!getDerived().AlwaysRebuild() && T == E->getType()) 5711 return SemaRef.Owned(E); 5712 5713 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 5714} 5715 5716template<typename Derived> 5717ExprResult 5718TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 5719 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 5720 if (SubExpr.isInvalid()) 5721 return ExprError(); 5722 5723 if (!getDerived().AlwaysRebuild() && 5724 SubExpr.get() == E->getSubExpr()) 5725 return SemaRef.Owned(E); 5726 5727 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get()); 5728} 5729 5730template<typename Derived> 5731ExprResult 5732TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 5733 ParmVarDecl *Param 5734 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 5735 E->getParam())); 5736 if (!Param) 5737 return ExprError(); 5738 5739 if (!getDerived().AlwaysRebuild() && 5740 Param == E->getParam()) 5741 return SemaRef.Owned(E); 5742 5743 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 5744} 5745 5746template<typename Derived> 5747ExprResult 5748TreeTransform<Derived>::TransformCXXScalarValueInitExpr( 5749 CXXScalarValueInitExpr *E) { 5750 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 5751 if (!T) 5752 return ExprError(); 5753 5754 if (!getDerived().AlwaysRebuild() && 5755 T == E->getTypeSourceInfo()) 5756 return SemaRef.Owned(E); 5757 5758 return getDerived().RebuildCXXScalarValueInitExpr(T, 5759 /*FIXME:*/T->getTypeLoc().getEndLoc(), 5760 E->getRParenLoc()); 5761} 5762 5763template<typename Derived> 5764ExprResult 5765TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 5766 // Transform the type that we're allocating 5767 TypeSourceInfo *AllocTypeInfo 5768 = getDerived().TransformType(E->getAllocatedTypeSourceInfo()); 5769 if (!AllocTypeInfo) 5770 return ExprError(); 5771 5772 // Transform the size of the array we're allocating (if any). 5773 ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 5774 if (ArraySize.isInvalid()) 5775 return ExprError(); 5776 5777 // Transform the placement arguments (if any). 5778 bool ArgumentChanged = false; 5779 ASTOwningVector<Expr*> PlacementArgs(SemaRef); 5780 if (getDerived().TransformExprs(E->getPlacementArgs(), 5781 E->getNumPlacementArgs(), true, 5782 PlacementArgs, &ArgumentChanged)) 5783 return ExprError(); 5784 5785 // transform the constructor arguments (if any). 5786 ASTOwningVector<Expr*> ConstructorArgs(SemaRef); 5787 if (TransformExprs(E->getConstructorArgs(), E->getNumConstructorArgs(), true, 5788 ConstructorArgs, &ArgumentChanged)) 5789 return ExprError(); 5790 5791 // Transform constructor, new operator, and delete operator. 5792 CXXConstructorDecl *Constructor = 0; 5793 if (E->getConstructor()) { 5794 Constructor = cast_or_null<CXXConstructorDecl>( 5795 getDerived().TransformDecl(E->getLocStart(), 5796 E->getConstructor())); 5797 if (!Constructor) 5798 return ExprError(); 5799 } 5800 5801 FunctionDecl *OperatorNew = 0; 5802 if (E->getOperatorNew()) { 5803 OperatorNew = cast_or_null<FunctionDecl>( 5804 getDerived().TransformDecl(E->getLocStart(), 5805 E->getOperatorNew())); 5806 if (!OperatorNew) 5807 return ExprError(); 5808 } 5809 5810 FunctionDecl *OperatorDelete = 0; 5811 if (E->getOperatorDelete()) { 5812 OperatorDelete = cast_or_null<FunctionDecl>( 5813 getDerived().TransformDecl(E->getLocStart(), 5814 E->getOperatorDelete())); 5815 if (!OperatorDelete) 5816 return ExprError(); 5817 } 5818 5819 if (!getDerived().AlwaysRebuild() && 5820 AllocTypeInfo == E->getAllocatedTypeSourceInfo() && 5821 ArraySize.get() == E->getArraySize() && 5822 Constructor == E->getConstructor() && 5823 OperatorNew == E->getOperatorNew() && 5824 OperatorDelete == E->getOperatorDelete() && 5825 !ArgumentChanged) { 5826 // Mark any declarations we need as referenced. 5827 // FIXME: instantiation-specific. 5828 if (Constructor) 5829 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 5830 if (OperatorNew) 5831 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew); 5832 if (OperatorDelete) 5833 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 5834 return SemaRef.Owned(E); 5835 } 5836 5837 QualType AllocType = AllocTypeInfo->getType(); 5838 if (!ArraySize.get()) { 5839 // If no array size was specified, but the new expression was 5840 // instantiated with an array type (e.g., "new T" where T is 5841 // instantiated with "int[4]"), extract the outer bound from the 5842 // array type as our array size. We do this with constant and 5843 // dependently-sized array types. 5844 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 5845 if (!ArrayT) { 5846 // Do nothing 5847 } else if (const ConstantArrayType *ConsArrayT 5848 = dyn_cast<ConstantArrayType>(ArrayT)) { 5849 ArraySize 5850 = SemaRef.Owned(IntegerLiteral::Create(SemaRef.Context, 5851 ConsArrayT->getSize(), 5852 SemaRef.Context.getSizeType(), 5853 /*FIXME:*/E->getLocStart())); 5854 AllocType = ConsArrayT->getElementType(); 5855 } else if (const DependentSizedArrayType *DepArrayT 5856 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 5857 if (DepArrayT->getSizeExpr()) { 5858 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()); 5859 AllocType = DepArrayT->getElementType(); 5860 } 5861 } 5862 } 5863 5864 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 5865 E->isGlobalNew(), 5866 /*FIXME:*/E->getLocStart(), 5867 move_arg(PlacementArgs), 5868 /*FIXME:*/E->getLocStart(), 5869 E->getTypeIdParens(), 5870 AllocType, 5871 AllocTypeInfo, 5872 ArraySize.get(), 5873 /*FIXME:*/E->getLocStart(), 5874 move_arg(ConstructorArgs), 5875 E->getLocEnd()); 5876} 5877 5878template<typename Derived> 5879ExprResult 5880TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 5881 ExprResult Operand = getDerived().TransformExpr(E->getArgument()); 5882 if (Operand.isInvalid()) 5883 return ExprError(); 5884 5885 // Transform the delete operator, if known. 5886 FunctionDecl *OperatorDelete = 0; 5887 if (E->getOperatorDelete()) { 5888 OperatorDelete = cast_or_null<FunctionDecl>( 5889 getDerived().TransformDecl(E->getLocStart(), 5890 E->getOperatorDelete())); 5891 if (!OperatorDelete) 5892 return ExprError(); 5893 } 5894 5895 if (!getDerived().AlwaysRebuild() && 5896 Operand.get() == E->getArgument() && 5897 OperatorDelete == E->getOperatorDelete()) { 5898 // Mark any declarations we need as referenced. 5899 // FIXME: instantiation-specific. 5900 if (OperatorDelete) 5901 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 5902 5903 if (!E->getArgument()->isTypeDependent()) { 5904 QualType Destroyed = SemaRef.Context.getBaseElementType( 5905 E->getDestroyedType()); 5906 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 5907 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 5908 SemaRef.MarkDeclarationReferenced(E->getLocStart(), 5909 SemaRef.LookupDestructor(Record)); 5910 } 5911 } 5912 5913 return SemaRef.Owned(E); 5914 } 5915 5916 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 5917 E->isGlobalDelete(), 5918 E->isArrayForm(), 5919 Operand.get()); 5920} 5921 5922template<typename Derived> 5923ExprResult 5924TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 5925 CXXPseudoDestructorExpr *E) { 5926 ExprResult Base = getDerived().TransformExpr(E->getBase()); 5927 if (Base.isInvalid()) 5928 return ExprError(); 5929 5930 ParsedType ObjectTypePtr; 5931 bool MayBePseudoDestructor = false; 5932 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 5933 E->getOperatorLoc(), 5934 E->isArrow()? tok::arrow : tok::period, 5935 ObjectTypePtr, 5936 MayBePseudoDestructor); 5937 if (Base.isInvalid()) 5938 return ExprError(); 5939 5940 QualType ObjectType = ObjectTypePtr.get(); 5941 NestedNameSpecifier *Qualifier = E->getQualifier(); 5942 if (Qualifier) { 5943 Qualifier 5944 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5945 E->getQualifierRange(), 5946 ObjectType); 5947 if (!Qualifier) 5948 return ExprError(); 5949 } 5950 5951 PseudoDestructorTypeStorage Destroyed; 5952 if (E->getDestroyedTypeInfo()) { 5953 TypeSourceInfo *DestroyedTypeInfo 5954 = getDerived().TransformTypeInObjectScope(E->getDestroyedTypeInfo(), 5955 ObjectType, 0, Qualifier); 5956 if (!DestroyedTypeInfo) 5957 return ExprError(); 5958 Destroyed = DestroyedTypeInfo; 5959 } else if (ObjectType->isDependentType()) { 5960 // We aren't likely to be able to resolve the identifier down to a type 5961 // now anyway, so just retain the identifier. 5962 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 5963 E->getDestroyedTypeLoc()); 5964 } else { 5965 // Look for a destructor known with the given name. 5966 CXXScopeSpec SS; 5967 if (Qualifier) { 5968 SS.setScopeRep(Qualifier); 5969 SS.setRange(E->getQualifierRange()); 5970 } 5971 5972 ParsedType T = SemaRef.getDestructorName(E->getTildeLoc(), 5973 *E->getDestroyedTypeIdentifier(), 5974 E->getDestroyedTypeLoc(), 5975 /*Scope=*/0, 5976 SS, ObjectTypePtr, 5977 false); 5978 if (!T) 5979 return ExprError(); 5980 5981 Destroyed 5982 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 5983 E->getDestroyedTypeLoc()); 5984 } 5985 5986 TypeSourceInfo *ScopeTypeInfo = 0; 5987 if (E->getScopeTypeInfo()) { 5988 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo()); 5989 if (!ScopeTypeInfo) 5990 return ExprError(); 5991 } 5992 5993 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(), 5994 E->getOperatorLoc(), 5995 E->isArrow(), 5996 Qualifier, 5997 E->getQualifierRange(), 5998 ScopeTypeInfo, 5999 E->getColonColonLoc(), 6000 E->getTildeLoc(), 6001 Destroyed); 6002} 6003 6004template<typename Derived> 6005ExprResult 6006TreeTransform<Derived>::TransformUnresolvedLookupExpr( 6007 UnresolvedLookupExpr *Old) { 6008 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName()); 6009 6010 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 6011 Sema::LookupOrdinaryName); 6012 6013 // Transform all the decls. 6014 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 6015 E = Old->decls_end(); I != E; ++I) { 6016 NamedDecl *InstD = static_cast<NamedDecl*>( 6017 getDerived().TransformDecl(Old->getNameLoc(), 6018 *I)); 6019 if (!InstD) { 6020 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 6021 // This can happen because of dependent hiding. 6022 if (isa<UsingShadowDecl>(*I)) 6023 continue; 6024 else 6025 return ExprError(); 6026 } 6027 6028 // Expand using declarations. 6029 if (isa<UsingDecl>(InstD)) { 6030 UsingDecl *UD = cast<UsingDecl>(InstD); 6031 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 6032 E = UD->shadow_end(); I != E; ++I) 6033 R.addDecl(*I); 6034 continue; 6035 } 6036 6037 R.addDecl(InstD); 6038 } 6039 6040 // Resolve a kind, but don't do any further analysis. If it's 6041 // ambiguous, the callee needs to deal with it. 6042 R.resolveKind(); 6043 6044 // Rebuild the nested-name qualifier, if present. 6045 CXXScopeSpec SS; 6046 NestedNameSpecifier *Qualifier = 0; 6047 if (Old->getQualifier()) { 6048 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 6049 Old->getQualifierRange()); 6050 if (!Qualifier) 6051 return ExprError(); 6052 6053 SS.setScopeRep(Qualifier); 6054 SS.setRange(Old->getQualifierRange()); 6055 } 6056 6057 if (Old->getNamingClass()) { 6058 CXXRecordDecl *NamingClass 6059 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 6060 Old->getNameLoc(), 6061 Old->getNamingClass())); 6062 if (!NamingClass) 6063 return ExprError(); 6064 6065 R.setNamingClass(NamingClass); 6066 } 6067 6068 // If we have no template arguments, it's a normal declaration name. 6069 if (!Old->hasExplicitTemplateArgs()) 6070 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 6071 6072 // If we have template arguments, rebuild them, then rebuild the 6073 // templateid expression. 6074 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 6075 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 6076 Old->getNumTemplateArgs(), 6077 TransArgs)) 6078 return ExprError(); 6079 6080 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(), 6081 TransArgs); 6082} 6083 6084template<typename Derived> 6085ExprResult 6086TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 6087 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo()); 6088 if (!T) 6089 return ExprError(); 6090 6091 if (!getDerived().AlwaysRebuild() && 6092 T == E->getQueriedTypeSourceInfo()) 6093 return SemaRef.Owned(E); 6094 6095 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 6096 E->getLocStart(), 6097 T, 6098 E->getLocEnd()); 6099} 6100 6101template<typename Derived> 6102ExprResult 6103TreeTransform<Derived>::TransformBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 6104 TypeSourceInfo *LhsT = getDerived().TransformType(E->getLhsTypeSourceInfo()); 6105 if (!LhsT) 6106 return ExprError(); 6107 6108 TypeSourceInfo *RhsT = getDerived().TransformType(E->getRhsTypeSourceInfo()); 6109 if (!RhsT) 6110 return ExprError(); 6111 6112 if (!getDerived().AlwaysRebuild() && 6113 LhsT == E->getLhsTypeSourceInfo() && RhsT == E->getRhsTypeSourceInfo()) 6114 return SemaRef.Owned(E); 6115 6116 return getDerived().RebuildBinaryTypeTrait(E->getTrait(), 6117 E->getLocStart(), 6118 LhsT, RhsT, 6119 E->getLocEnd()); 6120} 6121 6122template<typename Derived> 6123ExprResult 6124TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 6125 DependentScopeDeclRefExpr *E) { 6126 NestedNameSpecifier *NNS 6127 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 6128 E->getQualifierRange()); 6129 if (!NNS) 6130 return ExprError(); 6131 6132 // TODO: If this is a conversion-function-id, verify that the 6133 // destination type name (if present) resolves the same way after 6134 // instantiation as it did in the local scope. 6135 6136 DeclarationNameInfo NameInfo 6137 = getDerived().TransformDeclarationNameInfo(E->getNameInfo()); 6138 if (!NameInfo.getName()) 6139 return ExprError(); 6140 6141 if (!E->hasExplicitTemplateArgs()) { 6142 if (!getDerived().AlwaysRebuild() && 6143 NNS == E->getQualifier() && 6144 // Note: it is sufficient to compare the Name component of NameInfo: 6145 // if name has not changed, DNLoc has not changed either. 6146 NameInfo.getName() == E->getDeclName()) 6147 return SemaRef.Owned(E); 6148 6149 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 6150 E->getQualifierRange(), 6151 NameInfo, 6152 /*TemplateArgs*/ 0); 6153 } 6154 6155 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6156 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6157 E->getNumTemplateArgs(), 6158 TransArgs)) 6159 return ExprError(); 6160 6161 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 6162 E->getQualifierRange(), 6163 NameInfo, 6164 &TransArgs); 6165} 6166 6167template<typename Derived> 6168ExprResult 6169TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 6170 // CXXConstructExprs are always implicit, so when we have a 6171 // 1-argument construction we just transform that argument. 6172 if (E->getNumArgs() == 1 || 6173 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) 6174 return getDerived().TransformExpr(E->getArg(0)); 6175 6176 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 6177 6178 QualType T = getDerived().TransformType(E->getType()); 6179 if (T.isNull()) 6180 return ExprError(); 6181 6182 CXXConstructorDecl *Constructor 6183 = cast_or_null<CXXConstructorDecl>( 6184 getDerived().TransformDecl(E->getLocStart(), 6185 E->getConstructor())); 6186 if (!Constructor) 6187 return ExprError(); 6188 6189 bool ArgumentChanged = false; 6190 ASTOwningVector<Expr*> Args(SemaRef); 6191 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6192 &ArgumentChanged)) 6193 return ExprError(); 6194 6195 if (!getDerived().AlwaysRebuild() && 6196 T == E->getType() && 6197 Constructor == E->getConstructor() && 6198 !ArgumentChanged) { 6199 // Mark the constructor as referenced. 6200 // FIXME: Instantiation-specific 6201 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6202 return SemaRef.Owned(E); 6203 } 6204 6205 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 6206 Constructor, E->isElidable(), 6207 move_arg(Args), 6208 E->requiresZeroInitialization(), 6209 E->getConstructionKind(), 6210 E->getParenRange()); 6211} 6212 6213/// \brief Transform a C++ temporary-binding expression. 6214/// 6215/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 6216/// transform the subexpression and return that. 6217template<typename Derived> 6218ExprResult 6219TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 6220 return getDerived().TransformExpr(E->getSubExpr()); 6221} 6222 6223/// \brief Transform a C++ expression that contains cleanups that should 6224/// be run after the expression is evaluated. 6225/// 6226/// Since ExprWithCleanups nodes are implicitly generated, we 6227/// just transform the subexpression and return that. 6228template<typename Derived> 6229ExprResult 6230TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) { 6231 return getDerived().TransformExpr(E->getSubExpr()); 6232} 6233 6234template<typename Derived> 6235ExprResult 6236TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 6237 CXXTemporaryObjectExpr *E) { 6238 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6239 if (!T) 6240 return ExprError(); 6241 6242 CXXConstructorDecl *Constructor 6243 = cast_or_null<CXXConstructorDecl>( 6244 getDerived().TransformDecl(E->getLocStart(), 6245 E->getConstructor())); 6246 if (!Constructor) 6247 return ExprError(); 6248 6249 bool ArgumentChanged = false; 6250 ASTOwningVector<Expr*> Args(SemaRef); 6251 Args.reserve(E->getNumArgs()); 6252 if (TransformExprs(E->getArgs(), E->getNumArgs(), true, Args, 6253 &ArgumentChanged)) 6254 return ExprError(); 6255 6256 if (!getDerived().AlwaysRebuild() && 6257 T == E->getTypeSourceInfo() && 6258 Constructor == E->getConstructor() && 6259 !ArgumentChanged) { 6260 // FIXME: Instantiation-specific 6261 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 6262 return SemaRef.MaybeBindToTemporary(E); 6263 } 6264 6265 return getDerived().RebuildCXXTemporaryObjectExpr(T, 6266 /*FIXME:*/T->getTypeLoc().getEndLoc(), 6267 move_arg(Args), 6268 E->getLocEnd()); 6269} 6270 6271template<typename Derived> 6272ExprResult 6273TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 6274 CXXUnresolvedConstructExpr *E) { 6275 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo()); 6276 if (!T) 6277 return ExprError(); 6278 6279 bool ArgumentChanged = false; 6280 ASTOwningVector<Expr*> Args(SemaRef); 6281 Args.reserve(E->arg_size()); 6282 if (getDerived().TransformExprs(E->arg_begin(), E->arg_size(), true, Args, 6283 &ArgumentChanged)) 6284 return ExprError(); 6285 6286 if (!getDerived().AlwaysRebuild() && 6287 T == E->getTypeSourceInfo() && 6288 !ArgumentChanged) 6289 return SemaRef.Owned(E); 6290 6291 // FIXME: we're faking the locations of the commas 6292 return getDerived().RebuildCXXUnresolvedConstructExpr(T, 6293 E->getLParenLoc(), 6294 move_arg(Args), 6295 E->getRParenLoc()); 6296} 6297 6298template<typename Derived> 6299ExprResult 6300TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 6301 CXXDependentScopeMemberExpr *E) { 6302 // Transform the base of the expression. 6303 ExprResult Base((Expr*) 0); 6304 Expr *OldBase; 6305 QualType BaseType; 6306 QualType ObjectType; 6307 if (!E->isImplicitAccess()) { 6308 OldBase = E->getBase(); 6309 Base = getDerived().TransformExpr(OldBase); 6310 if (Base.isInvalid()) 6311 return ExprError(); 6312 6313 // Start the member reference and compute the object's type. 6314 ParsedType ObjectTy; 6315 bool MayBePseudoDestructor = false; 6316 Base = SemaRef.ActOnStartCXXMemberReference(0, Base.get(), 6317 E->getOperatorLoc(), 6318 E->isArrow()? tok::arrow : tok::period, 6319 ObjectTy, 6320 MayBePseudoDestructor); 6321 if (Base.isInvalid()) 6322 return ExprError(); 6323 6324 ObjectType = ObjectTy.get(); 6325 BaseType = ((Expr*) Base.get())->getType(); 6326 } else { 6327 OldBase = 0; 6328 BaseType = getDerived().TransformType(E->getBaseType()); 6329 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 6330 } 6331 6332 // Transform the first part of the nested-name-specifier that qualifies 6333 // the member name. 6334 NamedDecl *FirstQualifierInScope 6335 = getDerived().TransformFirstQualifierInScope( 6336 E->getFirstQualifierFoundInScope(), 6337 E->getQualifierRange().getBegin()); 6338 6339 NestedNameSpecifier *Qualifier = 0; 6340 if (E->getQualifier()) { 6341 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 6342 E->getQualifierRange(), 6343 ObjectType, 6344 FirstQualifierInScope); 6345 if (!Qualifier) 6346 return ExprError(); 6347 } 6348 6349 // TODO: If this is a conversion-function-id, verify that the 6350 // destination type name (if present) resolves the same way after 6351 // instantiation as it did in the local scope. 6352 6353 DeclarationNameInfo NameInfo 6354 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo()); 6355 if (!NameInfo.getName()) 6356 return ExprError(); 6357 6358 if (!E->hasExplicitTemplateArgs()) { 6359 // This is a reference to a member without an explicitly-specified 6360 // template argument list. Optimize for this common case. 6361 if (!getDerived().AlwaysRebuild() && 6362 Base.get() == OldBase && 6363 BaseType == E->getBaseType() && 6364 Qualifier == E->getQualifier() && 6365 NameInfo.getName() == E->getMember() && 6366 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 6367 return SemaRef.Owned(E); 6368 6369 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6370 BaseType, 6371 E->isArrow(), 6372 E->getOperatorLoc(), 6373 Qualifier, 6374 E->getQualifierRange(), 6375 FirstQualifierInScope, 6376 NameInfo, 6377 /*TemplateArgs*/ 0); 6378 } 6379 6380 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 6381 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(), 6382 E->getNumTemplateArgs(), 6383 TransArgs)) 6384 return ExprError(); 6385 6386 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(), 6387 BaseType, 6388 E->isArrow(), 6389 E->getOperatorLoc(), 6390 Qualifier, 6391 E->getQualifierRange(), 6392 FirstQualifierInScope, 6393 NameInfo, 6394 &TransArgs); 6395} 6396 6397template<typename Derived> 6398ExprResult 6399TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 6400 // Transform the base of the expression. 6401 ExprResult Base((Expr*) 0); 6402 QualType BaseType; 6403 if (!Old->isImplicitAccess()) { 6404 Base = getDerived().TransformExpr(Old->getBase()); 6405 if (Base.isInvalid()) 6406 return ExprError(); 6407 BaseType = ((Expr*) Base.get())->getType(); 6408 } else { 6409 BaseType = getDerived().TransformType(Old->getBaseType()); 6410 } 6411 6412 NestedNameSpecifier *Qualifier = 0; 6413 if (Old->getQualifier()) { 6414 Qualifier 6415 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 6416 Old->getQualifierRange()); 6417 if (Qualifier == 0) 6418 return ExprError(); 6419 } 6420 6421 LookupResult R(SemaRef, Old->getMemberNameInfo(), 6422 Sema::LookupOrdinaryName); 6423 6424 // Transform all the decls. 6425 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 6426 E = Old->decls_end(); I != E; ++I) { 6427 NamedDecl *InstD = static_cast<NamedDecl*>( 6428 getDerived().TransformDecl(Old->getMemberLoc(), 6429 *I)); 6430 if (!InstD) { 6431 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 6432 // This can happen because of dependent hiding. 6433 if (isa<UsingShadowDecl>(*I)) 6434 continue; 6435 else 6436 return ExprError(); 6437 } 6438 6439 // Expand using declarations. 6440 if (isa<UsingDecl>(InstD)) { 6441 UsingDecl *UD = cast<UsingDecl>(InstD); 6442 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 6443 E = UD->shadow_end(); I != E; ++I) 6444 R.addDecl(*I); 6445 continue; 6446 } 6447 6448 R.addDecl(InstD); 6449 } 6450 6451 R.resolveKind(); 6452 6453 // Determine the naming class. 6454 if (Old->getNamingClass()) { 6455 CXXRecordDecl *NamingClass 6456 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl( 6457 Old->getMemberLoc(), 6458 Old->getNamingClass())); 6459 if (!NamingClass) 6460 return ExprError(); 6461 6462 R.setNamingClass(NamingClass); 6463 } 6464 6465 TemplateArgumentListInfo TransArgs; 6466 if (Old->hasExplicitTemplateArgs()) { 6467 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 6468 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 6469 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(), 6470 Old->getNumTemplateArgs(), 6471 TransArgs)) 6472 return ExprError(); 6473 } 6474 6475 // FIXME: to do this check properly, we will need to preserve the 6476 // first-qualifier-in-scope here, just in case we had a dependent 6477 // base (and therefore couldn't do the check) and a 6478 // nested-name-qualifier (and therefore could do the lookup). 6479 NamedDecl *FirstQualifierInScope = 0; 6480 6481 return getDerived().RebuildUnresolvedMemberExpr(Base.get(), 6482 BaseType, 6483 Old->getOperatorLoc(), 6484 Old->isArrow(), 6485 Qualifier, 6486 Old->getQualifierRange(), 6487 FirstQualifierInScope, 6488 R, 6489 (Old->hasExplicitTemplateArgs() 6490 ? &TransArgs : 0)); 6491} 6492 6493template<typename Derived> 6494ExprResult 6495TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) { 6496 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand()); 6497 if (SubExpr.isInvalid()) 6498 return ExprError(); 6499 6500 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand()) 6501 return SemaRef.Owned(E); 6502 6503 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get()); 6504} 6505 6506template<typename Derived> 6507ExprResult 6508TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) { 6509 llvm_unreachable("pack expansion expression in unhandled context"); 6510 return ExprError(); 6511} 6512 6513template<typename Derived> 6514ExprResult 6515TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { 6516 // If E is not value-dependent, then nothing will change when we transform it. 6517 // Note: This is an instantiation-centric view. 6518 if (!E->isValueDependent()) 6519 return SemaRef.Owned(E); 6520 6521 // Note: None of the implementations of TryExpandParameterPacks can ever 6522 // produce a diagnostic when given only a single unexpanded parameter pack, 6523 // so 6524 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); 6525 bool ShouldExpand = false; 6526 unsigned NumExpansions = 0; 6527 if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), 6528 &Unexpanded, 1, 6529 ShouldExpand, NumExpansions)) 6530 return ExprError(); 6531 6532 if (!ShouldExpand) 6533 return SemaRef.Owned(E); 6534 6535 // We now know the length of the parameter pack, so build a new expression 6536 // that stores that length. 6537 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(), 6538 E->getPackLoc(), E->getRParenLoc(), 6539 NumExpansions); 6540} 6541 6542template<typename Derived> 6543ExprResult 6544TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 6545 return SemaRef.Owned(E); 6546} 6547 6548template<typename Derived> 6549ExprResult 6550TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 6551 TypeSourceInfo *EncodedTypeInfo 6552 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 6553 if (!EncodedTypeInfo) 6554 return ExprError(); 6555 6556 if (!getDerived().AlwaysRebuild() && 6557 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 6558 return SemaRef.Owned(E); 6559 6560 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 6561 EncodedTypeInfo, 6562 E->getRParenLoc()); 6563} 6564 6565template<typename Derived> 6566ExprResult 6567TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 6568 // Transform arguments. 6569 bool ArgChanged = false; 6570 ASTOwningVector<Expr*> Args(SemaRef); 6571 Args.reserve(E->getNumArgs()); 6572 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args, 6573 &ArgChanged)) 6574 return ExprError(); 6575 6576 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 6577 // Class message: transform the receiver type. 6578 TypeSourceInfo *ReceiverTypeInfo 6579 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 6580 if (!ReceiverTypeInfo) 6581 return ExprError(); 6582 6583 // If nothing changed, just retain the existing message send. 6584 if (!getDerived().AlwaysRebuild() && 6585 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 6586 return SemaRef.Owned(E); 6587 6588 // Build a new class message send. 6589 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 6590 E->getSelector(), 6591 E->getSelectorLoc(), 6592 E->getMethodDecl(), 6593 E->getLeftLoc(), 6594 move_arg(Args), 6595 E->getRightLoc()); 6596 } 6597 6598 // Instance message: transform the receiver 6599 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 6600 "Only class and instance messages may be instantiated"); 6601 ExprResult Receiver 6602 = getDerived().TransformExpr(E->getInstanceReceiver()); 6603 if (Receiver.isInvalid()) 6604 return ExprError(); 6605 6606 // If nothing changed, just retain the existing message send. 6607 if (!getDerived().AlwaysRebuild() && 6608 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 6609 return SemaRef.Owned(E); 6610 6611 // Build a new instance message send. 6612 return getDerived().RebuildObjCMessageExpr(Receiver.get(), 6613 E->getSelector(), 6614 E->getSelectorLoc(), 6615 E->getMethodDecl(), 6616 E->getLeftLoc(), 6617 move_arg(Args), 6618 E->getRightLoc()); 6619} 6620 6621template<typename Derived> 6622ExprResult 6623TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 6624 return SemaRef.Owned(E); 6625} 6626 6627template<typename Derived> 6628ExprResult 6629TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 6630 return SemaRef.Owned(E); 6631} 6632 6633template<typename Derived> 6634ExprResult 6635TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 6636 // Transform the base expression. 6637 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6638 if (Base.isInvalid()) 6639 return ExprError(); 6640 6641 // We don't need to transform the ivar; it will never change. 6642 6643 // If nothing changed, just retain the existing expression. 6644 if (!getDerived().AlwaysRebuild() && 6645 Base.get() == E->getBase()) 6646 return SemaRef.Owned(E); 6647 6648 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(), 6649 E->getLocation(), 6650 E->isArrow(), E->isFreeIvar()); 6651} 6652 6653template<typename Derived> 6654ExprResult 6655TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 6656 // 'super' and types never change. Property never changes. Just 6657 // retain the existing expression. 6658 if (!E->isObjectReceiver()) 6659 return SemaRef.Owned(E); 6660 6661 // Transform the base expression. 6662 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6663 if (Base.isInvalid()) 6664 return ExprError(); 6665 6666 // We don't need to transform the property; it will never change. 6667 6668 // If nothing changed, just retain the existing expression. 6669 if (!getDerived().AlwaysRebuild() && 6670 Base.get() == E->getBase()) 6671 return SemaRef.Owned(E); 6672 6673 if (E->isExplicitProperty()) 6674 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 6675 E->getExplicitProperty(), 6676 E->getLocation()); 6677 6678 return getDerived().RebuildObjCPropertyRefExpr(Base.get(), 6679 E->getType(), 6680 E->getImplicitPropertyGetter(), 6681 E->getImplicitPropertySetter(), 6682 E->getLocation()); 6683} 6684 6685template<typename Derived> 6686ExprResult 6687TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 6688 // Transform the base expression. 6689 ExprResult Base = getDerived().TransformExpr(E->getBase()); 6690 if (Base.isInvalid()) 6691 return ExprError(); 6692 6693 // If nothing changed, just retain the existing expression. 6694 if (!getDerived().AlwaysRebuild() && 6695 Base.get() == E->getBase()) 6696 return SemaRef.Owned(E); 6697 6698 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(), 6699 E->isArrow()); 6700} 6701 6702template<typename Derived> 6703ExprResult 6704TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 6705 bool ArgumentChanged = false; 6706 ASTOwningVector<Expr*> SubExprs(SemaRef); 6707 SubExprs.reserve(E->getNumSubExprs()); 6708 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false, 6709 SubExprs, &ArgumentChanged)) 6710 return ExprError(); 6711 6712 if (!getDerived().AlwaysRebuild() && 6713 !ArgumentChanged) 6714 return SemaRef.Owned(E); 6715 6716 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 6717 move_arg(SubExprs), 6718 E->getRParenLoc()); 6719} 6720 6721template<typename Derived> 6722ExprResult 6723TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 6724 SourceLocation CaretLoc(E->getExprLoc()); 6725 6726 SemaRef.ActOnBlockStart(CaretLoc, /*Scope=*/0); 6727 BlockScopeInfo *CurBlock = SemaRef.getCurBlock(); 6728 CurBlock->TheDecl->setIsVariadic(E->getBlockDecl()->isVariadic()); 6729 llvm::SmallVector<ParmVarDecl*, 4> Params; 6730 llvm::SmallVector<QualType, 4> ParamTypes; 6731 6732 // Parameter substitution. 6733 const BlockDecl *BD = E->getBlockDecl(); 6734 for (BlockDecl::param_const_iterator P = BD->param_begin(), 6735 EN = BD->param_end(); P != EN; ++P) { 6736 ParmVarDecl *OldParm = (*P); 6737 ParmVarDecl *NewParm = getDerived().TransformFunctionTypeParam(OldParm); 6738 QualType NewType = NewParm->getType(); 6739 Params.push_back(NewParm); 6740 ParamTypes.push_back(NewParm->getType()); 6741 } 6742 6743 const FunctionType *BExprFunctionType = E->getFunctionType(); 6744 QualType BExprResultType = BExprFunctionType->getResultType(); 6745 if (!BExprResultType.isNull()) { 6746 if (!BExprResultType->isDependentType()) 6747 CurBlock->ReturnType = BExprResultType; 6748 else if (BExprResultType != SemaRef.Context.DependentTy) 6749 CurBlock->ReturnType = getDerived().TransformType(BExprResultType); 6750 } 6751 6752 QualType FunctionType = getDerived().RebuildFunctionProtoType( 6753 CurBlock->ReturnType, 6754 ParamTypes.data(), 6755 ParamTypes.size(), 6756 BD->isVariadic(), 6757 0, 6758 BExprFunctionType->getExtInfo()); 6759 CurBlock->FunctionType = FunctionType; 6760 6761 // Set the parameters on the block decl. 6762 if (!Params.empty()) 6763 CurBlock->TheDecl->setParams(Params.data(), Params.size()); 6764 6765 // Transform the body 6766 StmtResult Body = getDerived().TransformStmt(E->getBody()); 6767 if (Body.isInvalid()) 6768 return ExprError(); 6769 6770 return SemaRef.ActOnBlockStmtExpr(CaretLoc, Body.get(), /*Scope=*/0); 6771} 6772 6773template<typename Derived> 6774ExprResult 6775TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 6776 NestedNameSpecifier *Qualifier = 0; 6777 6778 ValueDecl *ND 6779 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 6780 E->getDecl())); 6781 if (!ND) 6782 return ExprError(); 6783 6784 if (!getDerived().AlwaysRebuild() && 6785 ND == E->getDecl()) { 6786 // Mark it referenced in the new context regardless. 6787 // FIXME: this is a bit instantiation-specific. 6788 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 6789 6790 return SemaRef.Owned(E); 6791 } 6792 6793 DeclarationNameInfo NameInfo(E->getDecl()->getDeclName(), E->getLocation()); 6794 return getDerived().RebuildDeclRefExpr(Qualifier, SourceLocation(), 6795 ND, NameInfo, 0); 6796} 6797 6798//===----------------------------------------------------------------------===// 6799// Type reconstruction 6800//===----------------------------------------------------------------------===// 6801 6802template<typename Derived> 6803QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 6804 SourceLocation Star) { 6805 return SemaRef.BuildPointerType(PointeeType, Star, 6806 getDerived().getBaseEntity()); 6807} 6808 6809template<typename Derived> 6810QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 6811 SourceLocation Star) { 6812 return SemaRef.BuildBlockPointerType(PointeeType, Star, 6813 getDerived().getBaseEntity()); 6814} 6815 6816template<typename Derived> 6817QualType 6818TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 6819 bool WrittenAsLValue, 6820 SourceLocation Sigil) { 6821 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, 6822 Sigil, getDerived().getBaseEntity()); 6823} 6824 6825template<typename Derived> 6826QualType 6827TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 6828 QualType ClassType, 6829 SourceLocation Sigil) { 6830 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, 6831 Sigil, getDerived().getBaseEntity()); 6832} 6833 6834template<typename Derived> 6835QualType 6836TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 6837 ArrayType::ArraySizeModifier SizeMod, 6838 const llvm::APInt *Size, 6839 Expr *SizeExpr, 6840 unsigned IndexTypeQuals, 6841 SourceRange BracketsRange) { 6842 if (SizeExpr || !Size) 6843 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 6844 IndexTypeQuals, BracketsRange, 6845 getDerived().getBaseEntity()); 6846 6847 QualType Types[] = { 6848 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 6849 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 6850 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 6851 }; 6852 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 6853 QualType SizeType; 6854 for (unsigned I = 0; I != NumTypes; ++I) 6855 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 6856 SizeType = Types[I]; 6857 break; 6858 } 6859 6860 IntegerLiteral ArraySize(SemaRef.Context, *Size, SizeType, 6861 /*FIXME*/BracketsRange.getBegin()); 6862 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 6863 IndexTypeQuals, BracketsRange, 6864 getDerived().getBaseEntity()); 6865} 6866 6867template<typename Derived> 6868QualType 6869TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 6870 ArrayType::ArraySizeModifier SizeMod, 6871 const llvm::APInt &Size, 6872 unsigned IndexTypeQuals, 6873 SourceRange BracketsRange) { 6874 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 6875 IndexTypeQuals, BracketsRange); 6876} 6877 6878template<typename Derived> 6879QualType 6880TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 6881 ArrayType::ArraySizeModifier SizeMod, 6882 unsigned IndexTypeQuals, 6883 SourceRange BracketsRange) { 6884 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 6885 IndexTypeQuals, BracketsRange); 6886} 6887 6888template<typename Derived> 6889QualType 6890TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 6891 ArrayType::ArraySizeModifier SizeMod, 6892 Expr *SizeExpr, 6893 unsigned IndexTypeQuals, 6894 SourceRange BracketsRange) { 6895 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 6896 SizeExpr, 6897 IndexTypeQuals, BracketsRange); 6898} 6899 6900template<typename Derived> 6901QualType 6902TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 6903 ArrayType::ArraySizeModifier SizeMod, 6904 Expr *SizeExpr, 6905 unsigned IndexTypeQuals, 6906 SourceRange BracketsRange) { 6907 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 6908 SizeExpr, 6909 IndexTypeQuals, BracketsRange); 6910} 6911 6912template<typename Derived> 6913QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 6914 unsigned NumElements, 6915 VectorType::VectorKind VecKind) { 6916 // FIXME: semantic checking! 6917 return SemaRef.Context.getVectorType(ElementType, NumElements, VecKind); 6918} 6919 6920template<typename Derived> 6921QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 6922 unsigned NumElements, 6923 SourceLocation AttributeLoc) { 6924 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 6925 NumElements, true); 6926 IntegerLiteral *VectorSize 6927 = IntegerLiteral::Create(SemaRef.Context, numElements, SemaRef.Context.IntTy, 6928 AttributeLoc); 6929 return SemaRef.BuildExtVectorType(ElementType, VectorSize, AttributeLoc); 6930} 6931 6932template<typename Derived> 6933QualType 6934TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 6935 Expr *SizeExpr, 6936 SourceLocation AttributeLoc) { 6937 return SemaRef.BuildExtVectorType(ElementType, SizeExpr, AttributeLoc); 6938} 6939 6940template<typename Derived> 6941QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 6942 QualType *ParamTypes, 6943 unsigned NumParamTypes, 6944 bool Variadic, 6945 unsigned Quals, 6946 const FunctionType::ExtInfo &Info) { 6947 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 6948 Quals, 6949 getDerived().getBaseLocation(), 6950 getDerived().getBaseEntity(), 6951 Info); 6952} 6953 6954template<typename Derived> 6955QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 6956 return SemaRef.Context.getFunctionNoProtoType(T); 6957} 6958 6959template<typename Derived> 6960QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 6961 assert(D && "no decl found"); 6962 if (D->isInvalidDecl()) return QualType(); 6963 6964 // FIXME: Doesn't account for ObjCInterfaceDecl! 6965 TypeDecl *Ty; 6966 if (isa<UsingDecl>(D)) { 6967 UsingDecl *Using = cast<UsingDecl>(D); 6968 assert(Using->isTypeName() && 6969 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 6970 6971 // A valid resolved using typename decl points to exactly one type decl. 6972 assert(++Using->shadow_begin() == Using->shadow_end()); 6973 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 6974 6975 } else { 6976 assert(isa<UnresolvedUsingTypenameDecl>(D) && 6977 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 6978 Ty = cast<UnresolvedUsingTypenameDecl>(D); 6979 } 6980 6981 return SemaRef.Context.getTypeDeclType(Ty); 6982} 6983 6984template<typename Derived> 6985QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, 6986 SourceLocation Loc) { 6987 return SemaRef.BuildTypeofExprType(E, Loc); 6988} 6989 6990template<typename Derived> 6991QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 6992 return SemaRef.Context.getTypeOfType(Underlying); 6993} 6994 6995template<typename Derived> 6996QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, 6997 SourceLocation Loc) { 6998 return SemaRef.BuildDecltypeType(E, Loc); 6999} 7000 7001template<typename Derived> 7002QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 7003 TemplateName Template, 7004 SourceLocation TemplateNameLoc, 7005 const TemplateArgumentListInfo &TemplateArgs) { 7006 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 7007} 7008 7009template<typename Derived> 7010NestedNameSpecifier * 7011TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7012 SourceRange Range, 7013 IdentifierInfo &II, 7014 QualType ObjectType, 7015 NamedDecl *FirstQualifierInScope) { 7016 CXXScopeSpec SS; 7017 // FIXME: The source location information is all wrong. 7018 SS.setRange(Range); 7019 SS.setScopeRep(Prefix); 7020 return static_cast<NestedNameSpecifier *>( 7021 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 7022 Range.getEnd(), II, 7023 ObjectType, 7024 FirstQualifierInScope, 7025 false, false)); 7026} 7027 7028template<typename Derived> 7029NestedNameSpecifier * 7030TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7031 SourceRange Range, 7032 NamespaceDecl *NS) { 7033 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 7034} 7035 7036template<typename Derived> 7037NestedNameSpecifier * 7038TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 7039 SourceRange Range, 7040 bool TemplateKW, 7041 QualType T) { 7042 if (T->isDependentType() || T->isRecordType() || 7043 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 7044 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 7045 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 7046 T.getTypePtr()); 7047 } 7048 7049 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 7050 return 0; 7051} 7052 7053template<typename Derived> 7054TemplateName 7055TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7056 bool TemplateKW, 7057 TemplateDecl *Template) { 7058 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 7059 Template); 7060} 7061 7062template<typename Derived> 7063TemplateName 7064TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7065 SourceRange QualifierRange, 7066 const IdentifierInfo &II, 7067 QualType ObjectType, 7068 NamedDecl *FirstQualifierInScope) { 7069 CXXScopeSpec SS; 7070 SS.setRange(QualifierRange); 7071 SS.setScopeRep(Qualifier); 7072 UnqualifiedId Name; 7073 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 7074 Sema::TemplateTy Template; 7075 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7076 /*FIXME:*/getDerived().getBaseLocation(), 7077 SS, 7078 Name, 7079 ParsedType::make(ObjectType), 7080 /*EnteringContext=*/false, 7081 Template); 7082 return Template.get(); 7083} 7084 7085template<typename Derived> 7086TemplateName 7087TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 7088 OverloadedOperatorKind Operator, 7089 QualType ObjectType) { 7090 CXXScopeSpec SS; 7091 SS.setRange(SourceRange(getDerived().getBaseLocation())); 7092 SS.setScopeRep(Qualifier); 7093 UnqualifiedId Name; 7094 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 7095 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 7096 Operator, SymbolLocations); 7097 Sema::TemplateTy Template; 7098 getSema().ActOnDependentTemplateName(/*Scope=*/0, 7099 /*FIXME:*/getDerived().getBaseLocation(), 7100 SS, 7101 Name, 7102 ParsedType::make(ObjectType), 7103 /*EnteringContext=*/false, 7104 Template); 7105 return Template.template getAsVal<TemplateName>(); 7106} 7107 7108template<typename Derived> 7109ExprResult 7110TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 7111 SourceLocation OpLoc, 7112 Expr *OrigCallee, 7113 Expr *First, 7114 Expr *Second) { 7115 Expr *Callee = OrigCallee->IgnoreParenCasts(); 7116 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus); 7117 7118 // Determine whether this should be a builtin operation. 7119 if (Op == OO_Subscript) { 7120 if (!First->getType()->isOverloadableType() && 7121 !Second->getType()->isOverloadableType()) 7122 return getSema().CreateBuiltinArraySubscriptExpr(First, 7123 Callee->getLocStart(), 7124 Second, OpLoc); 7125 } else if (Op == OO_Arrow) { 7126 // -> is never a builtin operation. 7127 return SemaRef.BuildOverloadedArrowExpr(0, First, OpLoc); 7128 } else if (Second == 0 || isPostIncDec) { 7129 if (!First->getType()->isOverloadableType()) { 7130 // The argument is not of overloadable type, so try to create a 7131 // built-in unary operation. 7132 UnaryOperatorKind Opc 7133 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7134 7135 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First); 7136 } 7137 } else { 7138 if (!First->getType()->isOverloadableType() && 7139 !Second->getType()->isOverloadableType()) { 7140 // Neither of the arguments is an overloadable type, so try to 7141 // create a built-in binary operation. 7142 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7143 ExprResult Result 7144 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second); 7145 if (Result.isInvalid()) 7146 return ExprError(); 7147 7148 return move(Result); 7149 } 7150 } 7151 7152 // Compute the transformed set of functions (and function templates) to be 7153 // used during overload resolution. 7154 UnresolvedSet<16> Functions; 7155 7156 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Callee)) { 7157 assert(ULE->requiresADL()); 7158 7159 // FIXME: Do we have to check 7160 // IsAcceptableNonMemberOperatorCandidate for each of these? 7161 Functions.append(ULE->decls_begin(), ULE->decls_end()); 7162 } else { 7163 Functions.addDecl(cast<DeclRefExpr>(Callee)->getDecl()); 7164 } 7165 7166 // Add any functions found via argument-dependent lookup. 7167 Expr *Args[2] = { First, Second }; 7168 unsigned NumArgs = 1 + (Second != 0); 7169 7170 // Create the overloaded operator invocation for unary operators. 7171 if (NumArgs == 1 || isPostIncDec) { 7172 UnaryOperatorKind Opc 7173 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 7174 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, First); 7175 } 7176 7177 if (Op == OO_Subscript) 7178 return SemaRef.CreateOverloadedArraySubscriptExpr(Callee->getLocStart(), 7179 OpLoc, 7180 First, 7181 Second); 7182 7183 // Create the overloaded operator invocation for binary operators. 7184 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(Op); 7185 ExprResult Result 7186 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 7187 if (Result.isInvalid()) 7188 return ExprError(); 7189 7190 return move(Result); 7191} 7192 7193template<typename Derived> 7194ExprResult 7195TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base, 7196 SourceLocation OperatorLoc, 7197 bool isArrow, 7198 NestedNameSpecifier *Qualifier, 7199 SourceRange QualifierRange, 7200 TypeSourceInfo *ScopeType, 7201 SourceLocation CCLoc, 7202 SourceLocation TildeLoc, 7203 PseudoDestructorTypeStorage Destroyed) { 7204 CXXScopeSpec SS; 7205 if (Qualifier) { 7206 SS.setRange(QualifierRange); 7207 SS.setScopeRep(Qualifier); 7208 } 7209 7210 QualType BaseType = Base->getType(); 7211 if (Base->isTypeDependent() || Destroyed.getIdentifier() || 7212 (!isArrow && !BaseType->getAs<RecordType>()) || 7213 (isArrow && BaseType->getAs<PointerType>() && 7214 !BaseType->getAs<PointerType>()->getPointeeType() 7215 ->template getAs<RecordType>())){ 7216 // This pseudo-destructor expression is still a pseudo-destructor. 7217 return SemaRef.BuildPseudoDestructorExpr(Base, OperatorLoc, 7218 isArrow? tok::arrow : tok::period, 7219 SS, ScopeType, CCLoc, TildeLoc, 7220 Destroyed, 7221 /*FIXME?*/true); 7222 } 7223 7224 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 7225 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName( 7226 SemaRef.Context.getCanonicalType(DestroyedType->getType()))); 7227 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation()); 7228 NameInfo.setNamedTypeInfo(DestroyedType); 7229 7230 // FIXME: the ScopeType should be tacked onto SS. 7231 7232 return getSema().BuildMemberReferenceExpr(Base, BaseType, 7233 OperatorLoc, isArrow, 7234 SS, /*FIXME: FirstQualifier*/ 0, 7235 NameInfo, 7236 /*TemplateArgs*/ 0); 7237} 7238 7239} // end namespace clang 7240 7241#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 7242