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