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