TreeTransform.h revision db93c4a8f839b2f46bfea66531aa014242f4da2c
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 /*FIXME:*/LBracLoc, 1708 RBracLoc, 1709 move(Args)); 1710 } 1711 1712 /// \brief Build a new Objective-C instance message. 1713 OwningExprResult RebuildObjCMessageExpr(ExprArg Receiver, 1714 Selector Sel, 1715 ObjCMethodDecl *Method, 1716 SourceLocation LBracLoc, 1717 MultiExprArg Args, 1718 SourceLocation RBracLoc) { 1719 // FIXME: Drops Method 1720 QualType ReceiverType = static_cast<Expr *>(Receiver.get())->getType(); 1721 return SemaRef.BuildInstanceMessage(move(Receiver), 1722 ReceiverType, 1723 /*SuperLoc=*/SourceLocation(), 1724 Sel, 1725 LBracLoc, 1726 /*FIXME:*/LBracLoc, 1727 RBracLoc, 1728 move(Args)); 1729 } 1730 1731 /// \brief Build a new Objective-C protocol expression. 1732 /// 1733 /// By default, performs semantic analysis to build the new expression. 1734 /// Subclasses may override this routine to provide different behavior. 1735 OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol, 1736 SourceLocation AtLoc, 1737 SourceLocation ProtoLoc, 1738 SourceLocation LParenLoc, 1739 SourceLocation RParenLoc) { 1740 return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression( 1741 Protocol->getIdentifier(), 1742 AtLoc, 1743 ProtoLoc, 1744 LParenLoc, 1745 RParenLoc)); 1746 } 1747 1748 /// \brief Build a new shuffle vector expression. 1749 /// 1750 /// By default, performs semantic analysis to build the new expression. 1751 /// Subclasses may override this routine to provide different behavior. 1752 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 1753 MultiExprArg SubExprs, 1754 SourceLocation RParenLoc) { 1755 // Find the declaration for __builtin_shufflevector 1756 const IdentifierInfo &Name 1757 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 1758 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 1759 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 1760 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 1761 1762 // Build a reference to the __builtin_shufflevector builtin 1763 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 1764 Expr *Callee 1765 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 1766 BuiltinLoc); 1767 SemaRef.UsualUnaryConversions(Callee); 1768 1769 // Build the CallExpr 1770 unsigned NumSubExprs = SubExprs.size(); 1771 Expr **Subs = (Expr **)SubExprs.release(); 1772 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, 1773 Subs, NumSubExprs, 1774 Builtin->getResultType(), 1775 RParenLoc); 1776 OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); 1777 1778 // Type-check the __builtin_shufflevector expression. 1779 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); 1780 if (Result.isInvalid()) 1781 return SemaRef.ExprError(); 1782 1783 OwnedCall.release(); 1784 return move(Result); 1785 } 1786}; 1787 1788template<typename Derived> 1789Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 1790 if (!S) 1791 return SemaRef.Owned(S); 1792 1793 switch (S->getStmtClass()) { 1794 case Stmt::NoStmtClass: break; 1795 1796 // Transform individual statement nodes 1797#define STMT(Node, Parent) \ 1798 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 1799#define EXPR(Node, Parent) 1800#include "clang/AST/StmtNodes.def" 1801 1802 // Transform expressions by calling TransformExpr. 1803#define STMT(Node, Parent) 1804#define ABSTRACT_EXPR(Node, Parent) 1805#define EXPR(Node, Parent) case Stmt::Node##Class: 1806#include "clang/AST/StmtNodes.def" 1807 { 1808 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 1809 if (E.isInvalid()) 1810 return getSema().StmtError(); 1811 1812 return getSema().ActOnExprStmt(getSema().MakeFullExpr(E)); 1813 } 1814 } 1815 1816 return SemaRef.Owned(S->Retain()); 1817} 1818 1819 1820template<typename Derived> 1821Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E) { 1822 if (!E) 1823 return SemaRef.Owned(E); 1824 1825 switch (E->getStmtClass()) { 1826 case Stmt::NoStmtClass: break; 1827#define STMT(Node, Parent) case Stmt::Node##Class: break; 1828#define ABSTRACT_EXPR(Node, Parent) 1829#define EXPR(Node, Parent) \ 1830 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E)); 1831#include "clang/AST/StmtNodes.def" 1832 } 1833 1834 return SemaRef.Owned(E->Retain()); 1835} 1836 1837template<typename Derived> 1838NestedNameSpecifier * 1839TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 1840 SourceRange Range, 1841 QualType ObjectType, 1842 NamedDecl *FirstQualifierInScope) { 1843 if (!NNS) 1844 return 0; 1845 1846 // Transform the prefix of this nested name specifier. 1847 NestedNameSpecifier *Prefix = NNS->getPrefix(); 1848 if (Prefix) { 1849 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, 1850 ObjectType, 1851 FirstQualifierInScope); 1852 if (!Prefix) 1853 return 0; 1854 1855 // Clear out the object type and the first qualifier in scope; they only 1856 // apply to the first element in the nested-name-specifier. 1857 ObjectType = QualType(); 1858 FirstQualifierInScope = 0; 1859 } 1860 1861 switch (NNS->getKind()) { 1862 case NestedNameSpecifier::Identifier: 1863 assert((Prefix || !ObjectType.isNull()) && 1864 "Identifier nested-name-specifier with no prefix or object type"); 1865 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && 1866 ObjectType.isNull()) 1867 return NNS; 1868 1869 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1870 *NNS->getAsIdentifier(), 1871 ObjectType, 1872 FirstQualifierInScope); 1873 1874 case NestedNameSpecifier::Namespace: { 1875 NamespaceDecl *NS 1876 = cast_or_null<NamespaceDecl>( 1877 getDerived().TransformDecl(Range.getBegin(), 1878 NNS->getAsNamespace())); 1879 if (!getDerived().AlwaysRebuild() && 1880 Prefix == NNS->getPrefix() && 1881 NS == NNS->getAsNamespace()) 1882 return NNS; 1883 1884 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 1885 } 1886 1887 case NestedNameSpecifier::Global: 1888 // There is no meaningful transformation that one could perform on the 1889 // global scope. 1890 return NNS; 1891 1892 case NestedNameSpecifier::TypeSpecWithTemplate: 1893 case NestedNameSpecifier::TypeSpec: { 1894 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName()); 1895 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0), 1896 ObjectType); 1897 if (T.isNull()) 1898 return 0; 1899 1900 if (!getDerived().AlwaysRebuild() && 1901 Prefix == NNS->getPrefix() && 1902 T == QualType(NNS->getAsType(), 0)) 1903 return NNS; 1904 1905 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1906 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1907 T); 1908 } 1909 } 1910 1911 // Required to silence a GCC warning 1912 return 0; 1913} 1914 1915template<typename Derived> 1916DeclarationName 1917TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, 1918 SourceLocation Loc, 1919 QualType ObjectType) { 1920 if (!Name) 1921 return Name; 1922 1923 switch (Name.getNameKind()) { 1924 case DeclarationName::Identifier: 1925 case DeclarationName::ObjCZeroArgSelector: 1926 case DeclarationName::ObjCOneArgSelector: 1927 case DeclarationName::ObjCMultiArgSelector: 1928 case DeclarationName::CXXOperatorName: 1929 case DeclarationName::CXXLiteralOperatorName: 1930 case DeclarationName::CXXUsingDirective: 1931 return Name; 1932 1933 case DeclarationName::CXXConstructorName: 1934 case DeclarationName::CXXDestructorName: 1935 case DeclarationName::CXXConversionFunctionName: { 1936 TemporaryBase Rebase(*this, Loc, Name); 1937 QualType T = getDerived().TransformType(Name.getCXXNameType(), 1938 ObjectType); 1939 if (T.isNull()) 1940 return DeclarationName(); 1941 1942 return SemaRef.Context.DeclarationNames.getCXXSpecialName( 1943 Name.getNameKind(), 1944 SemaRef.Context.getCanonicalType(T)); 1945 } 1946 } 1947 1948 return DeclarationName(); 1949} 1950 1951template<typename Derived> 1952TemplateName 1953TreeTransform<Derived>::TransformTemplateName(TemplateName Name, 1954 QualType ObjectType) { 1955 SourceLocation Loc = getDerived().getBaseLocation(); 1956 1957 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 1958 NestedNameSpecifier *NNS 1959 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 1960 /*FIXME:*/SourceRange(getDerived().getBaseLocation()), 1961 ObjectType); 1962 if (!NNS) 1963 return TemplateName(); 1964 1965 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 1966 TemplateDecl *TransTemplate 1967 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template)); 1968 if (!TransTemplate) 1969 return TemplateName(); 1970 1971 if (!getDerived().AlwaysRebuild() && 1972 NNS == QTN->getQualifier() && 1973 TransTemplate == Template) 1974 return Name; 1975 1976 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1977 TransTemplate); 1978 } 1979 1980 // These should be getting filtered out before they make it into the AST. 1981 assert(false && "overloaded template name survived to here"); 1982 } 1983 1984 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 1985 NestedNameSpecifier *NNS 1986 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), 1987 /*FIXME:*/SourceRange(getDerived().getBaseLocation()), 1988 ObjectType); 1989 if (!NNS && DTN->getQualifier()) 1990 return TemplateName(); 1991 1992 if (!getDerived().AlwaysRebuild() && 1993 NNS == DTN->getQualifier() && 1994 ObjectType.isNull()) 1995 return Name; 1996 1997 if (DTN->isIdentifier()) 1998 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(), 1999 ObjectType); 2000 2001 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(), 2002 ObjectType); 2003 } 2004 2005 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 2006 TemplateDecl *TransTemplate 2007 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Loc, Template)); 2008 if (!TransTemplate) 2009 return TemplateName(); 2010 2011 if (!getDerived().AlwaysRebuild() && 2012 TransTemplate == Template) 2013 return Name; 2014 2015 return TemplateName(TransTemplate); 2016 } 2017 2018 // These should be getting filtered out before they reach the AST. 2019 assert(false && "overloaded function decl survived to here"); 2020 return TemplateName(); 2021} 2022 2023template<typename Derived> 2024void TreeTransform<Derived>::InventTemplateArgumentLoc( 2025 const TemplateArgument &Arg, 2026 TemplateArgumentLoc &Output) { 2027 SourceLocation Loc = getDerived().getBaseLocation(); 2028 switch (Arg.getKind()) { 2029 case TemplateArgument::Null: 2030 llvm_unreachable("null template argument in TreeTransform"); 2031 break; 2032 2033 case TemplateArgument::Type: 2034 Output = TemplateArgumentLoc(Arg, 2035 SemaRef.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); 2036 2037 break; 2038 2039 case TemplateArgument::Template: 2040 Output = TemplateArgumentLoc(Arg, SourceRange(), Loc); 2041 break; 2042 2043 case TemplateArgument::Expression: 2044 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 2045 break; 2046 2047 case TemplateArgument::Declaration: 2048 case TemplateArgument::Integral: 2049 case TemplateArgument::Pack: 2050 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 2051 break; 2052 } 2053} 2054 2055template<typename Derived> 2056bool TreeTransform<Derived>::TransformTemplateArgument( 2057 const TemplateArgumentLoc &Input, 2058 TemplateArgumentLoc &Output) { 2059 const TemplateArgument &Arg = Input.getArgument(); 2060 switch (Arg.getKind()) { 2061 case TemplateArgument::Null: 2062 case TemplateArgument::Integral: 2063 Output = Input; 2064 return false; 2065 2066 case TemplateArgument::Type: { 2067 TypeSourceInfo *DI = Input.getTypeSourceInfo(); 2068 if (DI == NULL) 2069 DI = InventTypeSourceInfo(Input.getArgument().getAsType()); 2070 2071 DI = getDerived().TransformType(DI); 2072 if (!DI) return true; 2073 2074 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 2075 return false; 2076 } 2077 2078 case TemplateArgument::Declaration: { 2079 // FIXME: we should never have to transform one of these. 2080 DeclarationName Name; 2081 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) 2082 Name = ND->getDeclName(); 2083 TemporaryBase Rebase(*this, Input.getLocation(), Name); 2084 Decl *D = getDerived().TransformDecl(Input.getLocation(), Arg.getAsDecl()); 2085 if (!D) return true; 2086 2087 Expr *SourceExpr = Input.getSourceDeclExpression(); 2088 if (SourceExpr) { 2089 EnterExpressionEvaluationContext Unevaluated(getSema(), 2090 Action::Unevaluated); 2091 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr); 2092 if (E.isInvalid()) 2093 SourceExpr = NULL; 2094 else { 2095 SourceExpr = E.takeAs<Expr>(); 2096 SourceExpr->Retain(); 2097 } 2098 } 2099 2100 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr); 2101 return false; 2102 } 2103 2104 case TemplateArgument::Template: { 2105 TemporaryBase Rebase(*this, Input.getLocation(), DeclarationName()); 2106 TemplateName Template 2107 = getDerived().TransformTemplateName(Arg.getAsTemplate()); 2108 if (Template.isNull()) 2109 return true; 2110 2111 Output = TemplateArgumentLoc(TemplateArgument(Template), 2112 Input.getTemplateQualifierRange(), 2113 Input.getTemplateNameLoc()); 2114 return false; 2115 } 2116 2117 case TemplateArgument::Expression: { 2118 // Template argument expressions are not potentially evaluated. 2119 EnterExpressionEvaluationContext Unevaluated(getSema(), 2120 Action::Unevaluated); 2121 2122 Expr *InputExpr = Input.getSourceExpression(); 2123 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 2124 2125 Sema::OwningExprResult E 2126 = getDerived().TransformExpr(InputExpr); 2127 if (E.isInvalid()) return true; 2128 2129 Expr *ETaken = E.takeAs<Expr>(); 2130 ETaken->Retain(); 2131 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken); 2132 return false; 2133 } 2134 2135 case TemplateArgument::Pack: { 2136 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 2137 TransformedArgs.reserve(Arg.pack_size()); 2138 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 2139 AEnd = Arg.pack_end(); 2140 A != AEnd; ++A) { 2141 2142 // FIXME: preserve source information here when we start 2143 // caring about parameter packs. 2144 2145 TemplateArgumentLoc InputArg; 2146 TemplateArgumentLoc OutputArg; 2147 getDerived().InventTemplateArgumentLoc(*A, InputArg); 2148 if (getDerived().TransformTemplateArgument(InputArg, OutputArg)) 2149 return true; 2150 2151 TransformedArgs.push_back(OutputArg.getArgument()); 2152 } 2153 TemplateArgument Result; 2154 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 2155 true); 2156 Output = TemplateArgumentLoc(Result, Input.getLocInfo()); 2157 return false; 2158 } 2159 } 2160 2161 // Work around bogus GCC warning 2162 return true; 2163} 2164 2165//===----------------------------------------------------------------------===// 2166// Type transformation 2167//===----------------------------------------------------------------------===// 2168 2169template<typename Derived> 2170QualType TreeTransform<Derived>::TransformType(QualType T, 2171 QualType ObjectType) { 2172 if (getDerived().AlreadyTransformed(T)) 2173 return T; 2174 2175 // Temporary workaround. All of these transformations should 2176 // eventually turn into transformations on TypeLocs. 2177 TypeSourceInfo *DI = getSema().Context.CreateTypeSourceInfo(T); 2178 DI->getTypeLoc().initialize(getDerived().getBaseLocation()); 2179 2180 TypeSourceInfo *NewDI = getDerived().TransformType(DI, ObjectType); 2181 2182 if (!NewDI) 2183 return QualType(); 2184 2185 return NewDI->getType(); 2186} 2187 2188template<typename Derived> 2189TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *DI, 2190 QualType ObjectType) { 2191 if (getDerived().AlreadyTransformed(DI->getType())) 2192 return DI; 2193 2194 TypeLocBuilder TLB; 2195 2196 TypeLoc TL = DI->getTypeLoc(); 2197 TLB.reserve(TL.getFullDataSize()); 2198 2199 QualType Result = getDerived().TransformType(TLB, TL, ObjectType); 2200 if (Result.isNull()) 2201 return 0; 2202 2203 return TLB.getTypeSourceInfo(SemaRef.Context, Result); 2204} 2205 2206template<typename Derived> 2207QualType 2208TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T, 2209 QualType ObjectType) { 2210 switch (T.getTypeLocClass()) { 2211#define ABSTRACT_TYPELOC(CLASS, PARENT) 2212#define TYPELOC(CLASS, PARENT) \ 2213 case TypeLoc::CLASS: \ 2214 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T), \ 2215 ObjectType); 2216#include "clang/AST/TypeLocNodes.def" 2217 } 2218 2219 llvm_unreachable("unhandled type loc!"); 2220 return QualType(); 2221} 2222 2223/// FIXME: By default, this routine adds type qualifiers only to types 2224/// that can have qualifiers, and silently suppresses those qualifiers 2225/// that are not permitted (e.g., qualifiers on reference or function 2226/// types). This is the right thing for template instantiation, but 2227/// probably not for other clients. 2228template<typename Derived> 2229QualType 2230TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 2231 QualifiedTypeLoc T, 2232 QualType ObjectType) { 2233 Qualifiers Quals = T.getType().getLocalQualifiers(); 2234 2235 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc(), 2236 ObjectType); 2237 if (Result.isNull()) 2238 return QualType(); 2239 2240 // Silently suppress qualifiers if the result type can't be qualified. 2241 // FIXME: this is the right thing for template instantiation, but 2242 // probably not for other clients. 2243 if (Result->isFunctionType() || Result->isReferenceType()) 2244 return Result; 2245 2246 Result = SemaRef.Context.getQualifiedType(Result, Quals); 2247 2248 TLB.push<QualifiedTypeLoc>(Result); 2249 2250 // No location information to preserve. 2251 2252 return Result; 2253} 2254 2255template <class TyLoc> static inline 2256QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 2257 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 2258 NewT.setNameLoc(T.getNameLoc()); 2259 return T.getType(); 2260} 2261 2262template<typename Derived> 2263QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 2264 BuiltinTypeLoc T, 2265 QualType ObjectType) { 2266 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T.getType()); 2267 NewT.setBuiltinLoc(T.getBuiltinLoc()); 2268 if (T.needsExtraLocalData()) 2269 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs(); 2270 return T.getType(); 2271} 2272 2273template<typename Derived> 2274QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 2275 ComplexTypeLoc T, 2276 QualType ObjectType) { 2277 // FIXME: recurse? 2278 return TransformTypeSpecType(TLB, T); 2279} 2280 2281template<typename Derived> 2282QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 2283 PointerTypeLoc TL, 2284 QualType ObjectType) { 2285 QualType PointeeType 2286 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2287 if (PointeeType.isNull()) 2288 return QualType(); 2289 2290 QualType Result = TL.getType(); 2291 if (PointeeType->isObjCInterfaceType()) { 2292 // A dependent pointer type 'T *' has is being transformed such 2293 // that an Objective-C class type is being replaced for 'T'. The 2294 // resulting pointer type is an ObjCObjectPointerType, not a 2295 // PointerType. 2296 const ObjCInterfaceType *IFace = PointeeType->getAs<ObjCInterfaceType>(); 2297 Result = SemaRef.Context.getObjCObjectPointerType(PointeeType, 2298 const_cast<ObjCProtocolDecl **>( 2299 IFace->qual_begin()), 2300 IFace->getNumProtocols()); 2301 2302 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(Result); 2303 NewT.setStarLoc(TL.getSigilLoc()); 2304 NewT.setHasProtocolsAsWritten(false); 2305 NewT.setLAngleLoc(SourceLocation()); 2306 NewT.setRAngleLoc(SourceLocation()); 2307 NewT.setHasBaseTypeAsWritten(true); 2308 return Result; 2309 } 2310 2311 if (getDerived().AlwaysRebuild() || 2312 PointeeType != TL.getPointeeLoc().getType()) { 2313 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc()); 2314 if (Result.isNull()) 2315 return QualType(); 2316 } 2317 2318 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(Result); 2319 NewT.setSigilLoc(TL.getSigilLoc()); 2320 return Result; 2321} 2322 2323template<typename Derived> 2324QualType 2325TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 2326 BlockPointerTypeLoc TL, 2327 QualType ObjectType) { 2328 QualType PointeeType 2329 = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2330 if (PointeeType.isNull()) 2331 return QualType(); 2332 2333 QualType Result = TL.getType(); 2334 if (getDerived().AlwaysRebuild() || 2335 PointeeType != TL.getPointeeLoc().getType()) { 2336 Result = getDerived().RebuildBlockPointerType(PointeeType, 2337 TL.getSigilLoc()); 2338 if (Result.isNull()) 2339 return QualType(); 2340 } 2341 2342 BlockPointerLoc NewT = TLB.push<BlockPointerLoc>(Result); 2343 NewT.setSigilLoc(TL.getSigilLoc()); 2344 return Result; 2345} 2346 2347/// Transforms a reference type. Note that somewhat paradoxically we 2348/// don't care whether the type itself is an l-value type or an r-value 2349/// type; we only care if the type was *written* as an l-value type 2350/// or an r-value type. 2351template<typename Derived> 2352QualType 2353TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 2354 ReferenceTypeLoc TL, 2355 QualType ObjectType) { 2356 const ReferenceType *T = TL.getTypePtr(); 2357 2358 // Note that this works with the pointee-as-written. 2359 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2360 if (PointeeType.isNull()) 2361 return QualType(); 2362 2363 QualType Result = TL.getType(); 2364 if (getDerived().AlwaysRebuild() || 2365 PointeeType != T->getPointeeTypeAsWritten()) { 2366 Result = getDerived().RebuildReferenceType(PointeeType, 2367 T->isSpelledAsLValue(), 2368 TL.getSigilLoc()); 2369 if (Result.isNull()) 2370 return QualType(); 2371 } 2372 2373 // r-value references can be rebuilt as l-value references. 2374 ReferenceTypeLoc NewTL; 2375 if (isa<LValueReferenceType>(Result)) 2376 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 2377 else 2378 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 2379 NewTL.setSigilLoc(TL.getSigilLoc()); 2380 2381 return Result; 2382} 2383 2384template<typename Derived> 2385QualType 2386TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 2387 LValueReferenceTypeLoc TL, 2388 QualType ObjectType) { 2389 return TransformReferenceType(TLB, TL, ObjectType); 2390} 2391 2392template<typename Derived> 2393QualType 2394TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 2395 RValueReferenceTypeLoc TL, 2396 QualType ObjectType) { 2397 return TransformReferenceType(TLB, TL, ObjectType); 2398} 2399 2400template<typename Derived> 2401QualType 2402TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 2403 MemberPointerTypeLoc TL, 2404 QualType ObjectType) { 2405 MemberPointerType *T = TL.getTypePtr(); 2406 2407 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2408 if (PointeeType.isNull()) 2409 return QualType(); 2410 2411 // TODO: preserve source information for this. 2412 QualType ClassType 2413 = getDerived().TransformType(QualType(T->getClass(), 0)); 2414 if (ClassType.isNull()) 2415 return QualType(); 2416 2417 QualType Result = TL.getType(); 2418 if (getDerived().AlwaysRebuild() || 2419 PointeeType != T->getPointeeType() || 2420 ClassType != QualType(T->getClass(), 0)) { 2421 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType, 2422 TL.getStarLoc()); 2423 if (Result.isNull()) 2424 return QualType(); 2425 } 2426 2427 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 2428 NewTL.setSigilLoc(TL.getSigilLoc()); 2429 2430 return Result; 2431} 2432 2433template<typename Derived> 2434QualType 2435TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 2436 ConstantArrayTypeLoc TL, 2437 QualType ObjectType) { 2438 ConstantArrayType *T = TL.getTypePtr(); 2439 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2440 if (ElementType.isNull()) 2441 return QualType(); 2442 2443 QualType Result = TL.getType(); 2444 if (getDerived().AlwaysRebuild() || 2445 ElementType != T->getElementType()) { 2446 Result = getDerived().RebuildConstantArrayType(ElementType, 2447 T->getSizeModifier(), 2448 T->getSize(), 2449 T->getIndexTypeCVRQualifiers(), 2450 TL.getBracketsRange()); 2451 if (Result.isNull()) 2452 return QualType(); 2453 } 2454 2455 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 2456 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2457 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2458 2459 Expr *Size = TL.getSizeExpr(); 2460 if (Size) { 2461 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2462 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 2463 } 2464 NewTL.setSizeExpr(Size); 2465 2466 return Result; 2467} 2468 2469template<typename Derived> 2470QualType TreeTransform<Derived>::TransformIncompleteArrayType( 2471 TypeLocBuilder &TLB, 2472 IncompleteArrayTypeLoc TL, 2473 QualType ObjectType) { 2474 IncompleteArrayType *T = TL.getTypePtr(); 2475 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2476 if (ElementType.isNull()) 2477 return QualType(); 2478 2479 QualType Result = TL.getType(); 2480 if (getDerived().AlwaysRebuild() || 2481 ElementType != T->getElementType()) { 2482 Result = getDerived().RebuildIncompleteArrayType(ElementType, 2483 T->getSizeModifier(), 2484 T->getIndexTypeCVRQualifiers(), 2485 TL.getBracketsRange()); 2486 if (Result.isNull()) 2487 return QualType(); 2488 } 2489 2490 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 2491 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2492 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2493 NewTL.setSizeExpr(0); 2494 2495 return Result; 2496} 2497 2498template<typename Derived> 2499QualType 2500TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 2501 VariableArrayTypeLoc TL, 2502 QualType ObjectType) { 2503 VariableArrayType *T = TL.getTypePtr(); 2504 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2505 if (ElementType.isNull()) 2506 return QualType(); 2507 2508 // Array bounds are not potentially evaluated contexts 2509 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2510 2511 Sema::OwningExprResult SizeResult 2512 = getDerived().TransformExpr(T->getSizeExpr()); 2513 if (SizeResult.isInvalid()) 2514 return QualType(); 2515 2516 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2517 2518 QualType Result = TL.getType(); 2519 if (getDerived().AlwaysRebuild() || 2520 ElementType != T->getElementType() || 2521 Size != T->getSizeExpr()) { 2522 Result = getDerived().RebuildVariableArrayType(ElementType, 2523 T->getSizeModifier(), 2524 move(SizeResult), 2525 T->getIndexTypeCVRQualifiers(), 2526 TL.getBracketsRange()); 2527 if (Result.isNull()) 2528 return QualType(); 2529 } 2530 else SizeResult.take(); 2531 2532 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 2533 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2534 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2535 NewTL.setSizeExpr(Size); 2536 2537 return Result; 2538} 2539 2540template<typename Derived> 2541QualType 2542TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 2543 DependentSizedArrayTypeLoc TL, 2544 QualType ObjectType) { 2545 DependentSizedArrayType *T = TL.getTypePtr(); 2546 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2547 if (ElementType.isNull()) 2548 return QualType(); 2549 2550 // Array bounds are not potentially evaluated contexts 2551 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2552 2553 Sema::OwningExprResult SizeResult 2554 = getDerived().TransformExpr(T->getSizeExpr()); 2555 if (SizeResult.isInvalid()) 2556 return QualType(); 2557 2558 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2559 2560 QualType Result = TL.getType(); 2561 if (getDerived().AlwaysRebuild() || 2562 ElementType != T->getElementType() || 2563 Size != T->getSizeExpr()) { 2564 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 2565 T->getSizeModifier(), 2566 move(SizeResult), 2567 T->getIndexTypeCVRQualifiers(), 2568 TL.getBracketsRange()); 2569 if (Result.isNull()) 2570 return QualType(); 2571 } 2572 else SizeResult.take(); 2573 2574 // We might have any sort of array type now, but fortunately they 2575 // all have the same location layout. 2576 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 2577 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2578 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2579 NewTL.setSizeExpr(Size); 2580 2581 return Result; 2582} 2583 2584template<typename Derived> 2585QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 2586 TypeLocBuilder &TLB, 2587 DependentSizedExtVectorTypeLoc TL, 2588 QualType ObjectType) { 2589 DependentSizedExtVectorType *T = TL.getTypePtr(); 2590 2591 // FIXME: ext vector locs should be nested 2592 QualType ElementType = getDerived().TransformType(T->getElementType()); 2593 if (ElementType.isNull()) 2594 return QualType(); 2595 2596 // Vector sizes are not potentially evaluated contexts 2597 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2598 2599 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 2600 if (Size.isInvalid()) 2601 return QualType(); 2602 2603 QualType Result = TL.getType(); 2604 if (getDerived().AlwaysRebuild() || 2605 ElementType != T->getElementType() || 2606 Size.get() != T->getSizeExpr()) { 2607 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 2608 move(Size), 2609 T->getAttributeLoc()); 2610 if (Result.isNull()) 2611 return QualType(); 2612 } 2613 else Size.take(); 2614 2615 // Result might be dependent or not. 2616 if (isa<DependentSizedExtVectorType>(Result)) { 2617 DependentSizedExtVectorTypeLoc NewTL 2618 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 2619 NewTL.setNameLoc(TL.getNameLoc()); 2620 } else { 2621 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2622 NewTL.setNameLoc(TL.getNameLoc()); 2623 } 2624 2625 return Result; 2626} 2627 2628template<typename Derived> 2629QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 2630 VectorTypeLoc TL, 2631 QualType ObjectType) { 2632 VectorType *T = TL.getTypePtr(); 2633 QualType ElementType = getDerived().TransformType(T->getElementType()); 2634 if (ElementType.isNull()) 2635 return QualType(); 2636 2637 QualType Result = TL.getType(); 2638 if (getDerived().AlwaysRebuild() || 2639 ElementType != T->getElementType()) { 2640 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(), 2641 T->isAltiVec(), T->isPixel()); 2642 if (Result.isNull()) 2643 return QualType(); 2644 } 2645 2646 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 2647 NewTL.setNameLoc(TL.getNameLoc()); 2648 2649 return Result; 2650} 2651 2652template<typename Derived> 2653QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 2654 ExtVectorTypeLoc TL, 2655 QualType ObjectType) { 2656 VectorType *T = TL.getTypePtr(); 2657 QualType ElementType = getDerived().TransformType(T->getElementType()); 2658 if (ElementType.isNull()) 2659 return QualType(); 2660 2661 QualType Result = TL.getType(); 2662 if (getDerived().AlwaysRebuild() || 2663 ElementType != T->getElementType()) { 2664 Result = getDerived().RebuildExtVectorType(ElementType, 2665 T->getNumElements(), 2666 /*FIXME*/ SourceLocation()); 2667 if (Result.isNull()) 2668 return QualType(); 2669 } 2670 2671 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2672 NewTL.setNameLoc(TL.getNameLoc()); 2673 2674 return Result; 2675} 2676 2677template<typename Derived> 2678ParmVarDecl * 2679TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm) { 2680 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); 2681 TypeSourceInfo *NewDI = getDerived().TransformType(OldDI); 2682 if (!NewDI) 2683 return 0; 2684 2685 if (NewDI == OldDI) 2686 return OldParm; 2687 else 2688 return ParmVarDecl::Create(SemaRef.Context, 2689 OldParm->getDeclContext(), 2690 OldParm->getLocation(), 2691 OldParm->getIdentifier(), 2692 NewDI->getType(), 2693 NewDI, 2694 OldParm->getStorageClass(), 2695 OldParm->getStorageClassAsWritten(), 2696 /* DefArg */ NULL); 2697} 2698 2699template<typename Derived> 2700bool TreeTransform<Derived>:: 2701 TransformFunctionTypeParams(FunctionProtoTypeLoc TL, 2702 llvm::SmallVectorImpl<QualType> &PTypes, 2703 llvm::SmallVectorImpl<ParmVarDecl*> &PVars) { 2704 FunctionProtoType *T = TL.getTypePtr(); 2705 2706 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2707 ParmVarDecl *OldParm = TL.getArg(i); 2708 2709 QualType NewType; 2710 ParmVarDecl *NewParm; 2711 2712 if (OldParm) { 2713 NewParm = getDerived().TransformFunctionTypeParam(OldParm); 2714 if (!NewParm) 2715 return true; 2716 NewType = NewParm->getType(); 2717 2718 // Deal with the possibility that we don't have a parameter 2719 // declaration for this parameter. 2720 } else { 2721 NewParm = 0; 2722 2723 QualType OldType = T->getArgType(i); 2724 NewType = getDerived().TransformType(OldType); 2725 if (NewType.isNull()) 2726 return true; 2727 } 2728 2729 PTypes.push_back(NewType); 2730 PVars.push_back(NewParm); 2731 } 2732 2733 return false; 2734} 2735 2736template<typename Derived> 2737QualType 2738TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 2739 FunctionProtoTypeLoc TL, 2740 QualType ObjectType) { 2741 FunctionProtoType *T = TL.getTypePtr(); 2742 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2743 if (ResultType.isNull()) 2744 return QualType(); 2745 2746 // Transform the parameters. 2747 llvm::SmallVector<QualType, 4> ParamTypes; 2748 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 2749 if (getDerived().TransformFunctionTypeParams(TL, ParamTypes, ParamDecls)) 2750 return QualType(); 2751 2752 QualType Result = TL.getType(); 2753 if (getDerived().AlwaysRebuild() || 2754 ResultType != T->getResultType() || 2755 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 2756 Result = getDerived().RebuildFunctionProtoType(ResultType, 2757 ParamTypes.data(), 2758 ParamTypes.size(), 2759 T->isVariadic(), 2760 T->getTypeQuals()); 2761 if (Result.isNull()) 2762 return QualType(); 2763 } 2764 2765 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 2766 NewTL.setLParenLoc(TL.getLParenLoc()); 2767 NewTL.setRParenLoc(TL.getRParenLoc()); 2768 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 2769 NewTL.setArg(i, ParamDecls[i]); 2770 2771 return Result; 2772} 2773 2774template<typename Derived> 2775QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 2776 TypeLocBuilder &TLB, 2777 FunctionNoProtoTypeLoc TL, 2778 QualType ObjectType) { 2779 FunctionNoProtoType *T = TL.getTypePtr(); 2780 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2781 if (ResultType.isNull()) 2782 return QualType(); 2783 2784 QualType Result = TL.getType(); 2785 if (getDerived().AlwaysRebuild() || 2786 ResultType != T->getResultType()) 2787 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 2788 2789 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 2790 NewTL.setLParenLoc(TL.getLParenLoc()); 2791 NewTL.setRParenLoc(TL.getRParenLoc()); 2792 2793 return Result; 2794} 2795 2796template<typename Derived> QualType 2797TreeTransform<Derived>::TransformUnresolvedUsingType(TypeLocBuilder &TLB, 2798 UnresolvedUsingTypeLoc TL, 2799 QualType ObjectType) { 2800 UnresolvedUsingType *T = TL.getTypePtr(); 2801 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()); 2802 if (!D) 2803 return QualType(); 2804 2805 QualType Result = TL.getType(); 2806 if (getDerived().AlwaysRebuild() || D != T->getDecl()) { 2807 Result = getDerived().RebuildUnresolvedUsingType(D); 2808 if (Result.isNull()) 2809 return QualType(); 2810 } 2811 2812 // We might get an arbitrary type spec type back. We should at 2813 // least always get a type spec type, though. 2814 TypeSpecTypeLoc NewTL = TLB.pushTypeSpec(Result); 2815 NewTL.setNameLoc(TL.getNameLoc()); 2816 2817 return Result; 2818} 2819 2820template<typename Derived> 2821QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 2822 TypedefTypeLoc TL, 2823 QualType ObjectType) { 2824 TypedefType *T = TL.getTypePtr(); 2825 TypedefDecl *Typedef 2826 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(TL.getNameLoc(), 2827 T->getDecl())); 2828 if (!Typedef) 2829 return QualType(); 2830 2831 QualType Result = TL.getType(); 2832 if (getDerived().AlwaysRebuild() || 2833 Typedef != T->getDecl()) { 2834 Result = getDerived().RebuildTypedefType(Typedef); 2835 if (Result.isNull()) 2836 return QualType(); 2837 } 2838 2839 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 2840 NewTL.setNameLoc(TL.getNameLoc()); 2841 2842 return Result; 2843} 2844 2845template<typename Derived> 2846QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 2847 TypeOfExprTypeLoc TL, 2848 QualType ObjectType) { 2849 // typeof expressions are not potentially evaluated contexts 2850 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2851 2852 Sema::OwningExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr()); 2853 if (E.isInvalid()) 2854 return QualType(); 2855 2856 QualType Result = TL.getType(); 2857 if (getDerived().AlwaysRebuild() || 2858 E.get() != TL.getUnderlyingExpr()) { 2859 Result = getDerived().RebuildTypeOfExprType(move(E)); 2860 if (Result.isNull()) 2861 return QualType(); 2862 } 2863 else E.take(); 2864 2865 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 2866 NewTL.setTypeofLoc(TL.getTypeofLoc()); 2867 NewTL.setLParenLoc(TL.getLParenLoc()); 2868 NewTL.setRParenLoc(TL.getRParenLoc()); 2869 2870 return Result; 2871} 2872 2873template<typename Derived> 2874QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 2875 TypeOfTypeLoc TL, 2876 QualType ObjectType) { 2877 TypeSourceInfo* Old_Under_TI = TL.getUnderlyingTInfo(); 2878 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI); 2879 if (!New_Under_TI) 2880 return QualType(); 2881 2882 QualType Result = TL.getType(); 2883 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) { 2884 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType()); 2885 if (Result.isNull()) 2886 return QualType(); 2887 } 2888 2889 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 2890 NewTL.setTypeofLoc(TL.getTypeofLoc()); 2891 NewTL.setLParenLoc(TL.getLParenLoc()); 2892 NewTL.setRParenLoc(TL.getRParenLoc()); 2893 NewTL.setUnderlyingTInfo(New_Under_TI); 2894 2895 return Result; 2896} 2897 2898template<typename Derived> 2899QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 2900 DecltypeTypeLoc TL, 2901 QualType ObjectType) { 2902 DecltypeType *T = TL.getTypePtr(); 2903 2904 // decltype expressions are not potentially evaluated contexts 2905 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2906 2907 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2908 if (E.isInvalid()) 2909 return QualType(); 2910 2911 QualType Result = TL.getType(); 2912 if (getDerived().AlwaysRebuild() || 2913 E.get() != T->getUnderlyingExpr()) { 2914 Result = getDerived().RebuildDecltypeType(move(E)); 2915 if (Result.isNull()) 2916 return QualType(); 2917 } 2918 else E.take(); 2919 2920 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 2921 NewTL.setNameLoc(TL.getNameLoc()); 2922 2923 return Result; 2924} 2925 2926template<typename Derived> 2927QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 2928 RecordTypeLoc TL, 2929 QualType ObjectType) { 2930 RecordType *T = TL.getTypePtr(); 2931 RecordDecl *Record 2932 = cast_or_null<RecordDecl>(getDerived().TransformDecl(TL.getNameLoc(), 2933 T->getDecl())); 2934 if (!Record) 2935 return QualType(); 2936 2937 QualType Result = TL.getType(); 2938 if (getDerived().AlwaysRebuild() || 2939 Record != T->getDecl()) { 2940 Result = getDerived().RebuildRecordType(Record); 2941 if (Result.isNull()) 2942 return QualType(); 2943 } 2944 2945 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 2946 NewTL.setNameLoc(TL.getNameLoc()); 2947 2948 return Result; 2949} 2950 2951template<typename Derived> 2952QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 2953 EnumTypeLoc TL, 2954 QualType ObjectType) { 2955 EnumType *T = TL.getTypePtr(); 2956 EnumDecl *Enum 2957 = cast_or_null<EnumDecl>(getDerived().TransformDecl(TL.getNameLoc(), 2958 T->getDecl())); 2959 if (!Enum) 2960 return QualType(); 2961 2962 QualType Result = TL.getType(); 2963 if (getDerived().AlwaysRebuild() || 2964 Enum != T->getDecl()) { 2965 Result = getDerived().RebuildEnumType(Enum); 2966 if (Result.isNull()) 2967 return QualType(); 2968 } 2969 2970 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 2971 NewTL.setNameLoc(TL.getNameLoc()); 2972 2973 return Result; 2974} 2975 2976template <typename Derived> 2977QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 2978 ElaboratedTypeLoc TL, 2979 QualType ObjectType) { 2980 ElaboratedType *T = TL.getTypePtr(); 2981 2982 // FIXME: this should be a nested type. 2983 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2984 if (Underlying.isNull()) 2985 return QualType(); 2986 2987 QualType Result = TL.getType(); 2988 if (getDerived().AlwaysRebuild() || 2989 Underlying != T->getUnderlyingType()) { 2990 Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind()); 2991 if (Result.isNull()) 2992 return QualType(); 2993 } 2994 2995 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 2996 NewTL.setNameLoc(TL.getNameLoc()); 2997 2998 return Result; 2999} 3000 3001template<typename Derived> 3002QualType TreeTransform<Derived>::TransformInjectedClassNameType( 3003 TypeLocBuilder &TLB, 3004 InjectedClassNameTypeLoc TL, 3005 QualType ObjectType) { 3006 Decl *D = getDerived().TransformDecl(TL.getNameLoc(), 3007 TL.getTypePtr()->getDecl()); 3008 if (!D) return QualType(); 3009 3010 QualType T = SemaRef.Context.getTypeDeclType(cast<TypeDecl>(D)); 3011 TLB.pushTypeSpec(T).setNameLoc(TL.getNameLoc()); 3012 return T; 3013} 3014 3015 3016template<typename Derived> 3017QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 3018 TypeLocBuilder &TLB, 3019 TemplateTypeParmTypeLoc TL, 3020 QualType ObjectType) { 3021 return TransformTypeSpecType(TLB, TL); 3022} 3023 3024template<typename Derived> 3025QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 3026 TypeLocBuilder &TLB, 3027 SubstTemplateTypeParmTypeLoc TL, 3028 QualType ObjectType) { 3029 return TransformTypeSpecType(TLB, TL); 3030} 3031 3032template<typename Derived> 3033QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3034 const TemplateSpecializationType *TST, 3035 QualType ObjectType) { 3036 // FIXME: this entire method is a temporary workaround; callers 3037 // should be rewritten to provide real type locs. 3038 3039 // Fake up a TemplateSpecializationTypeLoc. 3040 TypeLocBuilder TLB; 3041 TemplateSpecializationTypeLoc TL 3042 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0)); 3043 3044 SourceLocation BaseLoc = getDerived().getBaseLocation(); 3045 3046 TL.setTemplateNameLoc(BaseLoc); 3047 TL.setLAngleLoc(BaseLoc); 3048 TL.setRAngleLoc(BaseLoc); 3049 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3050 const TemplateArgument &TA = TST->getArg(i); 3051 TemplateArgumentLoc TAL; 3052 getDerived().InventTemplateArgumentLoc(TA, TAL); 3053 TL.setArgLocInfo(i, TAL.getLocInfo()); 3054 } 3055 3056 TypeLocBuilder IgnoredTLB; 3057 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType); 3058} 3059 3060template<typename Derived> 3061QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 3062 TypeLocBuilder &TLB, 3063 TemplateSpecializationTypeLoc TL, 3064 QualType ObjectType) { 3065 const TemplateSpecializationType *T = TL.getTypePtr(); 3066 3067 TemplateName Template 3068 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType); 3069 if (Template.isNull()) 3070 return QualType(); 3071 3072 TemplateArgumentListInfo NewTemplateArgs; 3073 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc()); 3074 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc()); 3075 3076 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) { 3077 TemplateArgumentLoc Loc; 3078 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), Loc)) 3079 return QualType(); 3080 NewTemplateArgs.addArgument(Loc); 3081 } 3082 3083 // FIXME: maybe don't rebuild if all the template arguments are the same. 3084 3085 QualType Result = 3086 getDerived().RebuildTemplateSpecializationType(Template, 3087 TL.getTemplateNameLoc(), 3088 NewTemplateArgs); 3089 3090 if (!Result.isNull()) { 3091 TemplateSpecializationTypeLoc NewTL 3092 = TLB.push<TemplateSpecializationTypeLoc>(Result); 3093 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 3094 NewTL.setLAngleLoc(TL.getLAngleLoc()); 3095 NewTL.setRAngleLoc(TL.getRAngleLoc()); 3096 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 3097 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 3098 } 3099 3100 return Result; 3101} 3102 3103template<typename Derived> 3104QualType 3105TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB, 3106 QualifiedNameTypeLoc TL, 3107 QualType ObjectType) { 3108 QualifiedNameType *T = TL.getTypePtr(); 3109 NestedNameSpecifier *NNS 3110 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 3111 SourceRange(), 3112 ObjectType); 3113 if (!NNS) 3114 return QualType(); 3115 3116 QualType Named = getDerived().TransformType(T->getNamedType()); 3117 if (Named.isNull()) 3118 return QualType(); 3119 3120 QualType Result = TL.getType(); 3121 if (getDerived().AlwaysRebuild() || 3122 NNS != T->getQualifier() || 3123 Named != T->getNamedType()) { 3124 Result = getDerived().RebuildQualifiedNameType(NNS, Named); 3125 if (Result.isNull()) 3126 return QualType(); 3127 } 3128 3129 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result); 3130 NewTL.setNameLoc(TL.getNameLoc()); 3131 3132 return Result; 3133} 3134 3135template<typename Derived> 3136QualType TreeTransform<Derived>::TransformDependentNameType(TypeLocBuilder &TLB, 3137 DependentNameTypeLoc TL, 3138 QualType ObjectType) { 3139 DependentNameType *T = TL.getTypePtr(); 3140 3141 /* FIXME: preserve source information better than this */ 3142 SourceRange SR(TL.getNameLoc()); 3143 3144 NestedNameSpecifier *NNS 3145 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR, 3146 ObjectType); 3147 if (!NNS) 3148 return QualType(); 3149 3150 QualType Result; 3151 3152 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 3153 QualType NewTemplateId 3154 = getDerived().TransformType(QualType(TemplateId, 0)); 3155 if (NewTemplateId.isNull()) 3156 return QualType(); 3157 3158 if (!getDerived().AlwaysRebuild() && 3159 NNS == T->getQualifier() && 3160 NewTemplateId == QualType(TemplateId, 0)) 3161 return QualType(T, 0); 3162 3163 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS, 3164 NewTemplateId); 3165 } else { 3166 Result = getDerived().RebuildDependentNameType(T->getKeyword(), NNS, 3167 T->getIdentifier(), SR); 3168 } 3169 if (Result.isNull()) 3170 return QualType(); 3171 3172 DependentNameTypeLoc NewTL = TLB.push<DependentNameTypeLoc>(Result); 3173 NewTL.setNameLoc(TL.getNameLoc()); 3174 3175 return Result; 3176} 3177 3178template<typename Derived> 3179QualType 3180TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 3181 ObjCInterfaceTypeLoc TL, 3182 QualType ObjectType) { 3183 assert(false && "TransformObjCInterfaceType unimplemented"); 3184 return QualType(); 3185} 3186 3187template<typename Derived> 3188QualType 3189TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 3190 ObjCObjectPointerTypeLoc TL, 3191 QualType ObjectType) { 3192 assert(false && "TransformObjCObjectPointerType unimplemented"); 3193 return QualType(); 3194} 3195 3196//===----------------------------------------------------------------------===// 3197// Statement transformation 3198//===----------------------------------------------------------------------===// 3199template<typename Derived> 3200Sema::OwningStmtResult 3201TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 3202 return SemaRef.Owned(S->Retain()); 3203} 3204 3205template<typename Derived> 3206Sema::OwningStmtResult 3207TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 3208 return getDerived().TransformCompoundStmt(S, false); 3209} 3210 3211template<typename Derived> 3212Sema::OwningStmtResult 3213TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 3214 bool IsStmtExpr) { 3215 bool SubStmtChanged = false; 3216 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); 3217 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 3218 B != BEnd; ++B) { 3219 OwningStmtResult Result = getDerived().TransformStmt(*B); 3220 if (Result.isInvalid()) 3221 return getSema().StmtError(); 3222 3223 SubStmtChanged = SubStmtChanged || Result.get() != *B; 3224 Statements.push_back(Result.takeAs<Stmt>()); 3225 } 3226 3227 if (!getDerived().AlwaysRebuild() && 3228 !SubStmtChanged) 3229 return SemaRef.Owned(S->Retain()); 3230 3231 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 3232 move_arg(Statements), 3233 S->getRBracLoc(), 3234 IsStmtExpr); 3235} 3236 3237template<typename Derived> 3238Sema::OwningStmtResult 3239TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 3240 OwningExprResult LHS(SemaRef), RHS(SemaRef); 3241 { 3242 // The case value expressions are not potentially evaluated. 3243 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3244 3245 // Transform the left-hand case value. 3246 LHS = getDerived().TransformExpr(S->getLHS()); 3247 if (LHS.isInvalid()) 3248 return SemaRef.StmtError(); 3249 3250 // Transform the right-hand case value (for the GNU case-range extension). 3251 RHS = getDerived().TransformExpr(S->getRHS()); 3252 if (RHS.isInvalid()) 3253 return SemaRef.StmtError(); 3254 } 3255 3256 // Build the case statement. 3257 // Case statements are always rebuilt so that they will attached to their 3258 // transformed switch statement. 3259 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 3260 move(LHS), 3261 S->getEllipsisLoc(), 3262 move(RHS), 3263 S->getColonLoc()); 3264 if (Case.isInvalid()) 3265 return SemaRef.StmtError(); 3266 3267 // Transform the statement following the case 3268 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3269 if (SubStmt.isInvalid()) 3270 return SemaRef.StmtError(); 3271 3272 // Attach the body to the case statement 3273 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); 3274} 3275 3276template<typename Derived> 3277Sema::OwningStmtResult 3278TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 3279 // Transform the statement following the default case 3280 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3281 if (SubStmt.isInvalid()) 3282 return SemaRef.StmtError(); 3283 3284 // Default statements are always rebuilt 3285 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 3286 move(SubStmt)); 3287} 3288 3289template<typename Derived> 3290Sema::OwningStmtResult 3291TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 3292 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3293 if (SubStmt.isInvalid()) 3294 return SemaRef.StmtError(); 3295 3296 // FIXME: Pass the real colon location in. 3297 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 3298 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 3299 move(SubStmt)); 3300} 3301 3302template<typename Derived> 3303Sema::OwningStmtResult 3304TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 3305 // Transform the condition 3306 OwningExprResult Cond(SemaRef); 3307 VarDecl *ConditionVar = 0; 3308 if (S->getConditionVariable()) { 3309 ConditionVar 3310 = cast_or_null<VarDecl>( 3311 getDerived().TransformDefinition( 3312 S->getConditionVariable()->getLocation(), 3313 S->getConditionVariable())); 3314 if (!ConditionVar) 3315 return SemaRef.StmtError(); 3316 } else { 3317 Cond = getDerived().TransformExpr(S->getCond()); 3318 3319 if (Cond.isInvalid()) 3320 return SemaRef.StmtError(); 3321 } 3322 3323 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3324 3325 // Transform the "then" branch. 3326 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 3327 if (Then.isInvalid()) 3328 return SemaRef.StmtError(); 3329 3330 // Transform the "else" branch. 3331 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 3332 if (Else.isInvalid()) 3333 return SemaRef.StmtError(); 3334 3335 if (!getDerived().AlwaysRebuild() && 3336 FullCond->get() == S->getCond() && 3337 ConditionVar == S->getConditionVariable() && 3338 Then.get() == S->getThen() && 3339 Else.get() == S->getElse()) 3340 return SemaRef.Owned(S->Retain()); 3341 3342 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, ConditionVar, 3343 move(Then), 3344 S->getElseLoc(), move(Else)); 3345} 3346 3347template<typename Derived> 3348Sema::OwningStmtResult 3349TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 3350 // Transform the condition. 3351 OwningExprResult Cond(SemaRef); 3352 VarDecl *ConditionVar = 0; 3353 if (S->getConditionVariable()) { 3354 ConditionVar 3355 = cast_or_null<VarDecl>( 3356 getDerived().TransformDefinition( 3357 S->getConditionVariable()->getLocation(), 3358 S->getConditionVariable())); 3359 if (!ConditionVar) 3360 return SemaRef.StmtError(); 3361 } else { 3362 Cond = getDerived().TransformExpr(S->getCond()); 3363 3364 if (Cond.isInvalid()) 3365 return SemaRef.StmtError(); 3366 } 3367 3368 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3369 3370 // Rebuild the switch statement. 3371 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(FullCond, 3372 ConditionVar); 3373 if (Switch.isInvalid()) 3374 return SemaRef.StmtError(); 3375 3376 // Transform the body of the switch statement. 3377 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3378 if (Body.isInvalid()) 3379 return SemaRef.StmtError(); 3380 3381 // Complete the switch statement. 3382 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 3383 move(Body)); 3384} 3385 3386template<typename Derived> 3387Sema::OwningStmtResult 3388TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 3389 // Transform the condition 3390 OwningExprResult Cond(SemaRef); 3391 VarDecl *ConditionVar = 0; 3392 if (S->getConditionVariable()) { 3393 ConditionVar 3394 = cast_or_null<VarDecl>( 3395 getDerived().TransformDefinition( 3396 S->getConditionVariable()->getLocation(), 3397 S->getConditionVariable())); 3398 if (!ConditionVar) 3399 return SemaRef.StmtError(); 3400 } else { 3401 Cond = getDerived().TransformExpr(S->getCond()); 3402 3403 if (Cond.isInvalid()) 3404 return SemaRef.StmtError(); 3405 } 3406 3407 Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond)); 3408 3409 // Transform the body 3410 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3411 if (Body.isInvalid()) 3412 return SemaRef.StmtError(); 3413 3414 if (!getDerived().AlwaysRebuild() && 3415 FullCond->get() == S->getCond() && 3416 ConditionVar == S->getConditionVariable() && 3417 Body.get() == S->getBody()) 3418 return SemaRef.Owned(S->Retain()); 3419 3420 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, ConditionVar, 3421 move(Body)); 3422} 3423 3424template<typename Derived> 3425Sema::OwningStmtResult 3426TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 3427 // Transform the condition 3428 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3429 if (Cond.isInvalid()) 3430 return SemaRef.StmtError(); 3431 3432 // Transform the body 3433 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3434 if (Body.isInvalid()) 3435 return SemaRef.StmtError(); 3436 3437 if (!getDerived().AlwaysRebuild() && 3438 Cond.get() == S->getCond() && 3439 Body.get() == S->getBody()) 3440 return SemaRef.Owned(S->Retain()); 3441 3442 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 3443 /*FIXME:*/S->getWhileLoc(), move(Cond), 3444 S->getRParenLoc()); 3445} 3446 3447template<typename Derived> 3448Sema::OwningStmtResult 3449TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3450 // Transform the initialization statement 3451 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3452 if (Init.isInvalid()) 3453 return SemaRef.StmtError(); 3454 3455 // Transform the condition 3456 OwningExprResult Cond(SemaRef); 3457 VarDecl *ConditionVar = 0; 3458 if (S->getConditionVariable()) { 3459 ConditionVar 3460 = cast_or_null<VarDecl>( 3461 getDerived().TransformDefinition( 3462 S->getConditionVariable()->getLocation(), 3463 S->getConditionVariable())); 3464 if (!ConditionVar) 3465 return SemaRef.StmtError(); 3466 } else { 3467 Cond = getDerived().TransformExpr(S->getCond()); 3468 3469 if (Cond.isInvalid()) 3470 return SemaRef.StmtError(); 3471 } 3472 3473 // Transform the increment 3474 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3475 if (Inc.isInvalid()) 3476 return SemaRef.StmtError(); 3477 3478 // Transform the body 3479 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3480 if (Body.isInvalid()) 3481 return SemaRef.StmtError(); 3482 3483 if (!getDerived().AlwaysRebuild() && 3484 Init.get() == S->getInit() && 3485 Cond.get() == S->getCond() && 3486 Inc.get() == S->getInc() && 3487 Body.get() == S->getBody()) 3488 return SemaRef.Owned(S->Retain()); 3489 3490 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3491 move(Init), getSema().MakeFullExpr(Cond), 3492 ConditionVar, 3493 getSema().MakeFullExpr(Inc), 3494 S->getRParenLoc(), move(Body)); 3495} 3496 3497template<typename Derived> 3498Sema::OwningStmtResult 3499TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3500 // Goto statements must always be rebuilt, to resolve the label. 3501 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3502 S->getLabel()); 3503} 3504 3505template<typename Derived> 3506Sema::OwningStmtResult 3507TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3508 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3509 if (Target.isInvalid()) 3510 return SemaRef.StmtError(); 3511 3512 if (!getDerived().AlwaysRebuild() && 3513 Target.get() == S->getTarget()) 3514 return SemaRef.Owned(S->Retain()); 3515 3516 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3517 move(Target)); 3518} 3519 3520template<typename Derived> 3521Sema::OwningStmtResult 3522TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3523 return SemaRef.Owned(S->Retain()); 3524} 3525 3526template<typename Derived> 3527Sema::OwningStmtResult 3528TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3529 return SemaRef.Owned(S->Retain()); 3530} 3531 3532template<typename Derived> 3533Sema::OwningStmtResult 3534TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3535 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3536 if (Result.isInvalid()) 3537 return SemaRef.StmtError(); 3538 3539 // FIXME: We always rebuild the return statement because there is no way 3540 // to tell whether the return type of the function has changed. 3541 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3542} 3543 3544template<typename Derived> 3545Sema::OwningStmtResult 3546TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3547 bool DeclChanged = false; 3548 llvm::SmallVector<Decl *, 4> Decls; 3549 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3550 D != DEnd; ++D) { 3551 Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(), 3552 *D); 3553 if (!Transformed) 3554 return SemaRef.StmtError(); 3555 3556 if (Transformed != *D) 3557 DeclChanged = true; 3558 3559 Decls.push_back(Transformed); 3560 } 3561 3562 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3563 return SemaRef.Owned(S->Retain()); 3564 3565 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3566 S->getStartLoc(), S->getEndLoc()); 3567} 3568 3569template<typename Derived> 3570Sema::OwningStmtResult 3571TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3572 assert(false && "SwitchCase is abstract and cannot be transformed"); 3573 return SemaRef.Owned(S->Retain()); 3574} 3575 3576template<typename Derived> 3577Sema::OwningStmtResult 3578TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3579 3580 ASTOwningVector<&ActionBase::DeleteExpr> Constraints(getSema()); 3581 ASTOwningVector<&ActionBase::DeleteExpr> Exprs(getSema()); 3582 llvm::SmallVector<IdentifierInfo *, 4> Names; 3583 3584 OwningExprResult AsmString(SemaRef); 3585 ASTOwningVector<&ActionBase::DeleteExpr> Clobbers(getSema()); 3586 3587 bool ExprsChanged = false; 3588 3589 // Go through the outputs. 3590 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) { 3591 Names.push_back(S->getOutputIdentifier(I)); 3592 3593 // No need to transform the constraint literal. 3594 Constraints.push_back(S->getOutputConstraintLiteral(I)->Retain()); 3595 3596 // Transform the output expr. 3597 Expr *OutputExpr = S->getOutputExpr(I); 3598 OwningExprResult Result = getDerived().TransformExpr(OutputExpr); 3599 if (Result.isInvalid()) 3600 return SemaRef.StmtError(); 3601 3602 ExprsChanged |= Result.get() != OutputExpr; 3603 3604 Exprs.push_back(Result.takeAs<Expr>()); 3605 } 3606 3607 // Go through the inputs. 3608 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) { 3609 Names.push_back(S->getInputIdentifier(I)); 3610 3611 // No need to transform the constraint literal. 3612 Constraints.push_back(S->getInputConstraintLiteral(I)->Retain()); 3613 3614 // Transform the input expr. 3615 Expr *InputExpr = S->getInputExpr(I); 3616 OwningExprResult Result = getDerived().TransformExpr(InputExpr); 3617 if (Result.isInvalid()) 3618 return SemaRef.StmtError(); 3619 3620 ExprsChanged |= Result.get() != InputExpr; 3621 3622 Exprs.push_back(Result.takeAs<Expr>()); 3623 } 3624 3625 if (!getDerived().AlwaysRebuild() && !ExprsChanged) 3626 return SemaRef.Owned(S->Retain()); 3627 3628 // Go through the clobbers. 3629 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) 3630 Clobbers.push_back(S->getClobber(I)->Retain()); 3631 3632 // No need to transform the asm string literal. 3633 AsmString = SemaRef.Owned(S->getAsmString()); 3634 3635 return getDerived().RebuildAsmStmt(S->getAsmLoc(), 3636 S->isSimple(), 3637 S->isVolatile(), 3638 S->getNumOutputs(), 3639 S->getNumInputs(), 3640 Names.data(), 3641 move_arg(Constraints), 3642 move_arg(Exprs), 3643 move(AsmString), 3644 move_arg(Clobbers), 3645 S->getRParenLoc(), 3646 S->isMSAsm()); 3647} 3648 3649 3650template<typename Derived> 3651Sema::OwningStmtResult 3652TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3653 // FIXME: Implement this 3654 assert(false && "Cannot transform an Objective-C @try statement"); 3655 return SemaRef.Owned(S->Retain()); 3656} 3657 3658template<typename Derived> 3659Sema::OwningStmtResult 3660TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3661 // FIXME: Implement this 3662 assert(false && "Cannot transform an Objective-C @catch statement"); 3663 return SemaRef.Owned(S->Retain()); 3664} 3665 3666template<typename Derived> 3667Sema::OwningStmtResult 3668TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3669 // FIXME: Implement this 3670 assert(false && "Cannot transform an Objective-C @finally statement"); 3671 return SemaRef.Owned(S->Retain()); 3672} 3673 3674template<typename Derived> 3675Sema::OwningStmtResult 3676TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3677 // FIXME: Implement this 3678 assert(false && "Cannot transform an Objective-C @throw statement"); 3679 return SemaRef.Owned(S->Retain()); 3680} 3681 3682template<typename Derived> 3683Sema::OwningStmtResult 3684TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3685 ObjCAtSynchronizedStmt *S) { 3686 // FIXME: Implement this 3687 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3688 return SemaRef.Owned(S->Retain()); 3689} 3690 3691template<typename Derived> 3692Sema::OwningStmtResult 3693TreeTransform<Derived>::TransformObjCForCollectionStmt( 3694 ObjCForCollectionStmt *S) { 3695 // FIXME: Implement this 3696 assert(false && "Cannot transform an Objective-C for-each statement"); 3697 return SemaRef.Owned(S->Retain()); 3698} 3699 3700 3701template<typename Derived> 3702Sema::OwningStmtResult 3703TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3704 // Transform the exception declaration, if any. 3705 VarDecl *Var = 0; 3706 if (S->getExceptionDecl()) { 3707 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3708 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3709 ExceptionDecl->getDeclName()); 3710 3711 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3712 if (T.isNull()) 3713 return SemaRef.StmtError(); 3714 3715 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3716 T, 3717 ExceptionDecl->getTypeSourceInfo(), 3718 ExceptionDecl->getIdentifier(), 3719 ExceptionDecl->getLocation(), 3720 /*FIXME: Inaccurate*/ 3721 SourceRange(ExceptionDecl->getLocation())); 3722 if (!Var || Var->isInvalidDecl()) { 3723 if (Var) 3724 Var->Destroy(SemaRef.Context); 3725 return SemaRef.StmtError(); 3726 } 3727 } 3728 3729 // Transform the actual exception handler. 3730 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3731 if (Handler.isInvalid()) { 3732 if (Var) 3733 Var->Destroy(SemaRef.Context); 3734 return SemaRef.StmtError(); 3735 } 3736 3737 if (!getDerived().AlwaysRebuild() && 3738 !Var && 3739 Handler.get() == S->getHandlerBlock()) 3740 return SemaRef.Owned(S->Retain()); 3741 3742 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3743 Var, 3744 move(Handler)); 3745} 3746 3747template<typename Derived> 3748Sema::OwningStmtResult 3749TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3750 // Transform the try block itself. 3751 OwningStmtResult TryBlock 3752 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3753 if (TryBlock.isInvalid()) 3754 return SemaRef.StmtError(); 3755 3756 // Transform the handlers. 3757 bool HandlerChanged = false; 3758 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3759 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3760 OwningStmtResult Handler 3761 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3762 if (Handler.isInvalid()) 3763 return SemaRef.StmtError(); 3764 3765 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3766 Handlers.push_back(Handler.takeAs<Stmt>()); 3767 } 3768 3769 if (!getDerived().AlwaysRebuild() && 3770 TryBlock.get() == S->getTryBlock() && 3771 !HandlerChanged) 3772 return SemaRef.Owned(S->Retain()); 3773 3774 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3775 move_arg(Handlers)); 3776} 3777 3778//===----------------------------------------------------------------------===// 3779// Expression transformation 3780//===----------------------------------------------------------------------===// 3781template<typename Derived> 3782Sema::OwningExprResult 3783TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) { 3784 return SemaRef.Owned(E->Retain()); 3785} 3786 3787template<typename Derived> 3788Sema::OwningExprResult 3789TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) { 3790 NestedNameSpecifier *Qualifier = 0; 3791 if (E->getQualifier()) { 3792 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3793 E->getQualifierRange()); 3794 if (!Qualifier) 3795 return SemaRef.ExprError(); 3796 } 3797 3798 ValueDecl *ND 3799 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(), 3800 E->getDecl())); 3801 if (!ND) 3802 return SemaRef.ExprError(); 3803 3804 if (!getDerived().AlwaysRebuild() && 3805 Qualifier == E->getQualifier() && 3806 ND == E->getDecl() && 3807 !E->hasExplicitTemplateArgumentList()) { 3808 3809 // Mark it referenced in the new context regardless. 3810 // FIXME: this is a bit instantiation-specific. 3811 SemaRef.MarkDeclarationReferenced(E->getLocation(), ND); 3812 3813 return SemaRef.Owned(E->Retain()); 3814 } 3815 3816 TemplateArgumentListInfo TransArgs, *TemplateArgs = 0; 3817 if (E->hasExplicitTemplateArgumentList()) { 3818 TemplateArgs = &TransArgs; 3819 TransArgs.setLAngleLoc(E->getLAngleLoc()); 3820 TransArgs.setRAngleLoc(E->getRAngleLoc()); 3821 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3822 TemplateArgumentLoc Loc; 3823 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 3824 return SemaRef.ExprError(); 3825 TransArgs.addArgument(Loc); 3826 } 3827 } 3828 3829 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3830 ND, E->getLocation(), TemplateArgs); 3831} 3832 3833template<typename Derived> 3834Sema::OwningExprResult 3835TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) { 3836 return SemaRef.Owned(E->Retain()); 3837} 3838 3839template<typename Derived> 3840Sema::OwningExprResult 3841TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) { 3842 return SemaRef.Owned(E->Retain()); 3843} 3844 3845template<typename Derived> 3846Sema::OwningExprResult 3847TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) { 3848 return SemaRef.Owned(E->Retain()); 3849} 3850 3851template<typename Derived> 3852Sema::OwningExprResult 3853TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) { 3854 return SemaRef.Owned(E->Retain()); 3855} 3856 3857template<typename Derived> 3858Sema::OwningExprResult 3859TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) { 3860 return SemaRef.Owned(E->Retain()); 3861} 3862 3863template<typename Derived> 3864Sema::OwningExprResult 3865TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { 3866 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3867 if (SubExpr.isInvalid()) 3868 return SemaRef.ExprError(); 3869 3870 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3871 return SemaRef.Owned(E->Retain()); 3872 3873 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 3874 E->getRParen()); 3875} 3876 3877template<typename Derived> 3878Sema::OwningExprResult 3879TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) { 3880 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3881 if (SubExpr.isInvalid()) 3882 return SemaRef.ExprError(); 3883 3884 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3885 return SemaRef.Owned(E->Retain()); 3886 3887 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3888 E->getOpcode(), 3889 move(SubExpr)); 3890} 3891 3892template<typename Derived> 3893Sema::OwningExprResult 3894TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { 3895 if (E->isArgumentType()) { 3896 TypeSourceInfo *OldT = E->getArgumentTypeInfo(); 3897 3898 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 3899 if (!NewT) 3900 return SemaRef.ExprError(); 3901 3902 if (!getDerived().AlwaysRebuild() && OldT == NewT) 3903 return SemaRef.Owned(E->Retain()); 3904 3905 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 3906 E->isSizeOf(), 3907 E->getSourceRange()); 3908 } 3909 3910 Sema::OwningExprResult SubExpr(SemaRef); 3911 { 3912 // C++0x [expr.sizeof]p1: 3913 // The operand is either an expression, which is an unevaluated operand 3914 // [...] 3915 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3916 3917 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3918 if (SubExpr.isInvalid()) 3919 return SemaRef.ExprError(); 3920 3921 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3922 return SemaRef.Owned(E->Retain()); 3923 } 3924 3925 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3926 E->isSizeOf(), 3927 E->getSourceRange()); 3928} 3929 3930template<typename Derived> 3931Sema::OwningExprResult 3932TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) { 3933 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3934 if (LHS.isInvalid()) 3935 return SemaRef.ExprError(); 3936 3937 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3938 if (RHS.isInvalid()) 3939 return SemaRef.ExprError(); 3940 3941 3942 if (!getDerived().AlwaysRebuild() && 3943 LHS.get() == E->getLHS() && 3944 RHS.get() == E->getRHS()) 3945 return SemaRef.Owned(E->Retain()); 3946 3947 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3948 /*FIXME:*/E->getLHS()->getLocStart(), 3949 move(RHS), 3950 E->getRBracketLoc()); 3951} 3952 3953template<typename Derived> 3954Sema::OwningExprResult 3955TreeTransform<Derived>::TransformCallExpr(CallExpr *E) { 3956 // Transform the callee. 3957 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3958 if (Callee.isInvalid()) 3959 return SemaRef.ExprError(); 3960 3961 // Transform arguments. 3962 bool ArgChanged = false; 3963 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3964 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3965 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3966 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3967 if (Arg.isInvalid()) 3968 return SemaRef.ExprError(); 3969 3970 // FIXME: Wrong source location information for the ','. 3971 FakeCommaLocs.push_back( 3972 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3973 3974 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3975 Args.push_back(Arg.takeAs<Expr>()); 3976 } 3977 3978 if (!getDerived().AlwaysRebuild() && 3979 Callee.get() == E->getCallee() && 3980 !ArgChanged) 3981 return SemaRef.Owned(E->Retain()); 3982 3983 // FIXME: Wrong source location information for the '('. 3984 SourceLocation FakeLParenLoc 3985 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3986 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3987 move_arg(Args), 3988 FakeCommaLocs.data(), 3989 E->getRParenLoc()); 3990} 3991 3992template<typename Derived> 3993Sema::OwningExprResult 3994TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) { 3995 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3996 if (Base.isInvalid()) 3997 return SemaRef.ExprError(); 3998 3999 NestedNameSpecifier *Qualifier = 0; 4000 if (E->hasQualifier()) { 4001 Qualifier 4002 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4003 E->getQualifierRange()); 4004 if (Qualifier == 0) 4005 return SemaRef.ExprError(); 4006 } 4007 4008 ValueDecl *Member 4009 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(), 4010 E->getMemberDecl())); 4011 if (!Member) 4012 return SemaRef.ExprError(); 4013 4014 NamedDecl *FoundDecl = E->getFoundDecl(); 4015 if (FoundDecl == E->getMemberDecl()) { 4016 FoundDecl = Member; 4017 } else { 4018 FoundDecl = cast_or_null<NamedDecl>( 4019 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl)); 4020 if (!FoundDecl) 4021 return SemaRef.ExprError(); 4022 } 4023 4024 if (!getDerived().AlwaysRebuild() && 4025 Base.get() == E->getBase() && 4026 Qualifier == E->getQualifier() && 4027 Member == E->getMemberDecl() && 4028 FoundDecl == E->getFoundDecl() && 4029 !E->hasExplicitTemplateArgumentList()) { 4030 4031 // Mark it referenced in the new context regardless. 4032 // FIXME: this is a bit instantiation-specific. 4033 SemaRef.MarkDeclarationReferenced(E->getMemberLoc(), Member); 4034 return SemaRef.Owned(E->Retain()); 4035 } 4036 4037 TemplateArgumentListInfo TransArgs; 4038 if (E->hasExplicitTemplateArgumentList()) { 4039 TransArgs.setLAngleLoc(E->getLAngleLoc()); 4040 TransArgs.setRAngleLoc(E->getRAngleLoc()); 4041 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4042 TemplateArgumentLoc Loc; 4043 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 4044 return SemaRef.ExprError(); 4045 TransArgs.addArgument(Loc); 4046 } 4047 } 4048 4049 // FIXME: Bogus source location for the operator 4050 SourceLocation FakeOperatorLoc 4051 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 4052 4053 // FIXME: to do this check properly, we will need to preserve the 4054 // first-qualifier-in-scope here, just in case we had a dependent 4055 // base (and therefore couldn't do the check) and a 4056 // nested-name-qualifier (and therefore could do the lookup). 4057 NamedDecl *FirstQualifierInScope = 0; 4058 4059 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 4060 E->isArrow(), 4061 Qualifier, 4062 E->getQualifierRange(), 4063 E->getMemberLoc(), 4064 Member, 4065 FoundDecl, 4066 (E->hasExplicitTemplateArgumentList() 4067 ? &TransArgs : 0), 4068 FirstQualifierInScope); 4069} 4070 4071template<typename Derived> 4072Sema::OwningExprResult 4073TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) { 4074 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4075 if (LHS.isInvalid()) 4076 return SemaRef.ExprError(); 4077 4078 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4079 if (RHS.isInvalid()) 4080 return SemaRef.ExprError(); 4081 4082 if (!getDerived().AlwaysRebuild() && 4083 LHS.get() == E->getLHS() && 4084 RHS.get() == E->getRHS()) 4085 return SemaRef.Owned(E->Retain()); 4086 4087 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 4088 move(LHS), move(RHS)); 4089} 4090 4091template<typename Derived> 4092Sema::OwningExprResult 4093TreeTransform<Derived>::TransformCompoundAssignOperator( 4094 CompoundAssignOperator *E) { 4095 return getDerived().TransformBinaryOperator(E); 4096} 4097 4098template<typename Derived> 4099Sema::OwningExprResult 4100TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) { 4101 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 4102 if (Cond.isInvalid()) 4103 return SemaRef.ExprError(); 4104 4105 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4106 if (LHS.isInvalid()) 4107 return SemaRef.ExprError(); 4108 4109 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4110 if (RHS.isInvalid()) 4111 return SemaRef.ExprError(); 4112 4113 if (!getDerived().AlwaysRebuild() && 4114 Cond.get() == E->getCond() && 4115 LHS.get() == E->getLHS() && 4116 RHS.get() == E->getRHS()) 4117 return SemaRef.Owned(E->Retain()); 4118 4119 return getDerived().RebuildConditionalOperator(move(Cond), 4120 E->getQuestionLoc(), 4121 move(LHS), 4122 E->getColonLoc(), 4123 move(RHS)); 4124} 4125 4126template<typename Derived> 4127Sema::OwningExprResult 4128TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) { 4129 // Implicit casts are eliminated during transformation, since they 4130 // will be recomputed by semantic analysis after transformation. 4131 return getDerived().TransformExpr(E->getSubExprAsWritten()); 4132} 4133 4134template<typename Derived> 4135Sema::OwningExprResult 4136TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) { 4137 TypeSourceInfo *OldT; 4138 TypeSourceInfo *NewT; 4139 { 4140 // FIXME: Source location isn't quite accurate. 4141 SourceLocation TypeStartLoc 4142 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 4143 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 4144 4145 OldT = E->getTypeInfoAsWritten(); 4146 NewT = getDerived().TransformType(OldT); 4147 if (!NewT) 4148 return SemaRef.ExprError(); 4149 } 4150 4151 OwningExprResult SubExpr 4152 = getDerived().TransformExpr(E->getSubExprAsWritten()); 4153 if (SubExpr.isInvalid()) 4154 return SemaRef.ExprError(); 4155 4156 if (!getDerived().AlwaysRebuild() && 4157 OldT == NewT && 4158 SubExpr.get() == E->getSubExpr()) 4159 return SemaRef.Owned(E->Retain()); 4160 4161 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(), 4162 NewT, 4163 E->getRParenLoc(), 4164 move(SubExpr)); 4165} 4166 4167template<typename Derived> 4168Sema::OwningExprResult 4169TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) { 4170 TypeSourceInfo *OldT = E->getTypeSourceInfo(); 4171 TypeSourceInfo *NewT = getDerived().TransformType(OldT); 4172 if (!NewT) 4173 return SemaRef.ExprError(); 4174 4175 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 4176 if (Init.isInvalid()) 4177 return SemaRef.ExprError(); 4178 4179 if (!getDerived().AlwaysRebuild() && 4180 OldT == NewT && 4181 Init.get() == E->getInitializer()) 4182 return SemaRef.Owned(E->Retain()); 4183 4184 // Note: the expression type doesn't necessarily match the 4185 // type-as-written, but that's okay, because it should always be 4186 // derivable from the initializer. 4187 4188 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), NewT, 4189 /*FIXME:*/E->getInitializer()->getLocEnd(), 4190 move(Init)); 4191} 4192 4193template<typename Derived> 4194Sema::OwningExprResult 4195TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) { 4196 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4197 if (Base.isInvalid()) 4198 return SemaRef.ExprError(); 4199 4200 if (!getDerived().AlwaysRebuild() && 4201 Base.get() == E->getBase()) 4202 return SemaRef.Owned(E->Retain()); 4203 4204 // FIXME: Bad source location 4205 SourceLocation FakeOperatorLoc 4206 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 4207 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 4208 E->getAccessorLoc(), 4209 E->getAccessor()); 4210} 4211 4212template<typename Derived> 4213Sema::OwningExprResult 4214TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) { 4215 bool InitChanged = false; 4216 4217 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4218 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 4219 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 4220 if (Init.isInvalid()) 4221 return SemaRef.ExprError(); 4222 4223 InitChanged = InitChanged || Init.get() != E->getInit(I); 4224 Inits.push_back(Init.takeAs<Expr>()); 4225 } 4226 4227 if (!getDerived().AlwaysRebuild() && !InitChanged) 4228 return SemaRef.Owned(E->Retain()); 4229 4230 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 4231 E->getRBraceLoc(), E->getType()); 4232} 4233 4234template<typename Derived> 4235Sema::OwningExprResult 4236TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) { 4237 Designation Desig; 4238 4239 // transform the initializer value 4240 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 4241 if (Init.isInvalid()) 4242 return SemaRef.ExprError(); 4243 4244 // transform the designators. 4245 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 4246 bool ExprChanged = false; 4247 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 4248 DEnd = E->designators_end(); 4249 D != DEnd; ++D) { 4250 if (D->isFieldDesignator()) { 4251 Desig.AddDesignator(Designator::getField(D->getFieldName(), 4252 D->getDotLoc(), 4253 D->getFieldLoc())); 4254 continue; 4255 } 4256 4257 if (D->isArrayDesignator()) { 4258 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 4259 if (Index.isInvalid()) 4260 return SemaRef.ExprError(); 4261 4262 Desig.AddDesignator(Designator::getArray(Index.get(), 4263 D->getLBracketLoc())); 4264 4265 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 4266 ArrayExprs.push_back(Index.release()); 4267 continue; 4268 } 4269 4270 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 4271 OwningExprResult Start 4272 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 4273 if (Start.isInvalid()) 4274 return SemaRef.ExprError(); 4275 4276 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 4277 if (End.isInvalid()) 4278 return SemaRef.ExprError(); 4279 4280 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 4281 End.get(), 4282 D->getLBracketLoc(), 4283 D->getEllipsisLoc())); 4284 4285 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 4286 End.get() != E->getArrayRangeEnd(*D); 4287 4288 ArrayExprs.push_back(Start.release()); 4289 ArrayExprs.push_back(End.release()); 4290 } 4291 4292 if (!getDerived().AlwaysRebuild() && 4293 Init.get() == E->getInit() && 4294 !ExprChanged) 4295 return SemaRef.Owned(E->Retain()); 4296 4297 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 4298 E->getEqualOrColonLoc(), 4299 E->usesGNUSyntax(), move(Init)); 4300} 4301 4302template<typename Derived> 4303Sema::OwningExprResult 4304TreeTransform<Derived>::TransformImplicitValueInitExpr( 4305 ImplicitValueInitExpr *E) { 4306 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4307 4308 // FIXME: Will we ever have proper type location here? Will we actually 4309 // need to transform the type? 4310 QualType T = getDerived().TransformType(E->getType()); 4311 if (T.isNull()) 4312 return SemaRef.ExprError(); 4313 4314 if (!getDerived().AlwaysRebuild() && 4315 T == E->getType()) 4316 return SemaRef.Owned(E->Retain()); 4317 4318 return getDerived().RebuildImplicitValueInitExpr(T); 4319} 4320 4321template<typename Derived> 4322Sema::OwningExprResult 4323TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) { 4324 // FIXME: Do we want the type as written? 4325 QualType T; 4326 4327 { 4328 // FIXME: Source location isn't quite accurate. 4329 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4330 T = getDerived().TransformType(E->getType()); 4331 if (T.isNull()) 4332 return SemaRef.ExprError(); 4333 } 4334 4335 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4336 if (SubExpr.isInvalid()) 4337 return SemaRef.ExprError(); 4338 4339 if (!getDerived().AlwaysRebuild() && 4340 T == E->getType() && 4341 SubExpr.get() == E->getSubExpr()) 4342 return SemaRef.Owned(E->Retain()); 4343 4344 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 4345 T, E->getRParenLoc()); 4346} 4347 4348template<typename Derived> 4349Sema::OwningExprResult 4350TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { 4351 bool ArgumentChanged = false; 4352 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4353 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 4354 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 4355 if (Init.isInvalid()) 4356 return SemaRef.ExprError(); 4357 4358 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 4359 Inits.push_back(Init.takeAs<Expr>()); 4360 } 4361 4362 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 4363 move_arg(Inits), 4364 E->getRParenLoc()); 4365} 4366 4367/// \brief Transform an address-of-label expression. 4368/// 4369/// By default, the transformation of an address-of-label expression always 4370/// rebuilds the expression, so that the label identifier can be resolved to 4371/// the corresponding label statement by semantic analysis. 4372template<typename Derived> 4373Sema::OwningExprResult 4374TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) { 4375 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 4376 E->getLabel()); 4377} 4378 4379template<typename Derived> 4380Sema::OwningExprResult 4381TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) { 4382 OwningStmtResult SubStmt 4383 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 4384 if (SubStmt.isInvalid()) 4385 return SemaRef.ExprError(); 4386 4387 if (!getDerived().AlwaysRebuild() && 4388 SubStmt.get() == E->getSubStmt()) 4389 return SemaRef.Owned(E->Retain()); 4390 4391 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 4392 move(SubStmt), 4393 E->getRParenLoc()); 4394} 4395 4396template<typename Derived> 4397Sema::OwningExprResult 4398TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E) { 4399 QualType T1, T2; 4400 { 4401 // FIXME: Source location isn't quite accurate. 4402 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4403 4404 T1 = getDerived().TransformType(E->getArgType1()); 4405 if (T1.isNull()) 4406 return SemaRef.ExprError(); 4407 4408 T2 = getDerived().TransformType(E->getArgType2()); 4409 if (T2.isNull()) 4410 return SemaRef.ExprError(); 4411 } 4412 4413 if (!getDerived().AlwaysRebuild() && 4414 T1 == E->getArgType1() && 4415 T2 == E->getArgType2()) 4416 return SemaRef.Owned(E->Retain()); 4417 4418 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 4419 T1, T2, E->getRParenLoc()); 4420} 4421 4422template<typename Derived> 4423Sema::OwningExprResult 4424TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) { 4425 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 4426 if (Cond.isInvalid()) 4427 return SemaRef.ExprError(); 4428 4429 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4430 if (LHS.isInvalid()) 4431 return SemaRef.ExprError(); 4432 4433 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4434 if (RHS.isInvalid()) 4435 return SemaRef.ExprError(); 4436 4437 if (!getDerived().AlwaysRebuild() && 4438 Cond.get() == E->getCond() && 4439 LHS.get() == E->getLHS() && 4440 RHS.get() == E->getRHS()) 4441 return SemaRef.Owned(E->Retain()); 4442 4443 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 4444 move(Cond), move(LHS), move(RHS), 4445 E->getRParenLoc()); 4446} 4447 4448template<typename Derived> 4449Sema::OwningExprResult 4450TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) { 4451 return SemaRef.Owned(E->Retain()); 4452} 4453 4454template<typename Derived> 4455Sema::OwningExprResult 4456TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 4457 switch (E->getOperator()) { 4458 case OO_New: 4459 case OO_Delete: 4460 case OO_Array_New: 4461 case OO_Array_Delete: 4462 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr"); 4463 return SemaRef.ExprError(); 4464 4465 case OO_Call: { 4466 // This is a call to an object's operator(). 4467 assert(E->getNumArgs() >= 1 && "Object call is missing arguments"); 4468 4469 // Transform the object itself. 4470 OwningExprResult Object = getDerived().TransformExpr(E->getArg(0)); 4471 if (Object.isInvalid()) 4472 return SemaRef.ExprError(); 4473 4474 // FIXME: Poor location information 4475 SourceLocation FakeLParenLoc 4476 = SemaRef.PP.getLocForEndOfToken( 4477 static_cast<Expr *>(Object.get())->getLocEnd()); 4478 4479 // Transform the call arguments. 4480 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4481 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 4482 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) { 4483 if (getDerived().DropCallArgument(E->getArg(I))) 4484 break; 4485 4486 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 4487 if (Arg.isInvalid()) 4488 return SemaRef.ExprError(); 4489 4490 // FIXME: Poor source location information. 4491 SourceLocation FakeCommaLoc 4492 = SemaRef.PP.getLocForEndOfToken( 4493 static_cast<Expr *>(Arg.get())->getLocEnd()); 4494 FakeCommaLocs.push_back(FakeCommaLoc); 4495 Args.push_back(Arg.release()); 4496 } 4497 4498 return getDerived().RebuildCallExpr(move(Object), FakeLParenLoc, 4499 move_arg(Args), 4500 FakeCommaLocs.data(), 4501 E->getLocEnd()); 4502 } 4503 4504#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 4505 case OO_##Name: 4506#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 4507#include "clang/Basic/OperatorKinds.def" 4508 case OO_Subscript: 4509 // Handled below. 4510 break; 4511 4512 case OO_Conditional: 4513 llvm_unreachable("conditional operator is not actually overloadable"); 4514 return SemaRef.ExprError(); 4515 4516 case OO_None: 4517 case NUM_OVERLOADED_OPERATORS: 4518 llvm_unreachable("not an overloaded operator?"); 4519 return SemaRef.ExprError(); 4520 } 4521 4522 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 4523 if (Callee.isInvalid()) 4524 return SemaRef.ExprError(); 4525 4526 OwningExprResult First = getDerived().TransformExpr(E->getArg(0)); 4527 if (First.isInvalid()) 4528 return SemaRef.ExprError(); 4529 4530 OwningExprResult Second(SemaRef); 4531 if (E->getNumArgs() == 2) { 4532 Second = getDerived().TransformExpr(E->getArg(1)); 4533 if (Second.isInvalid()) 4534 return SemaRef.ExprError(); 4535 } 4536 4537 if (!getDerived().AlwaysRebuild() && 4538 Callee.get() == E->getCallee() && 4539 First.get() == E->getArg(0) && 4540 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 4541 return SemaRef.Owned(E->Retain()); 4542 4543 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 4544 E->getOperatorLoc(), 4545 move(Callee), 4546 move(First), 4547 move(Second)); 4548} 4549 4550template<typename Derived> 4551Sema::OwningExprResult 4552TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) { 4553 return getDerived().TransformCallExpr(E); 4554} 4555 4556template<typename Derived> 4557Sema::OwningExprResult 4558TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) { 4559 TypeSourceInfo *OldT; 4560 TypeSourceInfo *NewT; 4561 { 4562 // FIXME: Source location isn't quite accurate. 4563 SourceLocation TypeStartLoc 4564 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4565 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 4566 4567 OldT = E->getTypeInfoAsWritten(); 4568 NewT = getDerived().TransformType(OldT); 4569 if (!NewT) 4570 return SemaRef.ExprError(); 4571 } 4572 4573 OwningExprResult SubExpr 4574 = getDerived().TransformExpr(E->getSubExprAsWritten()); 4575 if (SubExpr.isInvalid()) 4576 return SemaRef.ExprError(); 4577 4578 if (!getDerived().AlwaysRebuild() && 4579 OldT == NewT && 4580 SubExpr.get() == E->getSubExpr()) 4581 return SemaRef.Owned(E->Retain()); 4582 4583 // FIXME: Poor source location information here. 4584 SourceLocation FakeLAngleLoc 4585 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4586 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 4587 SourceLocation FakeRParenLoc 4588 = SemaRef.PP.getLocForEndOfToken( 4589 E->getSubExpr()->getSourceRange().getEnd()); 4590 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 4591 E->getStmtClass(), 4592 FakeLAngleLoc, 4593 NewT, 4594 FakeRAngleLoc, 4595 FakeRAngleLoc, 4596 move(SubExpr), 4597 FakeRParenLoc); 4598} 4599 4600template<typename Derived> 4601Sema::OwningExprResult 4602TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) { 4603 return getDerived().TransformCXXNamedCastExpr(E); 4604} 4605 4606template<typename Derived> 4607Sema::OwningExprResult 4608TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) { 4609 return getDerived().TransformCXXNamedCastExpr(E); 4610} 4611 4612template<typename Derived> 4613Sema::OwningExprResult 4614TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 4615 CXXReinterpretCastExpr *E) { 4616 return getDerived().TransformCXXNamedCastExpr(E); 4617} 4618 4619template<typename Derived> 4620Sema::OwningExprResult 4621TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) { 4622 return getDerived().TransformCXXNamedCastExpr(E); 4623} 4624 4625template<typename Derived> 4626Sema::OwningExprResult 4627TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 4628 CXXFunctionalCastExpr *E) { 4629 TypeSourceInfo *OldT; 4630 TypeSourceInfo *NewT; 4631 { 4632 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4633 4634 OldT = E->getTypeInfoAsWritten(); 4635 NewT = getDerived().TransformType(OldT); 4636 if (!NewT) 4637 return SemaRef.ExprError(); 4638 } 4639 4640 OwningExprResult SubExpr 4641 = getDerived().TransformExpr(E->getSubExprAsWritten()); 4642 if (SubExpr.isInvalid()) 4643 return SemaRef.ExprError(); 4644 4645 if (!getDerived().AlwaysRebuild() && 4646 OldT == NewT && 4647 SubExpr.get() == E->getSubExpr()) 4648 return SemaRef.Owned(E->Retain()); 4649 4650 // FIXME: The end of the type's source range is wrong 4651 return getDerived().RebuildCXXFunctionalCastExpr( 4652 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 4653 NewT, 4654 /*FIXME:*/E->getSubExpr()->getLocStart(), 4655 move(SubExpr), 4656 E->getRParenLoc()); 4657} 4658 4659template<typename Derived> 4660Sema::OwningExprResult 4661TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) { 4662 if (E->isTypeOperand()) { 4663 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4664 4665 QualType T = getDerived().TransformType(E->getTypeOperand()); 4666 if (T.isNull()) 4667 return SemaRef.ExprError(); 4668 4669 if (!getDerived().AlwaysRebuild() && 4670 T == E->getTypeOperand()) 4671 return SemaRef.Owned(E->Retain()); 4672 4673 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4674 /*FIXME:*/E->getLocStart(), 4675 T, 4676 E->getLocEnd()); 4677 } 4678 4679 // We don't know whether the expression is potentially evaluated until 4680 // after we perform semantic analysis, so the expression is potentially 4681 // potentially evaluated. 4682 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4683 Action::PotentiallyPotentiallyEvaluated); 4684 4685 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 4686 if (SubExpr.isInvalid()) 4687 return SemaRef.ExprError(); 4688 4689 if (!getDerived().AlwaysRebuild() && 4690 SubExpr.get() == E->getExprOperand()) 4691 return SemaRef.Owned(E->Retain()); 4692 4693 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4694 /*FIXME:*/E->getLocStart(), 4695 move(SubExpr), 4696 E->getLocEnd()); 4697} 4698 4699template<typename Derived> 4700Sema::OwningExprResult 4701TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 4702 return SemaRef.Owned(E->Retain()); 4703} 4704 4705template<typename Derived> 4706Sema::OwningExprResult 4707TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 4708 CXXNullPtrLiteralExpr *E) { 4709 return SemaRef.Owned(E->Retain()); 4710} 4711 4712template<typename Derived> 4713Sema::OwningExprResult 4714TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) { 4715 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4716 4717 QualType T = getDerived().TransformType(E->getType()); 4718 if (T.isNull()) 4719 return SemaRef.ExprError(); 4720 4721 if (!getDerived().AlwaysRebuild() && 4722 T == E->getType()) 4723 return SemaRef.Owned(E->Retain()); 4724 4725 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T, E->isImplicit()); 4726} 4727 4728template<typename Derived> 4729Sema::OwningExprResult 4730TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) { 4731 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4732 if (SubExpr.isInvalid()) 4733 return SemaRef.ExprError(); 4734 4735 if (!getDerived().AlwaysRebuild() && 4736 SubExpr.get() == E->getSubExpr()) 4737 return SemaRef.Owned(E->Retain()); 4738 4739 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 4740} 4741 4742template<typename Derived> 4743Sema::OwningExprResult 4744TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 4745 ParmVarDecl *Param 4746 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(), 4747 E->getParam())); 4748 if (!Param) 4749 return SemaRef.ExprError(); 4750 4751 if (!getDerived().AlwaysRebuild() && 4752 Param == E->getParam()) 4753 return SemaRef.Owned(E->Retain()); 4754 4755 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param); 4756} 4757 4758template<typename Derived> 4759Sema::OwningExprResult 4760TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 4761 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4762 4763 QualType T = getDerived().TransformType(E->getType()); 4764 if (T.isNull()) 4765 return SemaRef.ExprError(); 4766 4767 if (!getDerived().AlwaysRebuild() && 4768 T == E->getType()) 4769 return SemaRef.Owned(E->Retain()); 4770 4771 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 4772 /*FIXME:*/E->getTypeBeginLoc(), 4773 T, 4774 E->getRParenLoc()); 4775} 4776 4777template<typename Derived> 4778Sema::OwningExprResult 4779TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) { 4780 // Transform the type that we're allocating 4781 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4782 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 4783 if (AllocType.isNull()) 4784 return SemaRef.ExprError(); 4785 4786 // Transform the size of the array we're allocating (if any). 4787 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 4788 if (ArraySize.isInvalid()) 4789 return SemaRef.ExprError(); 4790 4791 // Transform the placement arguments (if any). 4792 bool ArgumentChanged = false; 4793 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 4794 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 4795 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 4796 if (Arg.isInvalid()) 4797 return SemaRef.ExprError(); 4798 4799 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 4800 PlacementArgs.push_back(Arg.take()); 4801 } 4802 4803 // transform the constructor arguments (if any). 4804 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 4805 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 4806 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 4807 if (Arg.isInvalid()) 4808 return SemaRef.ExprError(); 4809 4810 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 4811 ConstructorArgs.push_back(Arg.take()); 4812 } 4813 4814 // Transform constructor, new operator, and delete operator. 4815 CXXConstructorDecl *Constructor = 0; 4816 if (E->getConstructor()) { 4817 Constructor = cast_or_null<CXXConstructorDecl>( 4818 getDerived().TransformDecl(E->getLocStart(), 4819 E->getConstructor())); 4820 if (!Constructor) 4821 return SemaRef.ExprError(); 4822 } 4823 4824 FunctionDecl *OperatorNew = 0; 4825 if (E->getOperatorNew()) { 4826 OperatorNew = cast_or_null<FunctionDecl>( 4827 getDerived().TransformDecl(E->getLocStart(), 4828 E->getOperatorNew())); 4829 if (!OperatorNew) 4830 return SemaRef.ExprError(); 4831 } 4832 4833 FunctionDecl *OperatorDelete = 0; 4834 if (E->getOperatorDelete()) { 4835 OperatorDelete = cast_or_null<FunctionDecl>( 4836 getDerived().TransformDecl(E->getLocStart(), 4837 E->getOperatorDelete())); 4838 if (!OperatorDelete) 4839 return SemaRef.ExprError(); 4840 } 4841 4842 if (!getDerived().AlwaysRebuild() && 4843 AllocType == E->getAllocatedType() && 4844 ArraySize.get() == E->getArraySize() && 4845 Constructor == E->getConstructor() && 4846 OperatorNew == E->getOperatorNew() && 4847 OperatorDelete == E->getOperatorDelete() && 4848 !ArgumentChanged) { 4849 // Mark any declarations we need as referenced. 4850 // FIXME: instantiation-specific. 4851 if (Constructor) 4852 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 4853 if (OperatorNew) 4854 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorNew); 4855 if (OperatorDelete) 4856 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 4857 return SemaRef.Owned(E->Retain()); 4858 } 4859 4860 if (!ArraySize.get()) { 4861 // If no array size was specified, but the new expression was 4862 // instantiated with an array type (e.g., "new T" where T is 4863 // instantiated with "int[4]"), extract the outer bound from the 4864 // array type as our array size. We do this with constant and 4865 // dependently-sized array types. 4866 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(AllocType); 4867 if (!ArrayT) { 4868 // Do nothing 4869 } else if (const ConstantArrayType *ConsArrayT 4870 = dyn_cast<ConstantArrayType>(ArrayT)) { 4871 ArraySize 4872 = SemaRef.Owned(new (SemaRef.Context) IntegerLiteral( 4873 ConsArrayT->getSize(), 4874 SemaRef.Context.getSizeType(), 4875 /*FIXME:*/E->getLocStart())); 4876 AllocType = ConsArrayT->getElementType(); 4877 } else if (const DependentSizedArrayType *DepArrayT 4878 = dyn_cast<DependentSizedArrayType>(ArrayT)) { 4879 if (DepArrayT->getSizeExpr()) { 4880 ArraySize = SemaRef.Owned(DepArrayT->getSizeExpr()->Retain()); 4881 AllocType = DepArrayT->getElementType(); 4882 } 4883 } 4884 } 4885 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 4886 E->isGlobalNew(), 4887 /*FIXME:*/E->getLocStart(), 4888 move_arg(PlacementArgs), 4889 /*FIXME:*/E->getLocStart(), 4890 E->isParenTypeId(), 4891 AllocType, 4892 /*FIXME:*/E->getLocStart(), 4893 /*FIXME:*/SourceRange(), 4894 move(ArraySize), 4895 /*FIXME:*/E->getLocStart(), 4896 move_arg(ConstructorArgs), 4897 E->getLocEnd()); 4898} 4899 4900template<typename Derived> 4901Sema::OwningExprResult 4902TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) { 4903 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 4904 if (Operand.isInvalid()) 4905 return SemaRef.ExprError(); 4906 4907 // Transform the delete operator, if known. 4908 FunctionDecl *OperatorDelete = 0; 4909 if (E->getOperatorDelete()) { 4910 OperatorDelete = cast_or_null<FunctionDecl>( 4911 getDerived().TransformDecl(E->getLocStart(), 4912 E->getOperatorDelete())); 4913 if (!OperatorDelete) 4914 return SemaRef.ExprError(); 4915 } 4916 4917 if (!getDerived().AlwaysRebuild() && 4918 Operand.get() == E->getArgument() && 4919 OperatorDelete == E->getOperatorDelete()) { 4920 // Mark any declarations we need as referenced. 4921 // FIXME: instantiation-specific. 4922 if (OperatorDelete) 4923 SemaRef.MarkDeclarationReferenced(E->getLocStart(), OperatorDelete); 4924 return SemaRef.Owned(E->Retain()); 4925 } 4926 4927 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 4928 E->isGlobalDelete(), 4929 E->isArrayForm(), 4930 move(Operand)); 4931} 4932 4933template<typename Derived> 4934Sema::OwningExprResult 4935TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 4936 CXXPseudoDestructorExpr *E) { 4937 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4938 if (Base.isInvalid()) 4939 return SemaRef.ExprError(); 4940 4941 Sema::TypeTy *ObjectTypePtr = 0; 4942 bool MayBePseudoDestructor = false; 4943 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4944 E->getOperatorLoc(), 4945 E->isArrow()? tok::arrow : tok::period, 4946 ObjectTypePtr, 4947 MayBePseudoDestructor); 4948 if (Base.isInvalid()) 4949 return SemaRef.ExprError(); 4950 4951 QualType ObjectType = QualType::getFromOpaquePtr(ObjectTypePtr); 4952 NestedNameSpecifier *Qualifier 4953 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4954 E->getQualifierRange(), 4955 ObjectType); 4956 if (E->getQualifier() && !Qualifier) 4957 return SemaRef.ExprError(); 4958 4959 PseudoDestructorTypeStorage Destroyed; 4960 if (E->getDestroyedTypeInfo()) { 4961 TypeSourceInfo *DestroyedTypeInfo 4962 = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType); 4963 if (!DestroyedTypeInfo) 4964 return SemaRef.ExprError(); 4965 Destroyed = DestroyedTypeInfo; 4966 } else if (ObjectType->isDependentType()) { 4967 // We aren't likely to be able to resolve the identifier down to a type 4968 // now anyway, so just retain the identifier. 4969 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(), 4970 E->getDestroyedTypeLoc()); 4971 } else { 4972 // Look for a destructor known with the given name. 4973 CXXScopeSpec SS; 4974 if (Qualifier) { 4975 SS.setScopeRep(Qualifier); 4976 SS.setRange(E->getQualifierRange()); 4977 } 4978 4979 Sema::TypeTy *T = SemaRef.getDestructorName(E->getTildeLoc(), 4980 *E->getDestroyedTypeIdentifier(), 4981 E->getDestroyedTypeLoc(), 4982 /*Scope=*/0, 4983 SS, ObjectTypePtr, 4984 false); 4985 if (!T) 4986 return SemaRef.ExprError(); 4987 4988 Destroyed 4989 = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T), 4990 E->getDestroyedTypeLoc()); 4991 } 4992 4993 TypeSourceInfo *ScopeTypeInfo = 0; 4994 if (E->getScopeTypeInfo()) { 4995 ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(), 4996 ObjectType); 4997 if (!ScopeTypeInfo) 4998 return SemaRef.ExprError(); 4999 } 5000 5001 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), 5002 E->getOperatorLoc(), 5003 E->isArrow(), 5004 Qualifier, 5005 E->getQualifierRange(), 5006 ScopeTypeInfo, 5007 E->getColonColonLoc(), 5008 E->getTildeLoc(), 5009 Destroyed); 5010} 5011 5012template<typename Derived> 5013Sema::OwningExprResult 5014TreeTransform<Derived>::TransformUnresolvedLookupExpr( 5015 UnresolvedLookupExpr *Old) { 5016 TemporaryBase Rebase(*this, Old->getNameLoc(), DeclarationName()); 5017 5018 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(), 5019 Sema::LookupOrdinaryName); 5020 5021 // Transform all the decls. 5022 for (UnresolvedLookupExpr::decls_iterator I = Old->decls_begin(), 5023 E = Old->decls_end(); I != E; ++I) { 5024 NamedDecl *InstD = static_cast<NamedDecl*>( 5025 getDerived().TransformDecl(Old->getNameLoc(), 5026 *I)); 5027 if (!InstD) { 5028 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 5029 // This can happen because of dependent hiding. 5030 if (isa<UsingShadowDecl>(*I)) 5031 continue; 5032 else 5033 return SemaRef.ExprError(); 5034 } 5035 5036 // Expand using declarations. 5037 if (isa<UsingDecl>(InstD)) { 5038 UsingDecl *UD = cast<UsingDecl>(InstD); 5039 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 5040 E = UD->shadow_end(); I != E; ++I) 5041 R.addDecl(*I); 5042 continue; 5043 } 5044 5045 R.addDecl(InstD); 5046 } 5047 5048 // Resolve a kind, but don't do any further analysis. If it's 5049 // ambiguous, the callee needs to deal with it. 5050 R.resolveKind(); 5051 5052 // Rebuild the nested-name qualifier, if present. 5053 CXXScopeSpec SS; 5054 NestedNameSpecifier *Qualifier = 0; 5055 if (Old->getQualifier()) { 5056 Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 5057 Old->getQualifierRange()); 5058 if (!Qualifier) 5059 return SemaRef.ExprError(); 5060 5061 SS.setScopeRep(Qualifier); 5062 SS.setRange(Old->getQualifierRange()); 5063 } 5064 5065 // If we have no template arguments, it's a normal declaration name. 5066 if (!Old->hasExplicitTemplateArgs()) 5067 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL()); 5068 5069 // If we have template arguments, rebuild them, then rebuild the 5070 // templateid expression. 5071 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc()); 5072 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) { 5073 TemplateArgumentLoc Loc; 5074 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc)) 5075 return SemaRef.ExprError(); 5076 TransArgs.addArgument(Loc); 5077 } 5078 5079 return getDerived().RebuildTemplateIdExpr(SS, R, Old->requiresADL(), 5080 TransArgs); 5081} 5082 5083template<typename Derived> 5084Sema::OwningExprResult 5085TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 5086 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 5087 5088 QualType T = getDerived().TransformType(E->getQueriedType()); 5089 if (T.isNull()) 5090 return SemaRef.ExprError(); 5091 5092 if (!getDerived().AlwaysRebuild() && 5093 T == E->getQueriedType()) 5094 return SemaRef.Owned(E->Retain()); 5095 5096 // FIXME: Bad location information 5097 SourceLocation FakeLParenLoc 5098 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 5099 5100 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 5101 E->getLocStart(), 5102 /*FIXME:*/FakeLParenLoc, 5103 T, 5104 E->getLocEnd()); 5105} 5106 5107template<typename Derived> 5108Sema::OwningExprResult 5109TreeTransform<Derived>::TransformDependentScopeDeclRefExpr( 5110 DependentScopeDeclRefExpr *E) { 5111 NestedNameSpecifier *NNS 5112 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5113 E->getQualifierRange()); 5114 if (!NNS) 5115 return SemaRef.ExprError(); 5116 5117 DeclarationName Name 5118 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); 5119 if (!Name) 5120 return SemaRef.ExprError(); 5121 5122 if (!E->hasExplicitTemplateArgs()) { 5123 if (!getDerived().AlwaysRebuild() && 5124 NNS == E->getQualifier() && 5125 Name == E->getDeclName()) 5126 return SemaRef.Owned(E->Retain()); 5127 5128 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 5129 E->getQualifierRange(), 5130 Name, E->getLocation(), 5131 /*TemplateArgs*/ 0); 5132 } 5133 5134 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 5135 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 5136 TemplateArgumentLoc Loc; 5137 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 5138 return SemaRef.ExprError(); 5139 TransArgs.addArgument(Loc); 5140 } 5141 5142 return getDerived().RebuildDependentScopeDeclRefExpr(NNS, 5143 E->getQualifierRange(), 5144 Name, E->getLocation(), 5145 &TransArgs); 5146} 5147 5148template<typename Derived> 5149Sema::OwningExprResult 5150TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) { 5151 // CXXConstructExprs are always implicit, so when we have a 5152 // 1-argument construction we just transform that argument. 5153 if (E->getNumArgs() == 1 || 5154 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(1)))) 5155 return getDerived().TransformExpr(E->getArg(0)); 5156 5157 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 5158 5159 QualType T = getDerived().TransformType(E->getType()); 5160 if (T.isNull()) 5161 return SemaRef.ExprError(); 5162 5163 CXXConstructorDecl *Constructor 5164 = cast_or_null<CXXConstructorDecl>( 5165 getDerived().TransformDecl(E->getLocStart(), 5166 E->getConstructor())); 5167 if (!Constructor) 5168 return SemaRef.ExprError(); 5169 5170 bool ArgumentChanged = false; 5171 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5172 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 5173 ArgEnd = E->arg_end(); 5174 Arg != ArgEnd; ++Arg) { 5175 if (getDerived().DropCallArgument(*Arg)) { 5176 ArgumentChanged = true; 5177 break; 5178 } 5179 5180 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 5181 if (TransArg.isInvalid()) 5182 return SemaRef.ExprError(); 5183 5184 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 5185 Args.push_back(TransArg.takeAs<Expr>()); 5186 } 5187 5188 if (!getDerived().AlwaysRebuild() && 5189 T == E->getType() && 5190 Constructor == E->getConstructor() && 5191 !ArgumentChanged) { 5192 // Mark the constructor as referenced. 5193 // FIXME: Instantiation-specific 5194 SemaRef.MarkDeclarationReferenced(E->getLocStart(), Constructor); 5195 return SemaRef.Owned(E->Retain()); 5196 } 5197 5198 return getDerived().RebuildCXXConstructExpr(T, /*FIXME:*/E->getLocStart(), 5199 Constructor, E->isElidable(), 5200 move_arg(Args)); 5201} 5202 5203/// \brief Transform a C++ temporary-binding expression. 5204/// 5205/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just 5206/// transform the subexpression and return that. 5207template<typename Derived> 5208Sema::OwningExprResult 5209TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 5210 return getDerived().TransformExpr(E->getSubExpr()); 5211} 5212 5213/// \brief Transform a C++ reference-binding expression. 5214/// 5215/// Since CXXBindReferenceExpr nodes are implicitly generated, we just 5216/// transform the subexpression and return that. 5217template<typename Derived> 5218Sema::OwningExprResult 5219TreeTransform<Derived>::TransformCXXBindReferenceExpr(CXXBindReferenceExpr *E) { 5220 return getDerived().TransformExpr(E->getSubExpr()); 5221} 5222 5223/// \brief Transform a C++ expression that contains temporaries that should 5224/// be destroyed after the expression is evaluated. 5225/// 5226/// Since CXXExprWithTemporaries nodes are implicitly generated, we 5227/// just transform the subexpression and return that. 5228template<typename Derived> 5229Sema::OwningExprResult 5230TreeTransform<Derived>::TransformCXXExprWithTemporaries( 5231 CXXExprWithTemporaries *E) { 5232 return getDerived().TransformExpr(E->getSubExpr()); 5233} 5234 5235template<typename Derived> 5236Sema::OwningExprResult 5237TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 5238 CXXTemporaryObjectExpr *E) { 5239 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 5240 QualType T = getDerived().TransformType(E->getType()); 5241 if (T.isNull()) 5242 return SemaRef.ExprError(); 5243 5244 CXXConstructorDecl *Constructor 5245 = cast_or_null<CXXConstructorDecl>( 5246 getDerived().TransformDecl(E->getLocStart(), 5247 E->getConstructor())); 5248 if (!Constructor) 5249 return SemaRef.ExprError(); 5250 5251 bool ArgumentChanged = false; 5252 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5253 Args.reserve(E->getNumArgs()); 5254 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 5255 ArgEnd = E->arg_end(); 5256 Arg != ArgEnd; ++Arg) { 5257 if (getDerived().DropCallArgument(*Arg)) { 5258 ArgumentChanged = true; 5259 break; 5260 } 5261 5262 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 5263 if (TransArg.isInvalid()) 5264 return SemaRef.ExprError(); 5265 5266 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 5267 Args.push_back((Expr *)TransArg.release()); 5268 } 5269 5270 if (!getDerived().AlwaysRebuild() && 5271 T == E->getType() && 5272 Constructor == E->getConstructor() && 5273 !ArgumentChanged) { 5274 // FIXME: Instantiation-specific 5275 SemaRef.MarkDeclarationReferenced(E->getTypeBeginLoc(), Constructor); 5276 return SemaRef.MaybeBindToTemporary(E->Retain()); 5277 } 5278 5279 // FIXME: Bogus location information 5280 SourceLocation CommaLoc; 5281 if (Args.size() > 1) { 5282 Expr *First = (Expr *)Args[0]; 5283 CommaLoc 5284 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 5285 } 5286 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 5287 T, 5288 /*FIXME:*/E->getTypeBeginLoc(), 5289 move_arg(Args), 5290 &CommaLoc, 5291 E->getLocEnd()); 5292} 5293 5294template<typename Derived> 5295Sema::OwningExprResult 5296TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 5297 CXXUnresolvedConstructExpr *E) { 5298 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 5299 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 5300 if (T.isNull()) 5301 return SemaRef.ExprError(); 5302 5303 bool ArgumentChanged = false; 5304 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5305 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 5306 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 5307 ArgEnd = E->arg_end(); 5308 Arg != ArgEnd; ++Arg) { 5309 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 5310 if (TransArg.isInvalid()) 5311 return SemaRef.ExprError(); 5312 5313 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 5314 FakeCommaLocs.push_back( 5315 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 5316 Args.push_back(TransArg.takeAs<Expr>()); 5317 } 5318 5319 if (!getDerived().AlwaysRebuild() && 5320 T == E->getTypeAsWritten() && 5321 !ArgumentChanged) 5322 return SemaRef.Owned(E->Retain()); 5323 5324 // FIXME: we're faking the locations of the commas 5325 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 5326 T, 5327 E->getLParenLoc(), 5328 move_arg(Args), 5329 FakeCommaLocs.data(), 5330 E->getRParenLoc()); 5331} 5332 5333template<typename Derived> 5334Sema::OwningExprResult 5335TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr( 5336 CXXDependentScopeMemberExpr *E) { 5337 // Transform the base of the expression. 5338 OwningExprResult Base(SemaRef, (Expr*) 0); 5339 Expr *OldBase; 5340 QualType BaseType; 5341 QualType ObjectType; 5342 if (!E->isImplicitAccess()) { 5343 OldBase = E->getBase(); 5344 Base = getDerived().TransformExpr(OldBase); 5345 if (Base.isInvalid()) 5346 return SemaRef.ExprError(); 5347 5348 // Start the member reference and compute the object's type. 5349 Sema::TypeTy *ObjectTy = 0; 5350 bool MayBePseudoDestructor = false; 5351 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 5352 E->getOperatorLoc(), 5353 E->isArrow()? tok::arrow : tok::period, 5354 ObjectTy, 5355 MayBePseudoDestructor); 5356 if (Base.isInvalid()) 5357 return SemaRef.ExprError(); 5358 5359 ObjectType = QualType::getFromOpaquePtr(ObjectTy); 5360 BaseType = ((Expr*) Base.get())->getType(); 5361 } else { 5362 OldBase = 0; 5363 BaseType = getDerived().TransformType(E->getBaseType()); 5364 ObjectType = BaseType->getAs<PointerType>()->getPointeeType(); 5365 } 5366 5367 // Transform the first part of the nested-name-specifier that qualifies 5368 // the member name. 5369 NamedDecl *FirstQualifierInScope 5370 = getDerived().TransformFirstQualifierInScope( 5371 E->getFirstQualifierFoundInScope(), 5372 E->getQualifierRange().getBegin()); 5373 5374 NestedNameSpecifier *Qualifier = 0; 5375 if (E->getQualifier()) { 5376 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 5377 E->getQualifierRange(), 5378 ObjectType, 5379 FirstQualifierInScope); 5380 if (!Qualifier) 5381 return SemaRef.ExprError(); 5382 } 5383 5384 DeclarationName Name 5385 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 5386 ObjectType); 5387 if (!Name) 5388 return SemaRef.ExprError(); 5389 5390 if (!E->hasExplicitTemplateArgs()) { 5391 // This is a reference to a member without an explicitly-specified 5392 // template argument list. Optimize for this common case. 5393 if (!getDerived().AlwaysRebuild() && 5394 Base.get() == OldBase && 5395 BaseType == E->getBaseType() && 5396 Qualifier == E->getQualifier() && 5397 Name == E->getMember() && 5398 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 5399 return SemaRef.Owned(E->Retain()); 5400 5401 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 5402 BaseType, 5403 E->isArrow(), 5404 E->getOperatorLoc(), 5405 Qualifier, 5406 E->getQualifierRange(), 5407 FirstQualifierInScope, 5408 Name, 5409 E->getMemberLoc(), 5410 /*TemplateArgs*/ 0); 5411 } 5412 5413 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc()); 5414 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 5415 TemplateArgumentLoc Loc; 5416 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc)) 5417 return SemaRef.ExprError(); 5418 TransArgs.addArgument(Loc); 5419 } 5420 5421 return getDerived().RebuildCXXDependentScopeMemberExpr(move(Base), 5422 BaseType, 5423 E->isArrow(), 5424 E->getOperatorLoc(), 5425 Qualifier, 5426 E->getQualifierRange(), 5427 FirstQualifierInScope, 5428 Name, 5429 E->getMemberLoc(), 5430 &TransArgs); 5431} 5432 5433template<typename Derived> 5434Sema::OwningExprResult 5435TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old) { 5436 // Transform the base of the expression. 5437 OwningExprResult Base(SemaRef, (Expr*) 0); 5438 QualType BaseType; 5439 if (!Old->isImplicitAccess()) { 5440 Base = getDerived().TransformExpr(Old->getBase()); 5441 if (Base.isInvalid()) 5442 return SemaRef.ExprError(); 5443 BaseType = ((Expr*) Base.get())->getType(); 5444 } else { 5445 BaseType = getDerived().TransformType(Old->getBaseType()); 5446 } 5447 5448 NestedNameSpecifier *Qualifier = 0; 5449 if (Old->getQualifier()) { 5450 Qualifier 5451 = getDerived().TransformNestedNameSpecifier(Old->getQualifier(), 5452 Old->getQualifierRange()); 5453 if (Qualifier == 0) 5454 return SemaRef.ExprError(); 5455 } 5456 5457 LookupResult R(SemaRef, Old->getMemberName(), Old->getMemberLoc(), 5458 Sema::LookupOrdinaryName); 5459 5460 // Transform all the decls. 5461 for (UnresolvedMemberExpr::decls_iterator I = Old->decls_begin(), 5462 E = Old->decls_end(); I != E; ++I) { 5463 NamedDecl *InstD = static_cast<NamedDecl*>( 5464 getDerived().TransformDecl(Old->getMemberLoc(), 5465 *I)); 5466 if (!InstD) { 5467 // Silently ignore these if a UsingShadowDecl instantiated to nothing. 5468 // This can happen because of dependent hiding. 5469 if (isa<UsingShadowDecl>(*I)) 5470 continue; 5471 else 5472 return SemaRef.ExprError(); 5473 } 5474 5475 // Expand using declarations. 5476 if (isa<UsingDecl>(InstD)) { 5477 UsingDecl *UD = cast<UsingDecl>(InstD); 5478 for (UsingDecl::shadow_iterator I = UD->shadow_begin(), 5479 E = UD->shadow_end(); I != E; ++I) 5480 R.addDecl(*I); 5481 continue; 5482 } 5483 5484 R.addDecl(InstD); 5485 } 5486 5487 R.resolveKind(); 5488 5489 TemplateArgumentListInfo TransArgs; 5490 if (Old->hasExplicitTemplateArgs()) { 5491 TransArgs.setLAngleLoc(Old->getLAngleLoc()); 5492 TransArgs.setRAngleLoc(Old->getRAngleLoc()); 5493 for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) { 5494 TemplateArgumentLoc Loc; 5495 if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], 5496 Loc)) 5497 return SemaRef.ExprError(); 5498 TransArgs.addArgument(Loc); 5499 } 5500 } 5501 5502 // FIXME: to do this check properly, we will need to preserve the 5503 // first-qualifier-in-scope here, just in case we had a dependent 5504 // base (and therefore couldn't do the check) and a 5505 // nested-name-qualifier (and therefore could do the lookup). 5506 NamedDecl *FirstQualifierInScope = 0; 5507 5508 return getDerived().RebuildUnresolvedMemberExpr(move(Base), 5509 BaseType, 5510 Old->getOperatorLoc(), 5511 Old->isArrow(), 5512 Qualifier, 5513 Old->getQualifierRange(), 5514 FirstQualifierInScope, 5515 R, 5516 (Old->hasExplicitTemplateArgs() 5517 ? &TransArgs : 0)); 5518} 5519 5520template<typename Derived> 5521Sema::OwningExprResult 5522TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) { 5523 return SemaRef.Owned(E->Retain()); 5524} 5525 5526template<typename Derived> 5527Sema::OwningExprResult 5528TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) { 5529 TypeSourceInfo *EncodedTypeInfo 5530 = getDerived().TransformType(E->getEncodedTypeSourceInfo()); 5531 if (!EncodedTypeInfo) 5532 return SemaRef.ExprError(); 5533 5534 if (!getDerived().AlwaysRebuild() && 5535 EncodedTypeInfo == E->getEncodedTypeSourceInfo()) 5536 return SemaRef.Owned(E->Retain()); 5537 5538 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 5539 EncodedTypeInfo, 5540 E->getRParenLoc()); 5541} 5542 5543template<typename Derived> 5544Sema::OwningExprResult 5545TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) { 5546 // Transform arguments. 5547 bool ArgChanged = false; 5548 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 5549 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 5550 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 5551 if (Arg.isInvalid()) 5552 return SemaRef.ExprError(); 5553 5554 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 5555 Args.push_back(Arg.takeAs<Expr>()); 5556 } 5557 5558 if (E->getReceiverKind() == ObjCMessageExpr::Class) { 5559 // Class message: transform the receiver type. 5560 TypeSourceInfo *ReceiverTypeInfo 5561 = getDerived().TransformType(E->getClassReceiverTypeInfo()); 5562 if (!ReceiverTypeInfo) 5563 return SemaRef.ExprError(); 5564 5565 // If nothing changed, just retain the existing message send. 5566 if (!getDerived().AlwaysRebuild() && 5567 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged) 5568 return SemaRef.Owned(E->Retain()); 5569 5570 // Build a new class message send. 5571 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo, 5572 E->getSelector(), 5573 E->getMethodDecl(), 5574 E->getLeftLoc(), 5575 move_arg(Args), 5576 E->getRightLoc()); 5577 } 5578 5579 // Instance message: transform the receiver 5580 assert(E->getReceiverKind() == ObjCMessageExpr::Instance && 5581 "Only class and instance messages may be instantiated"); 5582 OwningExprResult Receiver 5583 = getDerived().TransformExpr(E->getInstanceReceiver()); 5584 if (Receiver.isInvalid()) 5585 return SemaRef.ExprError(); 5586 5587 // If nothing changed, just retain the existing message send. 5588 if (!getDerived().AlwaysRebuild() && 5589 Receiver.get() == E->getInstanceReceiver() && !ArgChanged) 5590 return SemaRef.Owned(E->Retain()); 5591 5592 // Build a new instance message send. 5593 return getDerived().RebuildObjCMessageExpr(move(Receiver), 5594 E->getSelector(), 5595 E->getMethodDecl(), 5596 E->getLeftLoc(), 5597 move_arg(Args), 5598 E->getRightLoc()); 5599} 5600 5601template<typename Derived> 5602Sema::OwningExprResult 5603TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) { 5604 return SemaRef.Owned(E->Retain()); 5605} 5606 5607template<typename Derived> 5608Sema::OwningExprResult 5609TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) { 5610 ObjCProtocolDecl *Protocol 5611 = cast_or_null<ObjCProtocolDecl>( 5612 getDerived().TransformDecl(E->getLocStart(), 5613 E->getProtocol())); 5614 if (!Protocol) 5615 return SemaRef.ExprError(); 5616 5617 if (!getDerived().AlwaysRebuild() && 5618 Protocol == E->getProtocol()) 5619 return SemaRef.Owned(E->Retain()); 5620 5621 return getDerived().RebuildObjCProtocolExpr(Protocol, 5622 E->getAtLoc(), 5623 /*FIXME:*/E->getAtLoc(), 5624 /*FIXME:*/E->getAtLoc(), 5625 E->getRParenLoc()); 5626 5627} 5628 5629template<typename Derived> 5630Sema::OwningExprResult 5631TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) { 5632 // FIXME: Implement this! 5633 assert(false && "Cannot transform Objective-C expressions yet"); 5634 return SemaRef.Owned(E->Retain()); 5635} 5636 5637template<typename Derived> 5638Sema::OwningExprResult 5639TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 5640 // FIXME: Implement this! 5641 assert(false && "Cannot transform Objective-C expressions yet"); 5642 return SemaRef.Owned(E->Retain()); 5643} 5644 5645template<typename Derived> 5646Sema::OwningExprResult 5647TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 5648 ObjCImplicitSetterGetterRefExpr *E) { 5649 // FIXME: Implement this! 5650 assert(false && "Cannot transform Objective-C expressions yet"); 5651 return SemaRef.Owned(E->Retain()); 5652} 5653 5654template<typename Derived> 5655Sema::OwningExprResult 5656TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E) { 5657 // FIXME: Implement this! 5658 assert(false && "Cannot transform Objective-C expressions yet"); 5659 return SemaRef.Owned(E->Retain()); 5660} 5661 5662template<typename Derived> 5663Sema::OwningExprResult 5664TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) { 5665 // FIXME: Implement this! 5666 assert(false && "Cannot transform Objective-C expressions yet"); 5667 return SemaRef.Owned(E->Retain()); 5668} 5669 5670template<typename Derived> 5671Sema::OwningExprResult 5672TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) { 5673 bool ArgumentChanged = false; 5674 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 5675 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 5676 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 5677 if (SubExpr.isInvalid()) 5678 return SemaRef.ExprError(); 5679 5680 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 5681 SubExprs.push_back(SubExpr.takeAs<Expr>()); 5682 } 5683 5684 if (!getDerived().AlwaysRebuild() && 5685 !ArgumentChanged) 5686 return SemaRef.Owned(E->Retain()); 5687 5688 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 5689 move_arg(SubExprs), 5690 E->getRParenLoc()); 5691} 5692 5693template<typename Derived> 5694Sema::OwningExprResult 5695TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) { 5696 // FIXME: Implement this! 5697 assert(false && "Cannot transform block expressions yet"); 5698 return SemaRef.Owned(E->Retain()); 5699} 5700 5701template<typename Derived> 5702Sema::OwningExprResult 5703TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E) { 5704 // FIXME: Implement this! 5705 assert(false && "Cannot transform block-related expressions yet"); 5706 return SemaRef.Owned(E->Retain()); 5707} 5708 5709//===----------------------------------------------------------------------===// 5710// Type reconstruction 5711//===----------------------------------------------------------------------===// 5712 5713template<typename Derived> 5714QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 5715 SourceLocation Star) { 5716 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star, 5717 getDerived().getBaseEntity()); 5718} 5719 5720template<typename Derived> 5721QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 5722 SourceLocation Star) { 5723 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star, 5724 getDerived().getBaseEntity()); 5725} 5726 5727template<typename Derived> 5728QualType 5729TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 5730 bool WrittenAsLValue, 5731 SourceLocation Sigil) { 5732 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(), 5733 Sigil, getDerived().getBaseEntity()); 5734} 5735 5736template<typename Derived> 5737QualType 5738TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 5739 QualType ClassType, 5740 SourceLocation Sigil) { 5741 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 5742 Sigil, getDerived().getBaseEntity()); 5743} 5744 5745template<typename Derived> 5746QualType 5747TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 5748 ArrayType::ArraySizeModifier SizeMod, 5749 const llvm::APInt *Size, 5750 Expr *SizeExpr, 5751 unsigned IndexTypeQuals, 5752 SourceRange BracketsRange) { 5753 if (SizeExpr || !Size) 5754 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 5755 IndexTypeQuals, BracketsRange, 5756 getDerived().getBaseEntity()); 5757 5758 QualType Types[] = { 5759 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 5760 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 5761 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 5762 }; 5763 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 5764 QualType SizeType; 5765 for (unsigned I = 0; I != NumTypes; ++I) 5766 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 5767 SizeType = Types[I]; 5768 break; 5769 } 5770 5771 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 5772 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 5773 IndexTypeQuals, BracketsRange, 5774 getDerived().getBaseEntity()); 5775} 5776 5777template<typename Derived> 5778QualType 5779TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 5780 ArrayType::ArraySizeModifier SizeMod, 5781 const llvm::APInt &Size, 5782 unsigned IndexTypeQuals, 5783 SourceRange BracketsRange) { 5784 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 5785 IndexTypeQuals, BracketsRange); 5786} 5787 5788template<typename Derived> 5789QualType 5790TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 5791 ArrayType::ArraySizeModifier SizeMod, 5792 unsigned IndexTypeQuals, 5793 SourceRange BracketsRange) { 5794 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 5795 IndexTypeQuals, BracketsRange); 5796} 5797 5798template<typename Derived> 5799QualType 5800TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 5801 ArrayType::ArraySizeModifier SizeMod, 5802 ExprArg SizeExpr, 5803 unsigned IndexTypeQuals, 5804 SourceRange BracketsRange) { 5805 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5806 SizeExpr.takeAs<Expr>(), 5807 IndexTypeQuals, BracketsRange); 5808} 5809 5810template<typename Derived> 5811QualType 5812TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 5813 ArrayType::ArraySizeModifier SizeMod, 5814 ExprArg SizeExpr, 5815 unsigned IndexTypeQuals, 5816 SourceRange BracketsRange) { 5817 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5818 SizeExpr.takeAs<Expr>(), 5819 IndexTypeQuals, BracketsRange); 5820} 5821 5822template<typename Derived> 5823QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 5824 unsigned NumElements, 5825 bool IsAltiVec, bool IsPixel) { 5826 // FIXME: semantic checking! 5827 return SemaRef.Context.getVectorType(ElementType, NumElements, 5828 IsAltiVec, IsPixel); 5829} 5830 5831template<typename Derived> 5832QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 5833 unsigned NumElements, 5834 SourceLocation AttributeLoc) { 5835 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 5836 NumElements, true); 5837 IntegerLiteral *VectorSize 5838 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 5839 AttributeLoc); 5840 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 5841 AttributeLoc); 5842} 5843 5844template<typename Derived> 5845QualType 5846TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 5847 ExprArg SizeExpr, 5848 SourceLocation AttributeLoc) { 5849 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 5850} 5851 5852template<typename Derived> 5853QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 5854 QualType *ParamTypes, 5855 unsigned NumParamTypes, 5856 bool Variadic, 5857 unsigned Quals) { 5858 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 5859 Quals, 5860 getDerived().getBaseLocation(), 5861 getDerived().getBaseEntity()); 5862} 5863 5864template<typename Derived> 5865QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 5866 return SemaRef.Context.getFunctionNoProtoType(T); 5867} 5868 5869template<typename Derived> 5870QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(Decl *D) { 5871 assert(D && "no decl found"); 5872 if (D->isInvalidDecl()) return QualType(); 5873 5874 // FIXME: Doesn't account for ObjCInterfaceDecl! 5875 TypeDecl *Ty; 5876 if (isa<UsingDecl>(D)) { 5877 UsingDecl *Using = cast<UsingDecl>(D); 5878 assert(Using->isTypeName() && 5879 "UnresolvedUsingTypenameDecl transformed to non-typename using"); 5880 5881 // A valid resolved using typename decl points to exactly one type decl. 5882 assert(++Using->shadow_begin() == Using->shadow_end()); 5883 Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl()); 5884 5885 } else { 5886 assert(isa<UnresolvedUsingTypenameDecl>(D) && 5887 "UnresolvedUsingTypenameDecl transformed to non-using decl"); 5888 Ty = cast<UnresolvedUsingTypenameDecl>(D); 5889 } 5890 5891 return SemaRef.Context.getTypeDeclType(Ty); 5892} 5893 5894template<typename Derived> 5895QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 5896 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 5897} 5898 5899template<typename Derived> 5900QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 5901 return SemaRef.Context.getTypeOfType(Underlying); 5902} 5903 5904template<typename Derived> 5905QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 5906 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 5907} 5908 5909template<typename Derived> 5910QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 5911 TemplateName Template, 5912 SourceLocation TemplateNameLoc, 5913 const TemplateArgumentListInfo &TemplateArgs) { 5914 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs); 5915} 5916 5917template<typename Derived> 5918NestedNameSpecifier * 5919TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5920 SourceRange Range, 5921 IdentifierInfo &II, 5922 QualType ObjectType, 5923 NamedDecl *FirstQualifierInScope) { 5924 CXXScopeSpec SS; 5925 // FIXME: The source location information is all wrong. 5926 SS.setRange(Range); 5927 SS.setScopeRep(Prefix); 5928 return static_cast<NestedNameSpecifier *>( 5929 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 5930 Range.getEnd(), II, 5931 ObjectType, 5932 FirstQualifierInScope, 5933 false, false)); 5934} 5935 5936template<typename Derived> 5937NestedNameSpecifier * 5938TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5939 SourceRange Range, 5940 NamespaceDecl *NS) { 5941 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5942} 5943 5944template<typename Derived> 5945NestedNameSpecifier * 5946TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5947 SourceRange Range, 5948 bool TemplateKW, 5949 QualType T) { 5950 if (T->isDependentType() || T->isRecordType() || 5951 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5952 assert(!T.hasLocalQualifiers() && "Can't get cv-qualifiers here"); 5953 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5954 T.getTypePtr()); 5955 } 5956 5957 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5958 return 0; 5959} 5960 5961template<typename Derived> 5962TemplateName 5963TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5964 bool TemplateKW, 5965 TemplateDecl *Template) { 5966 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5967 Template); 5968} 5969 5970template<typename Derived> 5971TemplateName 5972TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5973 const IdentifierInfo &II, 5974 QualType ObjectType) { 5975 CXXScopeSpec SS; 5976 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5977 SS.setScopeRep(Qualifier); 5978 UnqualifiedId Name; 5979 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 5980 return getSema().ActOnDependentTemplateName( 5981 /*FIXME:*/getDerived().getBaseLocation(), 5982 SS, 5983 Name, 5984 ObjectType.getAsOpaquePtr(), 5985 /*EnteringContext=*/false) 5986 .template getAsVal<TemplateName>(); 5987} 5988 5989template<typename Derived> 5990TemplateName 5991TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5992 OverloadedOperatorKind Operator, 5993 QualType ObjectType) { 5994 CXXScopeSpec SS; 5995 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5996 SS.setScopeRep(Qualifier); 5997 UnqualifiedId Name; 5998 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 5999 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 6000 Operator, SymbolLocations); 6001 return getSema().ActOnDependentTemplateName( 6002 /*FIXME:*/getDerived().getBaseLocation(), 6003 SS, 6004 Name, 6005 ObjectType.getAsOpaquePtr(), 6006 /*EnteringContext=*/false) 6007 .template getAsVal<TemplateName>(); 6008} 6009 6010template<typename Derived> 6011Sema::OwningExprResult 6012TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 6013 SourceLocation OpLoc, 6014 ExprArg Callee, 6015 ExprArg First, 6016 ExprArg Second) { 6017 Expr *FirstExpr = (Expr *)First.get(); 6018 Expr *SecondExpr = (Expr *)Second.get(); 6019 Expr *CalleeExpr = ((Expr *)Callee.get())->IgnoreParenCasts(); 6020 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 6021 6022 // Determine whether this should be a builtin operation. 6023 if (Op == OO_Subscript) { 6024 if (!FirstExpr->getType()->isOverloadableType() && 6025 !SecondExpr->getType()->isOverloadableType()) 6026 return getSema().CreateBuiltinArraySubscriptExpr(move(First), 6027 CalleeExpr->getLocStart(), 6028 move(Second), OpLoc); 6029 } else if (Op == OO_Arrow) { 6030 // -> is never a builtin operation. 6031 return SemaRef.BuildOverloadedArrowExpr(0, move(First), OpLoc); 6032 } else if (SecondExpr == 0 || isPostIncDec) { 6033 if (!FirstExpr->getType()->isOverloadableType()) { 6034 // The argument is not of overloadable type, so try to create a 6035 // built-in unary operation. 6036 UnaryOperator::Opcode Opc 6037 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 6038 6039 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 6040 } 6041 } else { 6042 if (!FirstExpr->getType()->isOverloadableType() && 6043 !SecondExpr->getType()->isOverloadableType()) { 6044 // Neither of the arguments is an overloadable type, so try to 6045 // create a built-in binary operation. 6046 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 6047 OwningExprResult Result 6048 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 6049 if (Result.isInvalid()) 6050 return SemaRef.ExprError(); 6051 6052 First.release(); 6053 Second.release(); 6054 return move(Result); 6055 } 6056 } 6057 6058 // Compute the transformed set of functions (and function templates) to be 6059 // used during overload resolution. 6060 UnresolvedSet<16> Functions; 6061 6062 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(CalleeExpr)) { 6063 assert(ULE->requiresADL()); 6064 6065 // FIXME: Do we have to check 6066 // IsAcceptableNonMemberOperatorCandidate for each of these? 6067 Functions.append(ULE->decls_begin(), ULE->decls_end()); 6068 } else { 6069 Functions.addDecl(cast<DeclRefExpr>(CalleeExpr)->getDecl()); 6070 } 6071 6072 // Add any functions found via argument-dependent lookup. 6073 Expr *Args[2] = { FirstExpr, SecondExpr }; 6074 unsigned NumArgs = 1 + (SecondExpr != 0); 6075 6076 // Create the overloaded operator invocation for unary operators. 6077 if (NumArgs == 1 || isPostIncDec) { 6078 UnaryOperator::Opcode Opc 6079 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 6080 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 6081 } 6082 6083 if (Op == OO_Subscript) 6084 return SemaRef.CreateOverloadedArraySubscriptExpr(CalleeExpr->getLocStart(), 6085 OpLoc, 6086 move(First), 6087 move(Second)); 6088 6089 // Create the overloaded operator invocation for binary operators. 6090 BinaryOperator::Opcode Opc = 6091 BinaryOperator::getOverloadedOpcode(Op); 6092 OwningExprResult Result 6093 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 6094 if (Result.isInvalid()) 6095 return SemaRef.ExprError(); 6096 6097 First.release(); 6098 Second.release(); 6099 return move(Result); 6100} 6101 6102template<typename Derived> 6103Sema::OwningExprResult 6104TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(ExprArg Base, 6105 SourceLocation OperatorLoc, 6106 bool isArrow, 6107 NestedNameSpecifier *Qualifier, 6108 SourceRange QualifierRange, 6109 TypeSourceInfo *ScopeType, 6110 SourceLocation CCLoc, 6111 SourceLocation TildeLoc, 6112 PseudoDestructorTypeStorage Destroyed) { 6113 CXXScopeSpec SS; 6114 if (Qualifier) { 6115 SS.setRange(QualifierRange); 6116 SS.setScopeRep(Qualifier); 6117 } 6118 6119 Expr *BaseE = (Expr *)Base.get(); 6120 QualType BaseType = BaseE->getType(); 6121 if (BaseE->isTypeDependent() || Destroyed.getIdentifier() || 6122 (!isArrow && !BaseType->getAs<RecordType>()) || 6123 (isArrow && BaseType->getAs<PointerType>() && 6124 !BaseType->getAs<PointerType>()->getPointeeType() 6125 ->template getAs<RecordType>())){ 6126 // This pseudo-destructor expression is still a pseudo-destructor. 6127 return SemaRef.BuildPseudoDestructorExpr(move(Base), OperatorLoc, 6128 isArrow? tok::arrow : tok::period, 6129 SS, ScopeType, CCLoc, TildeLoc, 6130 Destroyed, 6131 /*FIXME?*/true); 6132 } 6133 6134 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo(); 6135 DeclarationName Name 6136 = SemaRef.Context.DeclarationNames.getCXXDestructorName( 6137 SemaRef.Context.getCanonicalType(DestroyedType->getType())); 6138 6139 // FIXME: the ScopeType should be tacked onto SS. 6140 6141 return getSema().BuildMemberReferenceExpr(move(Base), BaseType, 6142 OperatorLoc, isArrow, 6143 SS, /*FIXME: FirstQualifier*/ 0, 6144 Name, Destroyed.getLocation(), 6145 /*TemplateArgs*/ 0); 6146} 6147 6148} // end namespace clang 6149 6150#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 6151