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