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