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