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