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