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