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