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