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