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