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