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