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