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