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