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