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