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