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