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