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