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