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