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