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