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