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