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