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