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