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