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