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