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