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