TreeTransform.h revision 8a4386b3634065b96d08f94736bc1f953e385f50
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 "Sema.h" 17#include "clang/Sema/SemaDiagnostic.h" 18#include "clang/AST/Decl.h" 19#include "clang/AST/Expr.h" 20#include "clang/AST/ExprCXX.h" 21#include "clang/AST/ExprObjC.h" 22#include "clang/AST/Stmt.h" 23#include "clang/AST/StmtCXX.h" 24#include "clang/AST/StmtObjC.h" 25#include "clang/AST/TypeLocBuilder.h" 26#include "clang/Parse/Ownership.h" 27#include "clang/Parse/Designator.h" 28#include "clang/Lex/Preprocessor.h" 29#include "llvm/Support/ErrorHandling.h" 30#include <algorithm> 31 32namespace clang { 33 34/// \brief A semantic tree transformation that allows one to transform one 35/// abstract syntax tree into another. 36/// 37/// A new tree transformation is defined by creating a new subclass \c X of 38/// \c TreeTransform<X> and then overriding certain operations to provide 39/// behavior specific to that transformation. For example, template 40/// instantiation is implemented as a tree transformation where the 41/// transformation of TemplateTypeParmType nodes involves substituting the 42/// template arguments for their corresponding template parameters; a similar 43/// transformation is performed for non-type template parameters and 44/// template template parameters. 45/// 46/// This tree-transformation template uses static polymorphism to allow 47/// subclasses to customize any of its operations. Thus, a subclass can 48/// override any of the transformation or rebuild operators by providing an 49/// operation with the same signature as the default implementation. The 50/// overridding function should not be virtual. 51/// 52/// Semantic tree transformations are split into two stages, either of which 53/// can be replaced by a subclass. The "transform" step transforms an AST node 54/// or the parts of an AST node using the various transformation functions, 55/// then passes the pieces on to the "rebuild" step, which constructs a new AST 56/// node of the appropriate kind from the pieces. The default transformation 57/// routines recursively transform the operands to composite AST nodes (e.g., 58/// the pointee type of a PointerType node) and, if any of those operand nodes 59/// were changed by the transformation, invokes the rebuild operation to create 60/// a new AST node. 61/// 62/// Subclasses can customize the transformation at various levels. The 63/// most coarse-grained transformations involve replacing TransformType(), 64/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(), 65/// TransformTemplateName(), or TransformTemplateArgument() with entirely 66/// new implementations. 67/// 68/// For more fine-grained transformations, subclasses can replace any of the 69/// \c TransformXXX functions (where XXX is the name of an AST node, e.g., 70/// PointerType, StmtExpr) to alter the transformation. As mentioned previously, 71/// replacing TransformTemplateTypeParmType() allows template instantiation 72/// to substitute template arguments for their corresponding template 73/// parameters. Additionally, subclasses can override the \c RebuildXXX 74/// functions to control how AST nodes are rebuilt when their operands change. 75/// By default, \c TreeTransform will invoke semantic analysis to rebuild 76/// AST nodes. However, certain other tree transformations (e.g, cloning) may 77/// be able to use more efficient rebuild steps. 78/// 79/// There are a handful of other functions that can be overridden, allowing one 80/// to avoid traversing nodes that don't need any transformation 81/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their 82/// operands have not changed (\c AlwaysRebuild()), and customize the 83/// default locations and entity names used for type-checking 84/// (\c getBaseLocation(), \c getBaseEntity()). 85template<typename Derived> 86class TreeTransform { 87protected: 88 Sema &SemaRef; 89 90public: 91 typedef Sema::OwningStmtResult OwningStmtResult; 92 typedef Sema::OwningExprResult OwningExprResult; 93 typedef Sema::StmtArg StmtArg; 94 typedef Sema::ExprArg ExprArg; 95 typedef Sema::MultiExprArg MultiExprArg; 96 typedef Sema::MultiStmtArg MultiStmtArg; 97 98 /// \brief Initializes a new tree transformer. 99 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } 100 101 /// \brief Retrieves a reference to the derived class. 102 Derived &getDerived() { return static_cast<Derived&>(*this); } 103 104 /// \brief Retrieves a reference to the derived class. 105 const Derived &getDerived() const { 106 return static_cast<const Derived&>(*this); 107 } 108 109 /// \brief Retrieves a reference to the semantic analysis object used for 110 /// this tree transform. 111 Sema &getSema() const { return SemaRef; } 112 113 /// \brief Whether the transformation should always rebuild AST nodes, even 114 /// if none of the children have changed. 115 /// 116 /// Subclasses may override this function to specify when the transformation 117 /// should rebuild all AST nodes. 118 bool AlwaysRebuild() { return false; } 119 120 /// \brief Returns the location of the entity being transformed, if that 121 /// information was not available elsewhere in the AST. 122 /// 123 /// By default, returns no source-location information. Subclasses can 124 /// provide an alternative implementation that provides better location 125 /// information. 126 SourceLocation getBaseLocation() { return SourceLocation(); } 127 128 /// \brief Returns the name of the entity being transformed, if that 129 /// information was not available elsewhere in the AST. 130 /// 131 /// By default, returns an empty name. Subclasses can provide an alternative 132 /// implementation with a more precise name. 133 DeclarationName getBaseEntity() { return DeclarationName(); } 134 135 /// \brief Sets the "base" location and entity when that 136 /// information is known based on another transformation. 137 /// 138 /// By default, the source location and entity are ignored. Subclasses can 139 /// override this function to provide a customized implementation. 140 void setBase(SourceLocation Loc, DeclarationName Entity) { } 141 142 /// \brief RAII object that temporarily sets the base location and entity 143 /// used for reporting diagnostics in types. 144 class TemporaryBase { 145 TreeTransform &Self; 146 SourceLocation OldLocation; 147 DeclarationName OldEntity; 148 149 public: 150 TemporaryBase(TreeTransform &Self, SourceLocation Location, 151 DeclarationName Entity) : Self(Self) { 152 OldLocation = Self.getDerived().getBaseLocation(); 153 OldEntity = Self.getDerived().getBaseEntity(); 154 Self.getDerived().setBase(Location, Entity); 155 } 156 157 ~TemporaryBase() { 158 Self.getDerived().setBase(OldLocation, OldEntity); 159 } 160 }; 161 162 /// \brief Determine whether the given type \p T has already been 163 /// transformed. 164 /// 165 /// Subclasses can provide an alternative implementation of this routine 166 /// to short-circuit evaluation when it is known that a given type will 167 /// not change. For example, template instantiation need not traverse 168 /// non-dependent types. 169 bool AlreadyTransformed(QualType T) { 170 return T.isNull(); 171 } 172 173 /// \brief Transforms the given type into another type. 174 /// 175 /// By default, this routine transforms a type by creating a 176 /// DeclaratorInfo for it and delegating to the appropriate 177 /// function. This is expensive, but we don't mind, because 178 /// this method is deprecated anyway; all users should be 179 /// switched to storing DeclaratorInfos. 180 /// 181 /// \returns the transformed type. 182 QualType TransformType(QualType T); 183 184 /// \brief Transforms the given type-with-location into a new 185 /// type-with-location. 186 /// 187 /// By default, this routine transforms a type by delegating to the 188 /// appropriate TransformXXXType to build a new type. Subclasses 189 /// may override this function (to take over all type 190 /// transformations) or some set of the TransformXXXType functions 191 /// to alter the transformation. 192 DeclaratorInfo *TransformType(DeclaratorInfo *DI); 193 194 /// \brief Transform the given type-with-location into a new 195 /// type, collecting location information in the given builder 196 /// as necessary. 197 /// 198 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL); 199 200 /// \brief Transform the given statement. 201 /// 202 /// By default, this routine transforms a statement by delegating to the 203 /// appropriate TransformXXXStmt function to transform a specific kind of 204 /// statement or the TransformExpr() function to transform an expression. 205 /// Subclasses may override this function to transform statements using some 206 /// other mechanism. 207 /// 208 /// \returns the transformed statement. 209 OwningStmtResult TransformStmt(Stmt *S); 210 211 /// \brief Transform the given expression. 212 /// 213 /// By default, this routine transforms an expression by delegating to the 214 /// appropriate TransformXXXExpr function to build a new expression. 215 /// Subclasses may override this function to transform expressions using some 216 /// other mechanism. 217 /// 218 /// \returns the transformed expression. 219 OwningExprResult TransformExpr(Expr *E) { 220 return getDerived().TransformExpr(E, /*isAddressOfOperand=*/false); 221 } 222 223 /// \brief Transform the given expression. 224 /// 225 /// By default, this routine transforms an expression by delegating to the 226 /// appropriate TransformXXXExpr function to build a new expression. 227 /// Subclasses may override this function to transform expressions using some 228 /// other mechanism. 229 /// 230 /// \returns the transformed expression. 231 OwningExprResult TransformExpr(Expr *E, bool isAddressOfOperand); 232 233 /// \brief Transform the given declaration, which is referenced from a type 234 /// or expression. 235 /// 236 /// By default, acts as the identity function on declarations. Subclasses 237 /// may override this function to provide alternate behavior. 238 Decl *TransformDecl(Decl *D) { return D; } 239 240 /// \brief Transform the definition of the given declaration. 241 /// 242 /// By default, invokes TransformDecl() to transform the declaration. 243 /// Subclasses may override this function to provide alternate behavior. 244 Decl *TransformDefinition(Decl *D) { return getDerived().TransformDecl(D); } 245 246 /// \brief Transform the given declaration, which was the first part of a 247 /// nested-name-specifier in a member access expression. 248 /// 249 /// This specific declaration transformation only applies to the first 250 /// identifier in a nested-name-specifier of a member access expression, e.g., 251 /// the \c T in \c x->T::member 252 /// 253 /// By default, invokes TransformDecl() to transform the declaration. 254 /// Subclasses may override this function to provide alternate behavior. 255 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) { 256 return cast_or_null<NamedDecl>(getDerived().TransformDecl(D)); 257 } 258 259 /// \brief Transform the given nested-name-specifier. 260 /// 261 /// By default, transforms all of the types and declarations within the 262 /// nested-name-specifier. Subclasses may override this function to provide 263 /// alternate behavior. 264 NestedNameSpecifier *TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 265 SourceRange Range, 266 QualType ObjectType = QualType(), 267 NamedDecl *FirstQualifierInScope = 0); 268 269 /// \brief Transform the given declaration name. 270 /// 271 /// By default, transforms the types of conversion function, constructor, 272 /// and destructor names and then (if needed) rebuilds the declaration name. 273 /// Identifiers and selectors are returned unmodified. Sublcasses may 274 /// override this function to provide alternate behavior. 275 DeclarationName TransformDeclarationName(DeclarationName Name, 276 SourceLocation Loc, 277 QualType ObjectType = QualType()); 278 279 /// \brief Transform the given template name. 280 /// 281 /// By default, transforms the template name by transforming the declarations 282 /// and nested-name-specifiers that occur within the template name. 283 /// Subclasses may override this function to provide alternate behavior. 284 TemplateName TransformTemplateName(TemplateName Name, 285 QualType ObjectType = QualType()); 286 287 /// \brief Transform the given template argument. 288 /// 289 /// By default, this operation transforms the type, expression, or 290 /// declaration stored within the template argument and constructs a 291 /// new template argument from the transformed result. Subclasses may 292 /// override this function to provide alternate behavior. 293 /// 294 /// Returns true if there was an error. 295 bool TransformTemplateArgument(const TemplateArgumentLoc &Input, 296 TemplateArgumentLoc &Output); 297 298 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument. 299 void InventTemplateArgumentLoc(const TemplateArgument &Arg, 300 TemplateArgumentLoc &ArgLoc); 301 302 /// \brief Fakes up a DeclaratorInfo for a type. 303 DeclaratorInfo *InventDeclaratorInfo(QualType T) { 304 return SemaRef.Context.getTrivialDeclaratorInfo(T, 305 getDerived().getBaseLocation()); 306 } 307 308#define ABSTRACT_TYPELOC(CLASS, PARENT) 309#define TYPELOC(CLASS, PARENT) \ 310 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T); 311#include "clang/AST/TypeLocNodes.def" 312 313 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL); 314 315 QualType 316 TransformTemplateSpecializationType(const TemplateSpecializationType *T, 317 QualType ObjectType); 318 319 QualType 320 TransformTemplateSpecializationType(TypeLocBuilder &TLB, 321 TemplateSpecializationTypeLoc TL, 322 QualType ObjectType); 323 324 OwningStmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr); 325 326#define STMT(Node, Parent) \ 327 OwningStmtResult Transform##Node(Node *S); 328#define EXPR(Node, Parent) \ 329 OwningExprResult Transform##Node(Node *E, bool isAddressOfOperand); 330#define ABSTRACT_EXPR(Node, Parent) 331#include "clang/AST/StmtNodes.def" 332 333 /// \brief Build a new pointer type given its pointee type. 334 /// 335 /// By default, performs semantic analysis when building the pointer type. 336 /// Subclasses may override this routine to provide different behavior. 337 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil); 338 339 /// \brief Build a new block pointer type given its pointee type. 340 /// 341 /// By default, performs semantic analysis when building the block pointer 342 /// type. Subclasses may override this routine to provide different behavior. 343 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil); 344 345 /// \brief Build a new reference type given the type it references. 346 /// 347 /// By default, performs semantic analysis when building the 348 /// reference type. Subclasses may override this routine to provide 349 /// different behavior. 350 /// 351 /// \param LValue whether the type was written with an lvalue sigil 352 /// or an rvalue sigil. 353 QualType RebuildReferenceType(QualType ReferentType, 354 bool LValue, 355 SourceLocation Sigil); 356 357 /// \brief Build a new member pointer type given the pointee type and the 358 /// class type it refers into. 359 /// 360 /// By default, performs semantic analysis when building the member pointer 361 /// type. Subclasses may override this routine to provide different behavior. 362 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType, 363 SourceLocation Sigil); 364 365 /// \brief Build a new Objective C object pointer type. 366 QualType RebuildObjCObjectPointerType(QualType PointeeType, 367 SourceLocation Sigil); 368 369 /// \brief Build a new array type given the element type, size 370 /// modifier, size of the array (if known), size expression, and index type 371 /// qualifiers. 372 /// 373 /// By default, performs semantic analysis when building the array type. 374 /// Subclasses may override this routine to provide different behavior. 375 /// Also by default, all of the other Rebuild*Array 376 QualType RebuildArrayType(QualType ElementType, 377 ArrayType::ArraySizeModifier SizeMod, 378 const llvm::APInt *Size, 379 Expr *SizeExpr, 380 unsigned IndexTypeQuals, 381 SourceRange BracketsRange); 382 383 /// \brief Build a new constant array type given the element type, size 384 /// modifier, (known) size of the array, and index type qualifiers. 385 /// 386 /// By default, performs semantic analysis when building the array type. 387 /// Subclasses may override this routine to provide different behavior. 388 QualType RebuildConstantArrayType(QualType ElementType, 389 ArrayType::ArraySizeModifier SizeMod, 390 const llvm::APInt &Size, 391 unsigned IndexTypeQuals, 392 SourceRange BracketsRange); 393 394 /// \brief Build a new incomplete array type given the element type, size 395 /// modifier, and index type qualifiers. 396 /// 397 /// By default, performs semantic analysis when building the array type. 398 /// Subclasses may override this routine to provide different behavior. 399 QualType RebuildIncompleteArrayType(QualType ElementType, 400 ArrayType::ArraySizeModifier SizeMod, 401 unsigned IndexTypeQuals, 402 SourceRange BracketsRange); 403 404 /// \brief Build a new variable-length array type given the element type, 405 /// size modifier, size expression, and index type qualifiers. 406 /// 407 /// By default, performs semantic analysis when building the array type. 408 /// Subclasses may override this routine to provide different behavior. 409 QualType RebuildVariableArrayType(QualType ElementType, 410 ArrayType::ArraySizeModifier SizeMod, 411 ExprArg SizeExpr, 412 unsigned IndexTypeQuals, 413 SourceRange BracketsRange); 414 415 /// \brief Build a new dependent-sized array type given the element type, 416 /// size modifier, size expression, and index type qualifiers. 417 /// 418 /// By default, performs semantic analysis when building the array type. 419 /// Subclasses may override this routine to provide different behavior. 420 QualType RebuildDependentSizedArrayType(QualType ElementType, 421 ArrayType::ArraySizeModifier SizeMod, 422 ExprArg SizeExpr, 423 unsigned IndexTypeQuals, 424 SourceRange BracketsRange); 425 426 /// \brief Build a new vector type given the element type and 427 /// number of elements. 428 /// 429 /// By default, performs semantic analysis when building the vector type. 430 /// Subclasses may override this routine to provide different behavior. 431 QualType RebuildVectorType(QualType ElementType, unsigned NumElements); 432 433 /// \brief Build a new extended vector type given the element type and 434 /// number of elements. 435 /// 436 /// By default, performs semantic analysis when building the vector type. 437 /// Subclasses may override this routine to provide different behavior. 438 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements, 439 SourceLocation AttributeLoc); 440 441 /// \brief Build a new potentially dependently-sized extended vector type 442 /// given the element type and number of elements. 443 /// 444 /// By default, performs semantic analysis when building the vector type. 445 /// Subclasses may override this routine to provide different behavior. 446 QualType RebuildDependentSizedExtVectorType(QualType ElementType, 447 ExprArg SizeExpr, 448 SourceLocation AttributeLoc); 449 450 /// \brief Build a new function type. 451 /// 452 /// By default, performs semantic analysis when building the function type. 453 /// Subclasses may override this routine to provide different behavior. 454 QualType RebuildFunctionProtoType(QualType T, 455 QualType *ParamTypes, 456 unsigned NumParamTypes, 457 bool Variadic, unsigned Quals); 458 459 /// \brief Build a new unprototyped function type. 460 QualType RebuildFunctionNoProtoType(QualType ResultType); 461 462 /// \brief Build a new typedef type. 463 QualType RebuildTypedefType(TypedefDecl *Typedef) { 464 return SemaRef.Context.getTypeDeclType(Typedef); 465 } 466 467 /// \brief Build a new class/struct/union type. 468 QualType RebuildRecordType(RecordDecl *Record) { 469 return SemaRef.Context.getTypeDeclType(Record); 470 } 471 472 /// \brief Build a new Enum type. 473 QualType RebuildEnumType(EnumDecl *Enum) { 474 return SemaRef.Context.getTypeDeclType(Enum); 475 } 476 477 /// \brief Build a new elaborated type. 478 QualType RebuildElaboratedType(QualType T, ElaboratedType::TagKind Tag) { 479 return SemaRef.Context.getElaboratedType(T, Tag); 480 } 481 482 /// \brief Build a new typeof(expr) type. 483 /// 484 /// By default, performs semantic analysis when building the typeof type. 485 /// Subclasses may override this routine to provide different behavior. 486 QualType RebuildTypeOfExprType(ExprArg Underlying); 487 488 /// \brief Build a new typeof(type) type. 489 /// 490 /// By default, builds a new TypeOfType with the given underlying type. 491 QualType RebuildTypeOfType(QualType Underlying); 492 493 /// \brief Build a new C++0x decltype type. 494 /// 495 /// By default, performs semantic analysis when building the decltype type. 496 /// Subclasses may override this routine to provide different behavior. 497 QualType RebuildDecltypeType(ExprArg Underlying); 498 499 /// \brief Build a new template specialization type. 500 /// 501 /// By default, performs semantic analysis when building the template 502 /// specialization type. Subclasses may override this routine to provide 503 /// different behavior. 504 QualType RebuildTemplateSpecializationType(TemplateName Template, 505 SourceLocation TemplateLoc, 506 SourceLocation LAngleLoc, 507 const TemplateArgumentLoc *Args, 508 unsigned NumArgs, 509 SourceLocation RAngleLoc); 510 511 /// \brief Build a new qualified name type. 512 /// 513 /// By default, builds a new QualifiedNameType type from the 514 /// nested-name-specifier and the named type. Subclasses may override 515 /// this routine to provide different behavior. 516 QualType RebuildQualifiedNameType(NestedNameSpecifier *NNS, QualType Named) { 517 return SemaRef.Context.getQualifiedNameType(NNS, Named); 518 } 519 520 /// \brief Build a new typename type that refers to a template-id. 521 /// 522 /// By default, builds a new TypenameType type from the nested-name-specifier 523 /// and the given type. Subclasses may override this routine to provide 524 /// different behavior. 525 QualType RebuildTypenameType(NestedNameSpecifier *NNS, QualType T) { 526 if (NNS->isDependent()) 527 return SemaRef.Context.getTypenameType(NNS, 528 cast<TemplateSpecializationType>(T)); 529 530 return SemaRef.Context.getQualifiedNameType(NNS, T); 531 } 532 533 /// \brief Build a new typename type that refers to an identifier. 534 /// 535 /// By default, performs semantic analysis when building the typename type 536 /// (or qualified name type). Subclasses may override this routine to provide 537 /// different behavior. 538 QualType RebuildTypenameType(NestedNameSpecifier *NNS, 539 const IdentifierInfo *Id, 540 SourceRange SR) { 541 return SemaRef.CheckTypenameType(NNS, *Id, SR); 542 } 543 544 /// \brief Build a new nested-name-specifier given the prefix and an 545 /// identifier that names the next step in the nested-name-specifier. 546 /// 547 /// By default, performs semantic analysis when building the new 548 /// nested-name-specifier. Subclasses may override this routine to provide 549 /// different behavior. 550 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 551 SourceRange Range, 552 IdentifierInfo &II, 553 QualType ObjectType, 554 NamedDecl *FirstQualifierInScope); 555 556 /// \brief Build a new nested-name-specifier given the prefix and the 557 /// namespace named in the next step in the nested-name-specifier. 558 /// 559 /// By default, performs semantic analysis when building the new 560 /// nested-name-specifier. Subclasses may override this routine to provide 561 /// different behavior. 562 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 563 SourceRange Range, 564 NamespaceDecl *NS); 565 566 /// \brief Build a new nested-name-specifier given the prefix and the 567 /// type named in the next step in the nested-name-specifier. 568 /// 569 /// By default, performs semantic analysis when building the new 570 /// nested-name-specifier. Subclasses may override this routine to provide 571 /// different behavior. 572 NestedNameSpecifier *RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 573 SourceRange Range, 574 bool TemplateKW, 575 QualType T); 576 577 /// \brief Build a new template name given a nested name specifier, a flag 578 /// indicating whether the "template" keyword was provided, and the template 579 /// that the template name refers to. 580 /// 581 /// By default, builds the new template name directly. Subclasses may override 582 /// this routine to provide different behavior. 583 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 584 bool TemplateKW, 585 TemplateDecl *Template); 586 587 /// \brief Build a new template name given a nested name specifier, a flag 588 /// indicating whether the "template" keyword was provided, and a set of 589 /// overloaded function templates. 590 /// 591 /// By default, builds the new template name directly. Subclasses may override 592 /// this routine to provide different behavior. 593 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 594 bool TemplateKW, 595 OverloadedFunctionDecl *Ovl); 596 597 /// \brief Build a new template name given a nested name specifier and the 598 /// name that is referred to as a template. 599 /// 600 /// By default, performs semantic analysis to determine whether the name can 601 /// be resolved to a specific template, then builds the appropriate kind of 602 /// template name. Subclasses may override this routine to provide different 603 /// behavior. 604 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 605 const IdentifierInfo &II, 606 QualType ObjectType); 607 608 /// \brief Build a new template name given a nested name specifier and the 609 /// overloaded operator name that is referred to as a template. 610 /// 611 /// By default, performs semantic analysis to determine whether the name can 612 /// be resolved to a specific template, then builds the appropriate kind of 613 /// template name. Subclasses may override this routine to provide different 614 /// behavior. 615 TemplateName RebuildTemplateName(NestedNameSpecifier *Qualifier, 616 OverloadedOperatorKind Operator, 617 QualType ObjectType); 618 619 /// \brief Build a new compound statement. 620 /// 621 /// By default, performs semantic analysis to build the new statement. 622 /// Subclasses may override this routine to provide different behavior. 623 OwningStmtResult RebuildCompoundStmt(SourceLocation LBraceLoc, 624 MultiStmtArg Statements, 625 SourceLocation RBraceLoc, 626 bool IsStmtExpr) { 627 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, move(Statements), 628 IsStmtExpr); 629 } 630 631 /// \brief Build a new case statement. 632 /// 633 /// By default, performs semantic analysis to build the new statement. 634 /// Subclasses may override this routine to provide different behavior. 635 OwningStmtResult RebuildCaseStmt(SourceLocation CaseLoc, 636 ExprArg LHS, 637 SourceLocation EllipsisLoc, 638 ExprArg RHS, 639 SourceLocation ColonLoc) { 640 return getSema().ActOnCaseStmt(CaseLoc, move(LHS), EllipsisLoc, move(RHS), 641 ColonLoc); 642 } 643 644 /// \brief Attach the body to a new case statement. 645 /// 646 /// By default, performs semantic analysis to build the new statement. 647 /// Subclasses may override this routine to provide different behavior. 648 OwningStmtResult RebuildCaseStmtBody(StmtArg S, StmtArg Body) { 649 getSema().ActOnCaseStmtBody(S.get(), move(Body)); 650 return move(S); 651 } 652 653 /// \brief Build a new default statement. 654 /// 655 /// By default, performs semantic analysis to build the new statement. 656 /// Subclasses may override this routine to provide different behavior. 657 OwningStmtResult RebuildDefaultStmt(SourceLocation DefaultLoc, 658 SourceLocation ColonLoc, 659 StmtArg SubStmt) { 660 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, move(SubStmt), 661 /*CurScope=*/0); 662 } 663 664 /// \brief Build a new label statement. 665 /// 666 /// By default, performs semantic analysis to build the new statement. 667 /// Subclasses may override this routine to provide different behavior. 668 OwningStmtResult RebuildLabelStmt(SourceLocation IdentLoc, 669 IdentifierInfo *Id, 670 SourceLocation ColonLoc, 671 StmtArg SubStmt) { 672 return SemaRef.ActOnLabelStmt(IdentLoc, Id, ColonLoc, move(SubStmt)); 673 } 674 675 /// \brief Build a new "if" statement. 676 /// 677 /// By default, performs semantic analysis to build the new statement. 678 /// Subclasses may override this routine to provide different behavior. 679 OwningStmtResult RebuildIfStmt(SourceLocation IfLoc, Sema::FullExprArg Cond, 680 StmtArg Then, SourceLocation ElseLoc, 681 StmtArg Else) { 682 return getSema().ActOnIfStmt(IfLoc, Cond, move(Then), ElseLoc, move(Else)); 683 } 684 685 /// \brief Start building a new switch statement. 686 /// 687 /// By default, performs semantic analysis to build the new statement. 688 /// Subclasses may override this routine to provide different behavior. 689 OwningStmtResult RebuildSwitchStmtStart(ExprArg Cond) { 690 return getSema().ActOnStartOfSwitchStmt(move(Cond)); 691 } 692 693 /// \brief Attach the body to the switch statement. 694 /// 695 /// By default, performs semantic analysis to build the new statement. 696 /// Subclasses may override this routine to provide different behavior. 697 OwningStmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc, 698 StmtArg Switch, StmtArg Body) { 699 return getSema().ActOnFinishSwitchStmt(SwitchLoc, move(Switch), 700 move(Body)); 701 } 702 703 /// \brief Build a new while statement. 704 /// 705 /// By default, performs semantic analysis to build the new statement. 706 /// Subclasses may override this routine to provide different behavior. 707 OwningStmtResult RebuildWhileStmt(SourceLocation WhileLoc, 708 Sema::FullExprArg Cond, 709 StmtArg Body) { 710 return getSema().ActOnWhileStmt(WhileLoc, Cond, move(Body)); 711 } 712 713 /// \brief Build a new do-while statement. 714 /// 715 /// By default, performs semantic analysis to build the new statement. 716 /// Subclasses may override this routine to provide different behavior. 717 OwningStmtResult RebuildDoStmt(SourceLocation DoLoc, StmtArg Body, 718 SourceLocation WhileLoc, 719 SourceLocation LParenLoc, 720 ExprArg Cond, 721 SourceLocation RParenLoc) { 722 return getSema().ActOnDoStmt(DoLoc, move(Body), WhileLoc, LParenLoc, 723 move(Cond), RParenLoc); 724 } 725 726 /// \brief Build a new for statement. 727 /// 728 /// By default, performs semantic analysis to build the new statement. 729 /// Subclasses may override this routine to provide different behavior. 730 OwningStmtResult RebuildForStmt(SourceLocation ForLoc, 731 SourceLocation LParenLoc, 732 StmtArg Init, ExprArg Cond, ExprArg Inc, 733 SourceLocation RParenLoc, StmtArg Body) { 734 return getSema().ActOnForStmt(ForLoc, LParenLoc, move(Init), move(Cond), 735 move(Inc), RParenLoc, move(Body)); 736 } 737 738 /// \brief Build a new goto statement. 739 /// 740 /// By default, performs semantic analysis to build the new statement. 741 /// Subclasses may override this routine to provide different behavior. 742 OwningStmtResult RebuildGotoStmt(SourceLocation GotoLoc, 743 SourceLocation LabelLoc, 744 LabelStmt *Label) { 745 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label->getID()); 746 } 747 748 /// \brief Build a new indirect goto statement. 749 /// 750 /// By default, performs semantic analysis to build the new statement. 751 /// Subclasses may override this routine to provide different behavior. 752 OwningStmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc, 753 SourceLocation StarLoc, 754 ExprArg Target) { 755 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, move(Target)); 756 } 757 758 /// \brief Build a new return statement. 759 /// 760 /// By default, performs semantic analysis to build the new statement. 761 /// Subclasses may override this routine to provide different behavior. 762 OwningStmtResult RebuildReturnStmt(SourceLocation ReturnLoc, 763 ExprArg Result) { 764 765 return getSema().ActOnReturnStmt(ReturnLoc, move(Result)); 766 } 767 768 /// \brief Build a new declaration statement. 769 /// 770 /// By default, performs semantic analysis to build the new statement. 771 /// Subclasses may override this routine to provide different behavior. 772 OwningStmtResult RebuildDeclStmt(Decl **Decls, unsigned NumDecls, 773 SourceLocation StartLoc, 774 SourceLocation EndLoc) { 775 return getSema().Owned( 776 new (getSema().Context) DeclStmt( 777 DeclGroupRef::Create(getSema().Context, 778 Decls, NumDecls), 779 StartLoc, EndLoc)); 780 } 781 782 /// \brief Build a new C++ exception declaration. 783 /// 784 /// By default, performs semantic analysis to build the new decaration. 785 /// Subclasses may override this routine to provide different behavior. 786 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, QualType T, 787 DeclaratorInfo *Declarator, 788 IdentifierInfo *Name, 789 SourceLocation Loc, 790 SourceRange TypeRange) { 791 return getSema().BuildExceptionDeclaration(0, T, Declarator, Name, Loc, 792 TypeRange); 793 } 794 795 /// \brief Build a new C++ catch statement. 796 /// 797 /// By default, performs semantic analysis to build the new statement. 798 /// Subclasses may override this routine to provide different behavior. 799 OwningStmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc, 800 VarDecl *ExceptionDecl, 801 StmtArg Handler) { 802 return getSema().Owned( 803 new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl, 804 Handler.takeAs<Stmt>())); 805 } 806 807 /// \brief Build a new C++ try statement. 808 /// 809 /// By default, performs semantic analysis to build the new statement. 810 /// Subclasses may override this routine to provide different behavior. 811 OwningStmtResult RebuildCXXTryStmt(SourceLocation TryLoc, 812 StmtArg TryBlock, 813 MultiStmtArg Handlers) { 814 return getSema().ActOnCXXTryBlock(TryLoc, move(TryBlock), move(Handlers)); 815 } 816 817 /// \brief Build a new expression that references a declaration. 818 /// 819 /// By default, performs semantic analysis to build the new expression. 820 /// Subclasses may override this routine to provide different behavior. 821 OwningExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier, 822 SourceRange QualifierRange, 823 NamedDecl *ND, SourceLocation Loc, 824 bool isAddressOfOperand) { 825 CXXScopeSpec SS; 826 SS.setScopeRep(Qualifier); 827 SS.setRange(QualifierRange); 828 return getSema().BuildDeclarationNameExpr(Loc, ND, 829 /*FIXME:*/false, 830 &SS, 831 isAddressOfOperand); 832 } 833 834 /// \brief Build a new expression in parentheses. 835 /// 836 /// By default, performs semantic analysis to build the new expression. 837 /// Subclasses may override this routine to provide different behavior. 838 OwningExprResult RebuildParenExpr(ExprArg SubExpr, SourceLocation LParen, 839 SourceLocation RParen) { 840 return getSema().ActOnParenExpr(LParen, RParen, move(SubExpr)); 841 } 842 843 /// \brief Build a new pseudo-destructor expression. 844 /// 845 /// By default, performs semantic analysis to build the new expression. 846 /// Subclasses may override this routine to provide different behavior. 847 OwningExprResult RebuildCXXPseudoDestructorExpr(ExprArg Base, 848 SourceLocation OperatorLoc, 849 bool isArrow, 850 SourceLocation DestroyedTypeLoc, 851 QualType DestroyedType, 852 NestedNameSpecifier *Qualifier, 853 SourceRange QualifierRange) { 854 CXXScopeSpec SS; 855 if (Qualifier) { 856 SS.setRange(QualifierRange); 857 SS.setScopeRep(Qualifier); 858 } 859 860 DeclarationName Name 861 = SemaRef.Context.DeclarationNames.getCXXDestructorName( 862 SemaRef.Context.getCanonicalType(DestroyedType)); 863 864 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), 865 OperatorLoc, 866 isArrow? tok::arrow : tok::period, 867 DestroyedTypeLoc, 868 Name, 869 Sema::DeclPtrTy::make((Decl *)0), 870 &SS); 871 } 872 873 /// \brief Build a new unary operator expression. 874 /// 875 /// By default, performs semantic analysis to build the new expression. 876 /// Subclasses may override this routine to provide different behavior. 877 OwningExprResult RebuildUnaryOperator(SourceLocation OpLoc, 878 UnaryOperator::Opcode Opc, 879 ExprArg SubExpr) { 880 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(SubExpr)); 881 } 882 883 /// \brief Build a new sizeof or alignof expression with a type argument. 884 /// 885 /// By default, performs semantic analysis to build the new expression. 886 /// Subclasses may override this routine to provide different behavior. 887 OwningExprResult RebuildSizeOfAlignOf(DeclaratorInfo *DInfo, 888 SourceLocation OpLoc, 889 bool isSizeOf, SourceRange R) { 890 return getSema().CreateSizeOfAlignOfExpr(DInfo, OpLoc, isSizeOf, R); 891 } 892 893 /// \brief Build a new sizeof or alignof expression with an expression 894 /// argument. 895 /// 896 /// By default, performs semantic analysis to build the new expression. 897 /// Subclasses may override this routine to provide different behavior. 898 OwningExprResult RebuildSizeOfAlignOf(ExprArg SubExpr, SourceLocation OpLoc, 899 bool isSizeOf, SourceRange R) { 900 OwningExprResult Result 901 = getSema().CreateSizeOfAlignOfExpr((Expr *)SubExpr.get(), 902 OpLoc, isSizeOf, R); 903 if (Result.isInvalid()) 904 return getSema().ExprError(); 905 906 SubExpr.release(); 907 return move(Result); 908 } 909 910 /// \brief Build a new array subscript expression. 911 /// 912 /// By default, performs semantic analysis to build the new expression. 913 /// Subclasses may override this routine to provide different behavior. 914 OwningExprResult RebuildArraySubscriptExpr(ExprArg LHS, 915 SourceLocation LBracketLoc, 916 ExprArg RHS, 917 SourceLocation RBracketLoc) { 918 return getSema().ActOnArraySubscriptExpr(/*Scope=*/0, move(LHS), 919 LBracketLoc, move(RHS), 920 RBracketLoc); 921 } 922 923 /// \brief Build a new call expression. 924 /// 925 /// By default, performs semantic analysis to build the new expression. 926 /// Subclasses may override this routine to provide different behavior. 927 OwningExprResult RebuildCallExpr(ExprArg Callee, SourceLocation LParenLoc, 928 MultiExprArg Args, 929 SourceLocation *CommaLocs, 930 SourceLocation RParenLoc) { 931 return getSema().ActOnCallExpr(/*Scope=*/0, move(Callee), LParenLoc, 932 move(Args), CommaLocs, RParenLoc); 933 } 934 935 /// \brief Build a new member access expression. 936 /// 937 /// By default, performs semantic analysis to build the new expression. 938 /// Subclasses may override this routine to provide different behavior. 939 OwningExprResult RebuildMemberExpr(ExprArg Base, SourceLocation OpLoc, 940 bool isArrow, 941 NestedNameSpecifier *Qualifier, 942 SourceRange QualifierRange, 943 SourceLocation MemberLoc, 944 NamedDecl *Member, 945 bool HasExplicitTemplateArgs, 946 SourceLocation LAngleLoc, 947 const TemplateArgumentLoc *ExplicitTemplateArgs, 948 unsigned NumExplicitTemplateArgs, 949 SourceLocation RAngleLoc, 950 NamedDecl *FirstQualifierInScope) { 951 if (!Member->getDeclName()) { 952 // We have a reference to an unnamed field. 953 assert(!Qualifier && "Can't have an unnamed field with a qualifier!"); 954 955 MemberExpr *ME = 956 new (getSema().Context) MemberExpr(Base.takeAs<Expr>(), isArrow, 957 Member, MemberLoc, 958 cast<FieldDecl>(Member)->getType()); 959 return getSema().Owned(ME); 960 } 961 962 CXXScopeSpec SS; 963 if (Qualifier) { 964 SS.setRange(QualifierRange); 965 SS.setScopeRep(Qualifier); 966 } 967 968 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 969 isArrow? tok::arrow : tok::period, 970 MemberLoc, 971 Member->getDeclName(), 972 HasExplicitTemplateArgs, 973 LAngleLoc, 974 ExplicitTemplateArgs, 975 NumExplicitTemplateArgs, 976 RAngleLoc, 977 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0), 978 &SS, 979 FirstQualifierInScope); 980 } 981 982 /// \brief Build a new binary operator expression. 983 /// 984 /// By default, performs semantic analysis to build the new expression. 985 /// Subclasses may override this routine to provide different behavior. 986 OwningExprResult RebuildBinaryOperator(SourceLocation OpLoc, 987 BinaryOperator::Opcode Opc, 988 ExprArg LHS, ExprArg RHS) { 989 OwningExprResult Result 990 = getSema().CreateBuiltinBinOp(OpLoc, Opc, (Expr *)LHS.get(), 991 (Expr *)RHS.get()); 992 if (Result.isInvalid()) 993 return SemaRef.ExprError(); 994 995 LHS.release(); 996 RHS.release(); 997 return move(Result); 998 } 999 1000 /// \brief Build a new conditional operator expression. 1001 /// 1002 /// By default, performs semantic analysis to build the new expression. 1003 /// Subclasses may override this routine to provide different behavior. 1004 OwningExprResult RebuildConditionalOperator(ExprArg Cond, 1005 SourceLocation QuestionLoc, 1006 ExprArg LHS, 1007 SourceLocation ColonLoc, 1008 ExprArg RHS) { 1009 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, move(Cond), 1010 move(LHS), move(RHS)); 1011 } 1012 1013 /// \brief Build a new implicit cast expression. 1014 /// 1015 /// By default, builds a new implicit cast without any semantic analysis. 1016 /// Subclasses may override this routine to provide different behavior. 1017 OwningExprResult RebuildImplicitCastExpr(QualType T, CastExpr::CastKind Kind, 1018 ExprArg SubExpr, bool isLvalue) { 1019 ImplicitCastExpr *ICE 1020 = new (getSema().Context) ImplicitCastExpr(T, Kind, 1021 (Expr *)SubExpr.release(), 1022 isLvalue); 1023 return getSema().Owned(ICE); 1024 } 1025 1026 /// \brief Build a new C-style cast expression. 1027 /// 1028 /// By default, performs semantic analysis to build the new expression. 1029 /// Subclasses may override this routine to provide different behavior. 1030 OwningExprResult RebuildCStyleCaseExpr(SourceLocation LParenLoc, 1031 QualType ExplicitTy, 1032 SourceLocation RParenLoc, 1033 ExprArg SubExpr) { 1034 return getSema().ActOnCastExpr(/*Scope=*/0, 1035 LParenLoc, 1036 ExplicitTy.getAsOpaquePtr(), 1037 RParenLoc, 1038 move(SubExpr)); 1039 } 1040 1041 /// \brief Build a new compound literal expression. 1042 /// 1043 /// By default, performs semantic analysis to build the new expression. 1044 /// Subclasses may override this routine to provide different behavior. 1045 OwningExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc, 1046 QualType T, 1047 SourceLocation RParenLoc, 1048 ExprArg Init) { 1049 return getSema().ActOnCompoundLiteral(LParenLoc, T.getAsOpaquePtr(), 1050 RParenLoc, move(Init)); 1051 } 1052 1053 /// \brief Build a new extended vector element access expression. 1054 /// 1055 /// By default, performs semantic analysis to build the new expression. 1056 /// Subclasses may override this routine to provide different behavior. 1057 OwningExprResult RebuildExtVectorElementExpr(ExprArg Base, 1058 SourceLocation OpLoc, 1059 SourceLocation AccessorLoc, 1060 IdentifierInfo &Accessor) { 1061 return getSema().BuildMemberReferenceExpr(/*Scope=*/0, move(Base), OpLoc, 1062 tok::period, AccessorLoc, 1063 DeclarationName(&Accessor), 1064 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0)); 1065 } 1066 1067 /// \brief Build a new initializer list expression. 1068 /// 1069 /// By default, performs semantic analysis to build the new expression. 1070 /// Subclasses may override this routine to provide different behavior. 1071 OwningExprResult RebuildInitList(SourceLocation LBraceLoc, 1072 MultiExprArg Inits, 1073 SourceLocation RBraceLoc) { 1074 return SemaRef.ActOnInitList(LBraceLoc, move(Inits), RBraceLoc); 1075 } 1076 1077 /// \brief Build a new designated initializer expression. 1078 /// 1079 /// By default, performs semantic analysis to build the new expression. 1080 /// Subclasses may override this routine to provide different behavior. 1081 OwningExprResult RebuildDesignatedInitExpr(Designation &Desig, 1082 MultiExprArg ArrayExprs, 1083 SourceLocation EqualOrColonLoc, 1084 bool GNUSyntax, 1085 ExprArg Init) { 1086 OwningExprResult Result 1087 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax, 1088 move(Init)); 1089 if (Result.isInvalid()) 1090 return SemaRef.ExprError(); 1091 1092 ArrayExprs.release(); 1093 return move(Result); 1094 } 1095 1096 /// \brief Build a new value-initialized expression. 1097 /// 1098 /// By default, builds the implicit value initialization without performing 1099 /// any semantic analysis. Subclasses may override this routine to provide 1100 /// different behavior. 1101 OwningExprResult RebuildImplicitValueInitExpr(QualType T) { 1102 return SemaRef.Owned(new (SemaRef.Context) ImplicitValueInitExpr(T)); 1103 } 1104 1105 /// \brief Build a new \c va_arg expression. 1106 /// 1107 /// By default, performs semantic analysis to build the new expression. 1108 /// Subclasses may override this routine to provide different behavior. 1109 OwningExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc, ExprArg SubExpr, 1110 QualType T, SourceLocation RParenLoc) { 1111 return getSema().ActOnVAArg(BuiltinLoc, move(SubExpr), T.getAsOpaquePtr(), 1112 RParenLoc); 1113 } 1114 1115 /// \brief Build a new expression list in parentheses. 1116 /// 1117 /// By default, performs semantic analysis to build the new expression. 1118 /// Subclasses may override this routine to provide different behavior. 1119 OwningExprResult RebuildParenListExpr(SourceLocation LParenLoc, 1120 MultiExprArg SubExprs, 1121 SourceLocation RParenLoc) { 1122 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, move(SubExprs)); 1123 } 1124 1125 /// \brief Build a new address-of-label expression. 1126 /// 1127 /// By default, performs semantic analysis, using the name of the label 1128 /// rather than attempting to map the label statement itself. 1129 /// Subclasses may override this routine to provide different behavior. 1130 OwningExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc, 1131 SourceLocation LabelLoc, 1132 LabelStmt *Label) { 1133 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label->getID()); 1134 } 1135 1136 /// \brief Build a new GNU statement expression. 1137 /// 1138 /// By default, performs semantic analysis to build the new expression. 1139 /// Subclasses may override this routine to provide different behavior. 1140 OwningExprResult RebuildStmtExpr(SourceLocation LParenLoc, 1141 StmtArg SubStmt, 1142 SourceLocation RParenLoc) { 1143 return getSema().ActOnStmtExpr(LParenLoc, move(SubStmt), RParenLoc); 1144 } 1145 1146 /// \brief Build a new __builtin_types_compatible_p expression. 1147 /// 1148 /// By default, performs semantic analysis to build the new expression. 1149 /// Subclasses may override this routine to provide different behavior. 1150 OwningExprResult RebuildTypesCompatibleExpr(SourceLocation BuiltinLoc, 1151 QualType T1, QualType T2, 1152 SourceLocation RParenLoc) { 1153 return getSema().ActOnTypesCompatibleExpr(BuiltinLoc, 1154 T1.getAsOpaquePtr(), 1155 T2.getAsOpaquePtr(), 1156 RParenLoc); 1157 } 1158 1159 /// \brief Build a new __builtin_choose_expr expression. 1160 /// 1161 /// By default, performs semantic analysis to build the new expression. 1162 /// Subclasses may override this routine to provide different behavior. 1163 OwningExprResult RebuildChooseExpr(SourceLocation BuiltinLoc, 1164 ExprArg Cond, ExprArg LHS, ExprArg RHS, 1165 SourceLocation RParenLoc) { 1166 return SemaRef.ActOnChooseExpr(BuiltinLoc, 1167 move(Cond), move(LHS), move(RHS), 1168 RParenLoc); 1169 } 1170 1171 /// \brief Build a new overloaded operator call expression. 1172 /// 1173 /// By default, performs semantic analysis to build the new expression. 1174 /// The semantic analysis provides the behavior of template instantiation, 1175 /// copying with transformations that turn what looks like an overloaded 1176 /// operator call into a use of a builtin operator, performing 1177 /// argument-dependent lookup, etc. Subclasses may override this routine to 1178 /// provide different behavior. 1179 OwningExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 1180 SourceLocation OpLoc, 1181 ExprArg Callee, 1182 ExprArg First, 1183 ExprArg Second); 1184 1185 /// \brief Build a new C++ "named" cast expression, such as static_cast or 1186 /// reinterpret_cast. 1187 /// 1188 /// By default, this routine dispatches to one of the more-specific routines 1189 /// for a particular named case, e.g., RebuildCXXStaticCastExpr(). 1190 /// Subclasses may override this routine to provide different behavior. 1191 OwningExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc, 1192 Stmt::StmtClass Class, 1193 SourceLocation LAngleLoc, 1194 QualType T, 1195 SourceLocation RAngleLoc, 1196 SourceLocation LParenLoc, 1197 ExprArg SubExpr, 1198 SourceLocation RParenLoc) { 1199 switch (Class) { 1200 case Stmt::CXXStaticCastExprClass: 1201 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, T, 1202 RAngleLoc, LParenLoc, 1203 move(SubExpr), RParenLoc); 1204 1205 case Stmt::CXXDynamicCastExprClass: 1206 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, T, 1207 RAngleLoc, LParenLoc, 1208 move(SubExpr), RParenLoc); 1209 1210 case Stmt::CXXReinterpretCastExprClass: 1211 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, T, 1212 RAngleLoc, LParenLoc, 1213 move(SubExpr), 1214 RParenLoc); 1215 1216 case Stmt::CXXConstCastExprClass: 1217 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, T, 1218 RAngleLoc, LParenLoc, 1219 move(SubExpr), RParenLoc); 1220 1221 default: 1222 assert(false && "Invalid C++ named cast"); 1223 break; 1224 } 1225 1226 return getSema().ExprError(); 1227 } 1228 1229 /// \brief Build a new C++ static_cast expression. 1230 /// 1231 /// By default, performs semantic analysis to build the new expression. 1232 /// Subclasses may override this routine to provide different behavior. 1233 OwningExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc, 1234 SourceLocation LAngleLoc, 1235 QualType T, 1236 SourceLocation RAngleLoc, 1237 SourceLocation LParenLoc, 1238 ExprArg SubExpr, 1239 SourceLocation RParenLoc) { 1240 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_static_cast, 1241 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1242 LParenLoc, move(SubExpr), RParenLoc); 1243 } 1244 1245 /// \brief Build a new C++ dynamic_cast expression. 1246 /// 1247 /// By default, performs semantic analysis to build the new expression. 1248 /// Subclasses may override this routine to provide different behavior. 1249 OwningExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc, 1250 SourceLocation LAngleLoc, 1251 QualType T, 1252 SourceLocation RAngleLoc, 1253 SourceLocation LParenLoc, 1254 ExprArg SubExpr, 1255 SourceLocation RParenLoc) { 1256 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_dynamic_cast, 1257 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1258 LParenLoc, move(SubExpr), RParenLoc); 1259 } 1260 1261 /// \brief Build a new C++ reinterpret_cast expression. 1262 /// 1263 /// By default, performs semantic analysis to build the new expression. 1264 /// Subclasses may override this routine to provide different behavior. 1265 OwningExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc, 1266 SourceLocation LAngleLoc, 1267 QualType T, 1268 SourceLocation RAngleLoc, 1269 SourceLocation LParenLoc, 1270 ExprArg SubExpr, 1271 SourceLocation RParenLoc) { 1272 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_reinterpret_cast, 1273 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1274 LParenLoc, move(SubExpr), RParenLoc); 1275 } 1276 1277 /// \brief Build a new C++ const_cast expression. 1278 /// 1279 /// By default, performs semantic analysis to build the new expression. 1280 /// Subclasses may override this routine to provide different behavior. 1281 OwningExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc, 1282 SourceLocation LAngleLoc, 1283 QualType T, 1284 SourceLocation RAngleLoc, 1285 SourceLocation LParenLoc, 1286 ExprArg SubExpr, 1287 SourceLocation RParenLoc) { 1288 return getSema().ActOnCXXNamedCast(OpLoc, tok::kw_const_cast, 1289 LAngleLoc, T.getAsOpaquePtr(), RAngleLoc, 1290 LParenLoc, move(SubExpr), RParenLoc); 1291 } 1292 1293 /// \brief Build a new C++ functional-style cast expression. 1294 /// 1295 /// By default, performs semantic analysis to build the new expression. 1296 /// Subclasses may override this routine to provide different behavior. 1297 OwningExprResult RebuildCXXFunctionalCastExpr(SourceRange TypeRange, 1298 QualType T, 1299 SourceLocation LParenLoc, 1300 ExprArg SubExpr, 1301 SourceLocation RParenLoc) { 1302 void *Sub = SubExpr.takeAs<Expr>(); 1303 return getSema().ActOnCXXTypeConstructExpr(TypeRange, 1304 T.getAsOpaquePtr(), 1305 LParenLoc, 1306 Sema::MultiExprArg(getSema(), &Sub, 1), 1307 /*CommaLocs=*/0, 1308 RParenLoc); 1309 } 1310 1311 /// \brief Build a new C++ typeid(type) expression. 1312 /// 1313 /// By default, performs semantic analysis to build the new expression. 1314 /// Subclasses may override this routine to provide different behavior. 1315 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 1316 SourceLocation LParenLoc, 1317 QualType T, 1318 SourceLocation RParenLoc) { 1319 return getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, true, 1320 T.getAsOpaquePtr(), RParenLoc); 1321 } 1322 1323 /// \brief Build a new C++ typeid(expr) expression. 1324 /// 1325 /// By default, performs semantic analysis to build the new expression. 1326 /// Subclasses may override this routine to provide different behavior. 1327 OwningExprResult RebuildCXXTypeidExpr(SourceLocation TypeidLoc, 1328 SourceLocation LParenLoc, 1329 ExprArg Operand, 1330 SourceLocation RParenLoc) { 1331 OwningExprResult Result 1332 = getSema().ActOnCXXTypeid(TypeidLoc, LParenLoc, false, Operand.get(), 1333 RParenLoc); 1334 if (Result.isInvalid()) 1335 return getSema().ExprError(); 1336 1337 Operand.release(); // FIXME: since ActOnCXXTypeid silently took ownership 1338 return move(Result); 1339 } 1340 1341 /// \brief Build a new C++ "this" expression. 1342 /// 1343 /// By default, builds a new "this" expression without performing any 1344 /// semantic analysis. Subclasses may override this routine to provide 1345 /// different behavior. 1346 OwningExprResult RebuildCXXThisExpr(SourceLocation ThisLoc, 1347 QualType ThisType) { 1348 return getSema().Owned( 1349 new (getSema().Context) CXXThisExpr(ThisLoc, ThisType)); 1350 } 1351 1352 /// \brief Build a new C++ throw expression. 1353 /// 1354 /// By default, performs semantic analysis to build the new expression. 1355 /// Subclasses may override this routine to provide different behavior. 1356 OwningExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, ExprArg Sub) { 1357 return getSema().ActOnCXXThrow(ThrowLoc, move(Sub)); 1358 } 1359 1360 /// \brief Build a new C++ default-argument expression. 1361 /// 1362 /// By default, builds a new default-argument expression, which does not 1363 /// require any semantic analysis. Subclasses may override this routine to 1364 /// provide different behavior. 1365 OwningExprResult RebuildCXXDefaultArgExpr(ParmVarDecl *Param) { 1366 return getSema().Owned(CXXDefaultArgExpr::Create(getSema().Context, Param)); 1367 } 1368 1369 /// \brief Build a new C++ zero-initialization expression. 1370 /// 1371 /// By default, performs semantic analysis to build the new expression. 1372 /// Subclasses may override this routine to provide different behavior. 1373 OwningExprResult RebuildCXXZeroInitValueExpr(SourceLocation TypeStartLoc, 1374 SourceLocation LParenLoc, 1375 QualType T, 1376 SourceLocation RParenLoc) { 1377 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeStartLoc), 1378 T.getAsOpaquePtr(), LParenLoc, 1379 MultiExprArg(getSema(), 0, 0), 1380 0, RParenLoc); 1381 } 1382 1383 /// \brief Build a new C++ conditional declaration expression. 1384 /// 1385 /// By default, performs semantic analysis to build the new expression. 1386 /// Subclasses may override this routine to provide different behavior. 1387 OwningExprResult RebuildCXXConditionDeclExpr(SourceLocation StartLoc, 1388 SourceLocation EqLoc, 1389 VarDecl *Var) { 1390 return SemaRef.Owned(new (SemaRef.Context) CXXConditionDeclExpr(StartLoc, 1391 EqLoc, 1392 Var)); 1393 } 1394 1395 /// \brief Build a new C++ "new" expression. 1396 /// 1397 /// By default, performs semantic analysis to build the new expression. 1398 /// Subclasses may override this routine to provide different behavior. 1399 OwningExprResult RebuildCXXNewExpr(SourceLocation StartLoc, 1400 bool UseGlobal, 1401 SourceLocation PlacementLParen, 1402 MultiExprArg PlacementArgs, 1403 SourceLocation PlacementRParen, 1404 bool ParenTypeId, 1405 QualType AllocType, 1406 SourceLocation TypeLoc, 1407 SourceRange TypeRange, 1408 ExprArg ArraySize, 1409 SourceLocation ConstructorLParen, 1410 MultiExprArg ConstructorArgs, 1411 SourceLocation ConstructorRParen) { 1412 return getSema().BuildCXXNew(StartLoc, UseGlobal, 1413 PlacementLParen, 1414 move(PlacementArgs), 1415 PlacementRParen, 1416 ParenTypeId, 1417 AllocType, 1418 TypeLoc, 1419 TypeRange, 1420 move(ArraySize), 1421 ConstructorLParen, 1422 move(ConstructorArgs), 1423 ConstructorRParen); 1424 } 1425 1426 /// \brief Build a new C++ "delete" expression. 1427 /// 1428 /// By default, performs semantic analysis to build the new expression. 1429 /// Subclasses may override this routine to provide different behavior. 1430 OwningExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc, 1431 bool IsGlobalDelete, 1432 bool IsArrayForm, 1433 ExprArg Operand) { 1434 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm, 1435 move(Operand)); 1436 } 1437 1438 /// \brief Build a new unary type trait expression. 1439 /// 1440 /// By default, performs semantic analysis to build the new expression. 1441 /// Subclasses may override this routine to provide different behavior. 1442 OwningExprResult RebuildUnaryTypeTrait(UnaryTypeTrait Trait, 1443 SourceLocation StartLoc, 1444 SourceLocation LParenLoc, 1445 QualType T, 1446 SourceLocation RParenLoc) { 1447 return getSema().ActOnUnaryTypeTrait(Trait, StartLoc, LParenLoc, 1448 T.getAsOpaquePtr(), RParenLoc); 1449 } 1450 1451 /// \brief Build a new (previously unresolved) declaration reference 1452 /// expression. 1453 /// 1454 /// By default, performs semantic analysis to build the new expression. 1455 /// Subclasses may override this routine to provide different behavior. 1456 OwningExprResult RebuildUnresolvedDeclRefExpr(NestedNameSpecifier *NNS, 1457 SourceRange QualifierRange, 1458 DeclarationName Name, 1459 SourceLocation Location, 1460 bool IsAddressOfOperand) { 1461 CXXScopeSpec SS; 1462 SS.setRange(QualifierRange); 1463 SS.setScopeRep(NNS); 1464 return getSema().ActOnDeclarationNameExpr(/*Scope=*/0, 1465 Location, 1466 Name, 1467 /*Trailing lparen=*/false, 1468 &SS, 1469 IsAddressOfOperand); 1470 } 1471 1472 /// \brief Build a new template-id expression. 1473 /// 1474 /// By default, performs semantic analysis to build the new expression. 1475 /// Subclasses may override this routine to provide different behavior. 1476 OwningExprResult RebuildTemplateIdExpr(NestedNameSpecifier *Qualifier, 1477 SourceRange QualifierRange, 1478 TemplateName Template, 1479 SourceLocation TemplateLoc, 1480 SourceLocation LAngleLoc, 1481 TemplateArgumentLoc *TemplateArgs, 1482 unsigned NumTemplateArgs, 1483 SourceLocation RAngleLoc) { 1484 return getSema().BuildTemplateIdExpr(Qualifier, QualifierRange, 1485 Template, TemplateLoc, 1486 LAngleLoc, 1487 TemplateArgs, NumTemplateArgs, 1488 RAngleLoc); 1489 } 1490 1491 /// \brief Build a new object-construction expression. 1492 /// 1493 /// By default, performs semantic analysis to build the new expression. 1494 /// Subclasses may override this routine to provide different behavior. 1495 OwningExprResult RebuildCXXConstructExpr(QualType T, 1496 CXXConstructorDecl *Constructor, 1497 bool IsElidable, 1498 MultiExprArg Args) { 1499 return getSema().BuildCXXConstructExpr(/*FIXME:ConstructLoc*/ 1500 SourceLocation(), 1501 T, Constructor, IsElidable, 1502 move(Args)); 1503 } 1504 1505 /// \brief Build a new object-construction expression. 1506 /// 1507 /// By default, performs semantic analysis to build the new expression. 1508 /// Subclasses may override this routine to provide different behavior. 1509 OwningExprResult RebuildCXXTemporaryObjectExpr(SourceLocation TypeBeginLoc, 1510 QualType T, 1511 SourceLocation LParenLoc, 1512 MultiExprArg Args, 1513 SourceLocation *Commas, 1514 SourceLocation RParenLoc) { 1515 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc), 1516 T.getAsOpaquePtr(), 1517 LParenLoc, 1518 move(Args), 1519 Commas, 1520 RParenLoc); 1521 } 1522 1523 /// \brief Build a new object-construction expression. 1524 /// 1525 /// By default, performs semantic analysis to build the new expression. 1526 /// Subclasses may override this routine to provide different behavior. 1527 OwningExprResult RebuildCXXUnresolvedConstructExpr(SourceLocation TypeBeginLoc, 1528 QualType T, 1529 SourceLocation LParenLoc, 1530 MultiExprArg Args, 1531 SourceLocation *Commas, 1532 SourceLocation RParenLoc) { 1533 return getSema().ActOnCXXTypeConstructExpr(SourceRange(TypeBeginLoc, 1534 /*FIXME*/LParenLoc), 1535 T.getAsOpaquePtr(), 1536 LParenLoc, 1537 move(Args), 1538 Commas, 1539 RParenLoc); 1540 } 1541 1542 /// \brief Build a new member reference expression. 1543 /// 1544 /// By default, performs semantic analysis to build the new expression. 1545 /// Subclasses may override this routine to provide different behavior. 1546 OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, 1547 bool IsArrow, 1548 SourceLocation OperatorLoc, 1549 NestedNameSpecifier *Qualifier, 1550 SourceRange QualifierRange, 1551 DeclarationName Name, 1552 SourceLocation MemberLoc, 1553 NamedDecl *FirstQualifierInScope) { 1554 OwningExprResult Base = move(BaseE); 1555 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1556 1557 CXXScopeSpec SS; 1558 SS.setRange(QualifierRange); 1559 SS.setScopeRep(Qualifier); 1560 1561 return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, 1562 move(Base), OperatorLoc, OpKind, 1563 MemberLoc, 1564 Name, 1565 /*FIXME?*/Sema::DeclPtrTy::make((Decl*)0), 1566 &SS, 1567 FirstQualifierInScope); 1568 } 1569 1570 /// \brief Build a new member reference expression with explicit template 1571 /// arguments. 1572 /// 1573 /// By default, performs semantic analysis to build the new expression. 1574 /// Subclasses may override this routine to provide different behavior. 1575 OwningExprResult RebuildCXXUnresolvedMemberExpr(ExprArg BaseE, 1576 bool IsArrow, 1577 SourceLocation OperatorLoc, 1578 NestedNameSpecifier *Qualifier, 1579 SourceRange QualifierRange, 1580 TemplateName Template, 1581 SourceLocation TemplateNameLoc, 1582 NamedDecl *FirstQualifierInScope, 1583 SourceLocation LAngleLoc, 1584 const TemplateArgumentLoc *TemplateArgs, 1585 unsigned NumTemplateArgs, 1586 SourceLocation RAngleLoc) { 1587 OwningExprResult Base = move(BaseE); 1588 tok::TokenKind OpKind = IsArrow? tok::arrow : tok::period; 1589 1590 CXXScopeSpec SS; 1591 SS.setRange(QualifierRange); 1592 SS.setScopeRep(Qualifier); 1593 1594 // FIXME: We're going to end up looking up the template based on its name, 1595 // twice! Also, duplicates part of Sema::BuildMemberAccessExpr. 1596 DeclarationName Name; 1597 if (TemplateDecl *ActualTemplate = Template.getAsTemplateDecl()) 1598 Name = ActualTemplate->getDeclName(); 1599 else if (OverloadedFunctionDecl *Ovl 1600 = Template.getAsOverloadedFunctionDecl()) 1601 Name = Ovl->getDeclName(); 1602 else { 1603 DependentTemplateName *DTN = Template.getAsDependentTemplateName(); 1604 if (DTN->isIdentifier()) 1605 Name = DTN->getIdentifier(); 1606 else 1607 Name = SemaRef.Context.DeclarationNames.getCXXOperatorName( 1608 DTN->getOperator()); 1609 } 1610 return SemaRef.BuildMemberReferenceExpr(/*Scope=*/0, move(Base), 1611 OperatorLoc, OpKind, 1612 TemplateNameLoc, Name, true, 1613 LAngleLoc, TemplateArgs, 1614 NumTemplateArgs, RAngleLoc, 1615 Sema::DeclPtrTy(), &SS); 1616 } 1617 1618 /// \brief Build a new Objective-C @encode expression. 1619 /// 1620 /// By default, performs semantic analysis to build the new expression. 1621 /// Subclasses may override this routine to provide different behavior. 1622 OwningExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc, 1623 QualType T, 1624 SourceLocation RParenLoc) { 1625 return SemaRef.Owned(SemaRef.BuildObjCEncodeExpression(AtLoc, T, 1626 RParenLoc)); 1627 } 1628 1629 /// \brief Build a new Objective-C protocol expression. 1630 /// 1631 /// By default, performs semantic analysis to build the new expression. 1632 /// Subclasses may override this routine to provide different behavior. 1633 OwningExprResult RebuildObjCProtocolExpr(ObjCProtocolDecl *Protocol, 1634 SourceLocation AtLoc, 1635 SourceLocation ProtoLoc, 1636 SourceLocation LParenLoc, 1637 SourceLocation RParenLoc) { 1638 return SemaRef.Owned(SemaRef.ParseObjCProtocolExpression( 1639 Protocol->getIdentifier(), 1640 AtLoc, 1641 ProtoLoc, 1642 LParenLoc, 1643 RParenLoc)); 1644 } 1645 1646 /// \brief Build a new shuffle vector expression. 1647 /// 1648 /// By default, performs semantic analysis to build the new expression. 1649 /// Subclasses may override this routine to provide different behavior. 1650 OwningExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc, 1651 MultiExprArg SubExprs, 1652 SourceLocation RParenLoc) { 1653 // Find the declaration for __builtin_shufflevector 1654 const IdentifierInfo &Name 1655 = SemaRef.Context.Idents.get("__builtin_shufflevector"); 1656 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl(); 1657 DeclContext::lookup_result Lookup = TUDecl->lookup(DeclarationName(&Name)); 1658 assert(Lookup.first != Lookup.second && "No __builtin_shufflevector?"); 1659 1660 // Build a reference to the __builtin_shufflevector builtin 1661 FunctionDecl *Builtin = cast<FunctionDecl>(*Lookup.first); 1662 Expr *Callee 1663 = new (SemaRef.Context) DeclRefExpr(Builtin, Builtin->getType(), 1664 BuiltinLoc, false, false); 1665 SemaRef.UsualUnaryConversions(Callee); 1666 1667 // Build the CallExpr 1668 unsigned NumSubExprs = SubExprs.size(); 1669 Expr **Subs = (Expr **)SubExprs.release(); 1670 CallExpr *TheCall = new (SemaRef.Context) CallExpr(SemaRef.Context, Callee, 1671 Subs, NumSubExprs, 1672 Builtin->getResultType(), 1673 RParenLoc); 1674 OwningExprResult OwnedCall(SemaRef.Owned(TheCall)); 1675 1676 // Type-check the __builtin_shufflevector expression. 1677 OwningExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall); 1678 if (Result.isInvalid()) 1679 return SemaRef.ExprError(); 1680 1681 OwnedCall.release(); 1682 return move(Result); 1683 } 1684}; 1685 1686template<typename Derived> 1687Sema::OwningStmtResult TreeTransform<Derived>::TransformStmt(Stmt *S) { 1688 if (!S) 1689 return SemaRef.Owned(S); 1690 1691 switch (S->getStmtClass()) { 1692 case Stmt::NoStmtClass: break; 1693 1694 // Transform individual statement nodes 1695#define STMT(Node, Parent) \ 1696 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S)); 1697#define EXPR(Node, Parent) 1698#include "clang/AST/StmtNodes.def" 1699 1700 // Transform expressions by calling TransformExpr. 1701#define STMT(Node, Parent) 1702#define EXPR(Node, Parent) case Stmt::Node##Class: 1703#include "clang/AST/StmtNodes.def" 1704 { 1705 Sema::OwningExprResult E = getDerived().TransformExpr(cast<Expr>(S)); 1706 if (E.isInvalid()) 1707 return getSema().StmtError(); 1708 1709 return getSema().Owned(E.takeAs<Stmt>()); 1710 } 1711 } 1712 1713 return SemaRef.Owned(S->Retain()); 1714} 1715 1716 1717template<typename Derived> 1718Sema::OwningExprResult TreeTransform<Derived>::TransformExpr(Expr *E, 1719 bool isAddressOfOperand) { 1720 if (!E) 1721 return SemaRef.Owned(E); 1722 1723 switch (E->getStmtClass()) { 1724 case Stmt::NoStmtClass: break; 1725#define STMT(Node, Parent) case Stmt::Node##Class: break; 1726#define EXPR(Node, Parent) \ 1727 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E), \ 1728 isAddressOfOperand); 1729#include "clang/AST/StmtNodes.def" 1730 } 1731 1732 return SemaRef.Owned(E->Retain()); 1733} 1734 1735template<typename Derived> 1736NestedNameSpecifier * 1737TreeTransform<Derived>::TransformNestedNameSpecifier(NestedNameSpecifier *NNS, 1738 SourceRange Range, 1739 QualType ObjectType, 1740 NamedDecl *FirstQualifierInScope) { 1741 if (!NNS) 1742 return 0; 1743 1744 // Transform the prefix of this nested name specifier. 1745 NestedNameSpecifier *Prefix = NNS->getPrefix(); 1746 if (Prefix) { 1747 Prefix = getDerived().TransformNestedNameSpecifier(Prefix, Range, 1748 ObjectType, 1749 FirstQualifierInScope); 1750 if (!Prefix) 1751 return 0; 1752 1753 // Clear out the object type and the first qualifier in scope; they only 1754 // apply to the first element in the nested-name-specifier. 1755 ObjectType = QualType(); 1756 FirstQualifierInScope = 0; 1757 } 1758 1759 switch (NNS->getKind()) { 1760 case NestedNameSpecifier::Identifier: 1761 assert((Prefix || !ObjectType.isNull()) && 1762 "Identifier nested-name-specifier with no prefix or object type"); 1763 if (!getDerived().AlwaysRebuild() && Prefix == NNS->getPrefix() && 1764 ObjectType.isNull()) 1765 return NNS; 1766 1767 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1768 *NNS->getAsIdentifier(), 1769 ObjectType, 1770 FirstQualifierInScope); 1771 1772 case NestedNameSpecifier::Namespace: { 1773 NamespaceDecl *NS 1774 = cast_or_null<NamespaceDecl>( 1775 getDerived().TransformDecl(NNS->getAsNamespace())); 1776 if (!getDerived().AlwaysRebuild() && 1777 Prefix == NNS->getPrefix() && 1778 NS == NNS->getAsNamespace()) 1779 return NNS; 1780 1781 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, NS); 1782 } 1783 1784 case NestedNameSpecifier::Global: 1785 // There is no meaningful transformation that one could perform on the 1786 // global scope. 1787 return NNS; 1788 1789 case NestedNameSpecifier::TypeSpecWithTemplate: 1790 case NestedNameSpecifier::TypeSpec: { 1791 TemporaryBase Rebase(*this, Range.getBegin(), DeclarationName()); 1792 QualType T = getDerived().TransformType(QualType(NNS->getAsType(), 0)); 1793 if (T.isNull()) 1794 return 0; 1795 1796 if (!getDerived().AlwaysRebuild() && 1797 Prefix == NNS->getPrefix() && 1798 T == QualType(NNS->getAsType(), 0)) 1799 return NNS; 1800 1801 return getDerived().RebuildNestedNameSpecifier(Prefix, Range, 1802 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate, 1803 T); 1804 } 1805 } 1806 1807 // Required to silence a GCC warning 1808 return 0; 1809} 1810 1811template<typename Derived> 1812DeclarationName 1813TreeTransform<Derived>::TransformDeclarationName(DeclarationName Name, 1814 SourceLocation Loc, 1815 QualType ObjectType) { 1816 if (!Name) 1817 return Name; 1818 1819 switch (Name.getNameKind()) { 1820 case DeclarationName::Identifier: 1821 case DeclarationName::ObjCZeroArgSelector: 1822 case DeclarationName::ObjCOneArgSelector: 1823 case DeclarationName::ObjCMultiArgSelector: 1824 case DeclarationName::CXXOperatorName: 1825 case DeclarationName::CXXUsingDirective: 1826 return Name; 1827 1828 case DeclarationName::CXXConstructorName: 1829 case DeclarationName::CXXDestructorName: 1830 case DeclarationName::CXXConversionFunctionName: { 1831 TemporaryBase Rebase(*this, Loc, Name); 1832 QualType T; 1833 if (!ObjectType.isNull() && 1834 isa<TemplateSpecializationType>(Name.getCXXNameType())) { 1835 TemplateSpecializationType *SpecType 1836 = cast<TemplateSpecializationType>(Name.getCXXNameType()); 1837 T = TransformTemplateSpecializationType(SpecType, ObjectType); 1838 } else 1839 T = getDerived().TransformType(Name.getCXXNameType()); 1840 if (T.isNull()) 1841 return DeclarationName(); 1842 1843 return SemaRef.Context.DeclarationNames.getCXXSpecialName( 1844 Name.getNameKind(), 1845 SemaRef.Context.getCanonicalType(T)); 1846 } 1847 } 1848 1849 return DeclarationName(); 1850} 1851 1852template<typename Derived> 1853TemplateName 1854TreeTransform<Derived>::TransformTemplateName(TemplateName Name, 1855 QualType ObjectType) { 1856 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) { 1857 NestedNameSpecifier *NNS 1858 = getDerived().TransformNestedNameSpecifier(QTN->getQualifier(), 1859 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1860 if (!NNS) 1861 return TemplateName(); 1862 1863 if (TemplateDecl *Template = QTN->getTemplateDecl()) { 1864 TemplateDecl *TransTemplate 1865 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1866 if (!TransTemplate) 1867 return TemplateName(); 1868 1869 if (!getDerived().AlwaysRebuild() && 1870 NNS == QTN->getQualifier() && 1871 TransTemplate == Template) 1872 return Name; 1873 1874 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1875 TransTemplate); 1876 } 1877 1878 OverloadedFunctionDecl *Ovl = QTN->getOverloadedFunctionDecl(); 1879 assert(Ovl && "Not a template name or an overload set?"); 1880 OverloadedFunctionDecl *TransOvl 1881 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1882 if (!TransOvl) 1883 return TemplateName(); 1884 1885 if (!getDerived().AlwaysRebuild() && 1886 NNS == QTN->getQualifier() && 1887 TransOvl == Ovl) 1888 return Name; 1889 1890 return getDerived().RebuildTemplateName(NNS, QTN->hasTemplateKeyword(), 1891 TransOvl); 1892 } 1893 1894 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) { 1895 NestedNameSpecifier *NNS 1896 = getDerived().TransformNestedNameSpecifier(DTN->getQualifier(), 1897 /*FIXME:*/SourceRange(getDerived().getBaseLocation())); 1898 if (!NNS && DTN->getQualifier()) 1899 return TemplateName(); 1900 1901 if (!getDerived().AlwaysRebuild() && 1902 NNS == DTN->getQualifier() && 1903 ObjectType.isNull()) 1904 return Name; 1905 1906 if (DTN->isIdentifier()) 1907 return getDerived().RebuildTemplateName(NNS, *DTN->getIdentifier(), 1908 ObjectType); 1909 1910 return getDerived().RebuildTemplateName(NNS, DTN->getOperator(), 1911 ObjectType); 1912 } 1913 1914 if (TemplateDecl *Template = Name.getAsTemplateDecl()) { 1915 TemplateDecl *TransTemplate 1916 = cast_or_null<TemplateDecl>(getDerived().TransformDecl(Template)); 1917 if (!TransTemplate) 1918 return TemplateName(); 1919 1920 if (!getDerived().AlwaysRebuild() && 1921 TransTemplate == Template) 1922 return Name; 1923 1924 return TemplateName(TransTemplate); 1925 } 1926 1927 OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl(); 1928 assert(Ovl && "Not a template name or an overload set?"); 1929 OverloadedFunctionDecl *TransOvl 1930 = cast_or_null<OverloadedFunctionDecl>(getDerived().TransformDecl(Ovl)); 1931 if (!TransOvl) 1932 return TemplateName(); 1933 1934 if (!getDerived().AlwaysRebuild() && 1935 TransOvl == Ovl) 1936 return Name; 1937 1938 return TemplateName(TransOvl); 1939} 1940 1941template<typename Derived> 1942void TreeTransform<Derived>::InventTemplateArgumentLoc( 1943 const TemplateArgument &Arg, 1944 TemplateArgumentLoc &Output) { 1945 SourceLocation Loc = getDerived().getBaseLocation(); 1946 switch (Arg.getKind()) { 1947 case TemplateArgument::Null: 1948 llvm::llvm_unreachable("null template argument in TreeTransform"); 1949 break; 1950 1951 case TemplateArgument::Type: 1952 Output = TemplateArgumentLoc(Arg, 1953 SemaRef.Context.getTrivialDeclaratorInfo(Arg.getAsType(), Loc)); 1954 1955 break; 1956 1957 case TemplateArgument::Expression: 1958 Output = TemplateArgumentLoc(Arg, Arg.getAsExpr()); 1959 break; 1960 1961 case TemplateArgument::Declaration: 1962 case TemplateArgument::Integral: 1963 case TemplateArgument::Pack: 1964 Output = TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); 1965 break; 1966 } 1967} 1968 1969template<typename Derived> 1970bool TreeTransform<Derived>::TransformTemplateArgument( 1971 const TemplateArgumentLoc &Input, 1972 TemplateArgumentLoc &Output) { 1973 const TemplateArgument &Arg = Input.getArgument(); 1974 switch (Arg.getKind()) { 1975 case TemplateArgument::Null: 1976 case TemplateArgument::Integral: 1977 Output = Input; 1978 return false; 1979 1980 case TemplateArgument::Type: { 1981 DeclaratorInfo *DI = Input.getSourceDeclaratorInfo(); 1982 if (DI == NULL) 1983 DI = InventDeclaratorInfo(Input.getArgument().getAsType()); 1984 1985 DI = getDerived().TransformType(DI); 1986 if (!DI) return true; 1987 1988 Output = TemplateArgumentLoc(TemplateArgument(DI->getType()), DI); 1989 return false; 1990 } 1991 1992 case TemplateArgument::Declaration: { 1993 // FIXME: we should never have to transform one of these. 1994 DeclarationName Name; 1995 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) 1996 Name = ND->getDeclName(); 1997 TemporaryBase Rebase(*this, SourceLocation(), Name); 1998 Decl *D = getDerived().TransformDecl(Arg.getAsDecl()); 1999 if (!D) return true; 2000 2001 Expr *SourceExpr = Input.getSourceDeclExpression(); 2002 if (SourceExpr) { 2003 EnterExpressionEvaluationContext Unevaluated(getSema(), 2004 Action::Unevaluated); 2005 Sema::OwningExprResult E = getDerived().TransformExpr(SourceExpr); 2006 if (E.isInvalid()) 2007 SourceExpr = NULL; 2008 else { 2009 SourceExpr = E.takeAs<Expr>(); 2010 SourceExpr->Retain(); 2011 } 2012 } 2013 2014 Output = TemplateArgumentLoc(TemplateArgument(D), SourceExpr); 2015 return false; 2016 } 2017 2018 case TemplateArgument::Expression: { 2019 // Template argument expressions are not potentially evaluated. 2020 EnterExpressionEvaluationContext Unevaluated(getSema(), 2021 Action::Unevaluated); 2022 2023 Expr *InputExpr = Input.getSourceExpression(); 2024 if (!InputExpr) InputExpr = Input.getArgument().getAsExpr(); 2025 2026 Sema::OwningExprResult E 2027 = getDerived().TransformExpr(InputExpr); 2028 if (E.isInvalid()) return true; 2029 2030 Expr *ETaken = E.takeAs<Expr>(); 2031 ETaken->Retain(); 2032 Output = TemplateArgumentLoc(TemplateArgument(ETaken), ETaken); 2033 return false; 2034 } 2035 2036 case TemplateArgument::Pack: { 2037 llvm::SmallVector<TemplateArgument, 4> TransformedArgs; 2038 TransformedArgs.reserve(Arg.pack_size()); 2039 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 2040 AEnd = Arg.pack_end(); 2041 A != AEnd; ++A) { 2042 2043 // FIXME: preserve source information here when we start 2044 // caring about parameter packs. 2045 2046 TemplateArgumentLoc InputArg; 2047 TemplateArgumentLoc OutputArg; 2048 getDerived().InventTemplateArgumentLoc(*A, InputArg); 2049 if (getDerived().TransformTemplateArgument(InputArg, OutputArg)) 2050 return true; 2051 2052 TransformedArgs.push_back(OutputArg.getArgument()); 2053 } 2054 TemplateArgument Result; 2055 Result.setArgumentPack(TransformedArgs.data(), TransformedArgs.size(), 2056 true); 2057 Output = TemplateArgumentLoc(Result, Input.getLocInfo()); 2058 return false; 2059 } 2060 } 2061 2062 // Work around bogus GCC warning 2063 return true; 2064} 2065 2066//===----------------------------------------------------------------------===// 2067// Type transformation 2068//===----------------------------------------------------------------------===// 2069 2070template<typename Derived> 2071QualType TreeTransform<Derived>::TransformType(QualType T) { 2072 if (getDerived().AlreadyTransformed(T)) 2073 return T; 2074 2075 // Temporary workaround. All of these transformations should 2076 // eventually turn into transformations on TypeLocs. 2077 DeclaratorInfo *DI = getSema().Context.CreateDeclaratorInfo(T); 2078 DI->getTypeLoc().initialize(getDerived().getBaseLocation()); 2079 2080 DeclaratorInfo *NewDI = getDerived().TransformType(DI); 2081 2082 if (!NewDI) 2083 return QualType(); 2084 2085 return NewDI->getType(); 2086} 2087 2088template<typename Derived> 2089DeclaratorInfo *TreeTransform<Derived>::TransformType(DeclaratorInfo *DI) { 2090 if (getDerived().AlreadyTransformed(DI->getType())) 2091 return DI; 2092 2093 TypeLocBuilder TLB; 2094 2095 TypeLoc TL = DI->getTypeLoc(); 2096 TLB.reserve(TL.getFullDataSize()); 2097 2098 QualType Result = getDerived().TransformType(TLB, TL); 2099 if (Result.isNull()) 2100 return 0; 2101 2102 return TLB.getDeclaratorInfo(SemaRef.Context, Result); 2103} 2104 2105template<typename Derived> 2106QualType 2107TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) { 2108 switch (T.getTypeLocClass()) { 2109#define ABSTRACT_TYPELOC(CLASS, PARENT) 2110#define TYPELOC(CLASS, PARENT) \ 2111 case TypeLoc::CLASS: \ 2112 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T)); 2113#include "clang/AST/TypeLocNodes.def" 2114 } 2115 2116 llvm::llvm_unreachable("unhandled type loc!"); 2117 return QualType(); 2118} 2119 2120/// FIXME: By default, this routine adds type qualifiers only to types 2121/// that can have qualifiers, and silently suppresses those qualifiers 2122/// that are not permitted (e.g., qualifiers on reference or function 2123/// types). This is the right thing for template instantiation, but 2124/// probably not for other clients. 2125template<typename Derived> 2126QualType 2127TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB, 2128 QualifiedTypeLoc T) { 2129 Qualifiers Quals = T.getType().getQualifiers(); 2130 2131 QualType Result = getDerived().TransformType(TLB, T.getUnqualifiedLoc()); 2132 if (Result.isNull()) 2133 return QualType(); 2134 2135 // Silently suppress qualifiers if the result type can't be qualified. 2136 // FIXME: this is the right thing for template instantiation, but 2137 // probably not for other clients. 2138 if (Result->isFunctionType() || Result->isReferenceType()) 2139 return Result; 2140 2141 Result = SemaRef.Context.getQualifiedType(Result, Quals); 2142 2143 TLB.push<QualifiedTypeLoc>(Result); 2144 2145 // No location information to preserve. 2146 2147 return Result; 2148} 2149 2150template <class TyLoc> static inline 2151QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) { 2152 TyLoc NewT = TLB.push<TyLoc>(T.getType()); 2153 NewT.setNameLoc(T.getNameLoc()); 2154 return T.getType(); 2155} 2156 2157// Ugly metaprogramming macros because I couldn't be bothered to make 2158// the equivalent template version work. 2159#define TransformPointerLikeType(TypeClass) do { \ 2160 QualType PointeeType \ 2161 = getDerived().TransformType(TLB, TL.getPointeeLoc()); \ 2162 if (PointeeType.isNull()) \ 2163 return QualType(); \ 2164 \ 2165 QualType Result = TL.getType(); \ 2166 if (getDerived().AlwaysRebuild() || \ 2167 PointeeType != TL.getPointeeLoc().getType()) { \ 2168 Result = getDerived().Rebuild##TypeClass(PointeeType, \ 2169 TL.getSigilLoc()); \ 2170 if (Result.isNull()) \ 2171 return QualType(); \ 2172 } \ 2173 \ 2174 TypeClass##Loc NewT = TLB.push<TypeClass##Loc>(Result); \ 2175 NewT.setSigilLoc(TL.getSigilLoc()); \ 2176 \ 2177 return Result; \ 2178} while(0) 2179 2180template<typename Derived> 2181QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB, 2182 BuiltinTypeLoc T) { 2183 return TransformTypeSpecType(TLB, T); 2184} 2185 2186template<typename Derived> 2187QualType 2188TreeTransform<Derived>::TransformFixedWidthIntType(TypeLocBuilder &TLB, 2189 FixedWidthIntTypeLoc T) { 2190 return TransformTypeSpecType(TLB, T); 2191} 2192 2193template<typename Derived> 2194QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB, 2195 ComplexTypeLoc T) { 2196 // FIXME: recurse? 2197 return TransformTypeSpecType(TLB, T); 2198} 2199 2200template<typename Derived> 2201QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB, 2202 PointerTypeLoc TL) { 2203 TransformPointerLikeType(PointerType); 2204} 2205 2206template<typename Derived> 2207QualType 2208TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB, 2209 BlockPointerTypeLoc TL) { 2210 TransformPointerLikeType(BlockPointerType); 2211} 2212 2213/// Transforms a reference type. Note that somewhat paradoxically we 2214/// don't care whether the type itself is an l-value type or an r-value 2215/// type; we only care if the type was *written* as an l-value type 2216/// or an r-value type. 2217template<typename Derived> 2218QualType 2219TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB, 2220 ReferenceTypeLoc TL) { 2221 const ReferenceType *T = TL.getTypePtr(); 2222 2223 // Note that this works with the pointee-as-written. 2224 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2225 if (PointeeType.isNull()) 2226 return QualType(); 2227 2228 QualType Result = TL.getType(); 2229 if (getDerived().AlwaysRebuild() || 2230 PointeeType != T->getPointeeTypeAsWritten()) { 2231 Result = getDerived().RebuildReferenceType(PointeeType, 2232 T->isSpelledAsLValue(), 2233 TL.getSigilLoc()); 2234 if (Result.isNull()) 2235 return QualType(); 2236 } 2237 2238 // r-value references can be rebuilt as l-value references. 2239 ReferenceTypeLoc NewTL; 2240 if (isa<LValueReferenceType>(Result)) 2241 NewTL = TLB.push<LValueReferenceTypeLoc>(Result); 2242 else 2243 NewTL = TLB.push<RValueReferenceTypeLoc>(Result); 2244 NewTL.setSigilLoc(TL.getSigilLoc()); 2245 2246 return Result; 2247} 2248 2249template<typename Derived> 2250QualType 2251TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB, 2252 LValueReferenceTypeLoc TL) { 2253 return TransformReferenceType(TLB, TL); 2254} 2255 2256template<typename Derived> 2257QualType 2258TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB, 2259 RValueReferenceTypeLoc TL) { 2260 return TransformReferenceType(TLB, TL); 2261} 2262 2263template<typename Derived> 2264QualType 2265TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB, 2266 MemberPointerTypeLoc TL) { 2267 MemberPointerType *T = TL.getTypePtr(); 2268 2269 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc()); 2270 if (PointeeType.isNull()) 2271 return QualType(); 2272 2273 // TODO: preserve source information for this. 2274 QualType ClassType 2275 = getDerived().TransformType(QualType(T->getClass(), 0)); 2276 if (ClassType.isNull()) 2277 return QualType(); 2278 2279 QualType Result = TL.getType(); 2280 if (getDerived().AlwaysRebuild() || 2281 PointeeType != T->getPointeeType() || 2282 ClassType != QualType(T->getClass(), 0)) { 2283 Result = getDerived().RebuildMemberPointerType(PointeeType, ClassType, 2284 TL.getStarLoc()); 2285 if (Result.isNull()) 2286 return QualType(); 2287 } 2288 2289 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(Result); 2290 NewTL.setSigilLoc(TL.getSigilLoc()); 2291 2292 return Result; 2293} 2294 2295template<typename Derived> 2296QualType 2297TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB, 2298 ConstantArrayTypeLoc TL) { 2299 ConstantArrayType *T = TL.getTypePtr(); 2300 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2301 if (ElementType.isNull()) 2302 return QualType(); 2303 2304 QualType Result = TL.getType(); 2305 if (getDerived().AlwaysRebuild() || 2306 ElementType != T->getElementType()) { 2307 Result = getDerived().RebuildConstantArrayType(ElementType, 2308 T->getSizeModifier(), 2309 T->getSize(), 2310 T->getIndexTypeCVRQualifiers(), 2311 TL.getBracketsRange()); 2312 if (Result.isNull()) 2313 return QualType(); 2314 } 2315 2316 ConstantArrayTypeLoc NewTL = TLB.push<ConstantArrayTypeLoc>(Result); 2317 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2318 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2319 2320 Expr *Size = TL.getSizeExpr(); 2321 if (Size) { 2322 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2323 Size = getDerived().TransformExpr(Size).template takeAs<Expr>(); 2324 } 2325 NewTL.setSizeExpr(Size); 2326 2327 return Result; 2328} 2329 2330template<typename Derived> 2331QualType TreeTransform<Derived>::TransformIncompleteArrayType( 2332 TypeLocBuilder &TLB, 2333 IncompleteArrayTypeLoc TL) { 2334 IncompleteArrayType *T = TL.getTypePtr(); 2335 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2336 if (ElementType.isNull()) 2337 return QualType(); 2338 2339 QualType Result = TL.getType(); 2340 if (getDerived().AlwaysRebuild() || 2341 ElementType != T->getElementType()) { 2342 Result = getDerived().RebuildIncompleteArrayType(ElementType, 2343 T->getSizeModifier(), 2344 T->getIndexTypeCVRQualifiers(), 2345 TL.getBracketsRange()); 2346 if (Result.isNull()) 2347 return QualType(); 2348 } 2349 2350 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(Result); 2351 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2352 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2353 NewTL.setSizeExpr(0); 2354 2355 return Result; 2356} 2357 2358template<typename Derived> 2359QualType 2360TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB, 2361 VariableArrayTypeLoc TL) { 2362 VariableArrayType *T = TL.getTypePtr(); 2363 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2364 if (ElementType.isNull()) 2365 return QualType(); 2366 2367 // Array bounds are not potentially evaluated contexts 2368 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2369 2370 Sema::OwningExprResult SizeResult 2371 = getDerived().TransformExpr(T->getSizeExpr()); 2372 if (SizeResult.isInvalid()) 2373 return QualType(); 2374 2375 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2376 2377 QualType Result = TL.getType(); 2378 if (getDerived().AlwaysRebuild() || 2379 ElementType != T->getElementType() || 2380 Size != T->getSizeExpr()) { 2381 Result = getDerived().RebuildVariableArrayType(ElementType, 2382 T->getSizeModifier(), 2383 move(SizeResult), 2384 T->getIndexTypeCVRQualifiers(), 2385 TL.getBracketsRange()); 2386 if (Result.isNull()) 2387 return QualType(); 2388 } 2389 else SizeResult.take(); 2390 2391 VariableArrayTypeLoc NewTL = TLB.push<VariableArrayTypeLoc>(Result); 2392 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2393 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2394 NewTL.setSizeExpr(Size); 2395 2396 return Result; 2397} 2398 2399template<typename Derived> 2400QualType 2401TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB, 2402 DependentSizedArrayTypeLoc TL) { 2403 DependentSizedArrayType *T = TL.getTypePtr(); 2404 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc()); 2405 if (ElementType.isNull()) 2406 return QualType(); 2407 2408 // Array bounds are not potentially evaluated contexts 2409 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2410 2411 Sema::OwningExprResult SizeResult 2412 = getDerived().TransformExpr(T->getSizeExpr()); 2413 if (SizeResult.isInvalid()) 2414 return QualType(); 2415 2416 Expr *Size = static_cast<Expr*>(SizeResult.get()); 2417 2418 QualType Result = TL.getType(); 2419 if (getDerived().AlwaysRebuild() || 2420 ElementType != T->getElementType() || 2421 Size != T->getSizeExpr()) { 2422 Result = getDerived().RebuildDependentSizedArrayType(ElementType, 2423 T->getSizeModifier(), 2424 move(SizeResult), 2425 T->getIndexTypeCVRQualifiers(), 2426 TL.getBracketsRange()); 2427 if (Result.isNull()) 2428 return QualType(); 2429 } 2430 else SizeResult.take(); 2431 2432 // We might have any sort of array type now, but fortunately they 2433 // all have the same location layout. 2434 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(Result); 2435 NewTL.setLBracketLoc(TL.getLBracketLoc()); 2436 NewTL.setRBracketLoc(TL.getRBracketLoc()); 2437 NewTL.setSizeExpr(Size); 2438 2439 return Result; 2440} 2441 2442template<typename Derived> 2443QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType( 2444 TypeLocBuilder &TLB, 2445 DependentSizedExtVectorTypeLoc TL) { 2446 DependentSizedExtVectorType *T = TL.getTypePtr(); 2447 2448 // FIXME: ext vector locs should be nested 2449 QualType ElementType = getDerived().TransformType(T->getElementType()); 2450 if (ElementType.isNull()) 2451 return QualType(); 2452 2453 // Vector sizes are not potentially evaluated contexts 2454 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2455 2456 Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr()); 2457 if (Size.isInvalid()) 2458 return QualType(); 2459 2460 QualType Result = TL.getType(); 2461 if (getDerived().AlwaysRebuild() || 2462 ElementType != T->getElementType() || 2463 Size.get() != T->getSizeExpr()) { 2464 Result = getDerived().RebuildDependentSizedExtVectorType(ElementType, 2465 move(Size), 2466 T->getAttributeLoc()); 2467 if (Result.isNull()) 2468 return QualType(); 2469 } 2470 else Size.take(); 2471 2472 // Result might be dependent or not. 2473 if (isa<DependentSizedExtVectorType>(Result)) { 2474 DependentSizedExtVectorTypeLoc NewTL 2475 = TLB.push<DependentSizedExtVectorTypeLoc>(Result); 2476 NewTL.setNameLoc(TL.getNameLoc()); 2477 } else { 2478 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2479 NewTL.setNameLoc(TL.getNameLoc()); 2480 } 2481 2482 return Result; 2483} 2484 2485template<typename Derived> 2486QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB, 2487 VectorTypeLoc TL) { 2488 VectorType *T = TL.getTypePtr(); 2489 QualType ElementType = getDerived().TransformType(T->getElementType()); 2490 if (ElementType.isNull()) 2491 return QualType(); 2492 2493 QualType Result = TL.getType(); 2494 if (getDerived().AlwaysRebuild() || 2495 ElementType != T->getElementType()) { 2496 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements()); 2497 if (Result.isNull()) 2498 return QualType(); 2499 } 2500 2501 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(Result); 2502 NewTL.setNameLoc(TL.getNameLoc()); 2503 2504 return Result; 2505} 2506 2507template<typename Derived> 2508QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, 2509 ExtVectorTypeLoc TL) { 2510 VectorType *T = TL.getTypePtr(); 2511 QualType ElementType = getDerived().TransformType(T->getElementType()); 2512 if (ElementType.isNull()) 2513 return QualType(); 2514 2515 QualType Result = TL.getType(); 2516 if (getDerived().AlwaysRebuild() || 2517 ElementType != T->getElementType()) { 2518 Result = getDerived().RebuildExtVectorType(ElementType, 2519 T->getNumElements(), 2520 /*FIXME*/ SourceLocation()); 2521 if (Result.isNull()) 2522 return QualType(); 2523 } 2524 2525 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(Result); 2526 NewTL.setNameLoc(TL.getNameLoc()); 2527 2528 return Result; 2529} 2530 2531template<typename Derived> 2532QualType 2533TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB, 2534 FunctionProtoTypeLoc TL) { 2535 FunctionProtoType *T = TL.getTypePtr(); 2536 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2537 if (ResultType.isNull()) 2538 return QualType(); 2539 2540 // Transform the parameters. 2541 llvm::SmallVector<QualType, 4> ParamTypes; 2542 llvm::SmallVector<ParmVarDecl*, 4> ParamDecls; 2543 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2544 ParmVarDecl *OldParm = TL.getArg(i); 2545 2546 QualType NewType; 2547 ParmVarDecl *NewParm; 2548 2549 if (OldParm) { 2550 DeclaratorInfo *OldDI = OldParm->getDeclaratorInfo(); 2551 assert(OldDI->getType() == T->getArgType(i)); 2552 2553 DeclaratorInfo *NewDI = getDerived().TransformType(OldDI); 2554 if (!NewDI) 2555 return QualType(); 2556 2557 if (NewDI == OldDI) 2558 NewParm = OldParm; 2559 else 2560 NewParm = ParmVarDecl::Create(SemaRef.Context, 2561 OldParm->getDeclContext(), 2562 OldParm->getLocation(), 2563 OldParm->getIdentifier(), 2564 NewDI->getType(), 2565 NewDI, 2566 OldParm->getStorageClass(), 2567 /* DefArg */ NULL); 2568 NewType = NewParm->getType(); 2569 2570 // Deal with the possibility that we don't have a parameter 2571 // declaration for this parameter. 2572 } else { 2573 NewParm = 0; 2574 2575 QualType OldType = T->getArgType(i); 2576 NewType = getDerived().TransformType(OldType); 2577 if (NewType.isNull()) 2578 return QualType(); 2579 } 2580 2581 ParamTypes.push_back(NewType); 2582 ParamDecls.push_back(NewParm); 2583 } 2584 2585 QualType Result = TL.getType(); 2586 if (getDerived().AlwaysRebuild() || 2587 ResultType != T->getResultType() || 2588 !std::equal(T->arg_type_begin(), T->arg_type_end(), ParamTypes.begin())) { 2589 Result = getDerived().RebuildFunctionProtoType(ResultType, 2590 ParamTypes.data(), 2591 ParamTypes.size(), 2592 T->isVariadic(), 2593 T->getTypeQuals()); 2594 if (Result.isNull()) 2595 return QualType(); 2596 } 2597 2598 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(Result); 2599 NewTL.setLParenLoc(TL.getLParenLoc()); 2600 NewTL.setRParenLoc(TL.getRParenLoc()); 2601 for (unsigned i = 0, e = NewTL.getNumArgs(); i != e; ++i) 2602 NewTL.setArg(i, ParamDecls[i]); 2603 2604 return Result; 2605} 2606 2607template<typename Derived> 2608QualType TreeTransform<Derived>::TransformFunctionNoProtoType( 2609 TypeLocBuilder &TLB, 2610 FunctionNoProtoTypeLoc TL) { 2611 FunctionNoProtoType *T = TL.getTypePtr(); 2612 QualType ResultType = getDerived().TransformType(TLB, TL.getResultLoc()); 2613 if (ResultType.isNull()) 2614 return QualType(); 2615 2616 QualType Result = TL.getType(); 2617 if (getDerived().AlwaysRebuild() || 2618 ResultType != T->getResultType()) 2619 Result = getDerived().RebuildFunctionNoProtoType(ResultType); 2620 2621 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(Result); 2622 NewTL.setLParenLoc(TL.getLParenLoc()); 2623 NewTL.setRParenLoc(TL.getRParenLoc()); 2624 2625 return Result; 2626} 2627 2628template<typename Derived> 2629QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB, 2630 TypedefTypeLoc TL) { 2631 TypedefType *T = TL.getTypePtr(); 2632 TypedefDecl *Typedef 2633 = cast_or_null<TypedefDecl>(getDerived().TransformDecl(T->getDecl())); 2634 if (!Typedef) 2635 return QualType(); 2636 2637 QualType Result = TL.getType(); 2638 if (getDerived().AlwaysRebuild() || 2639 Typedef != T->getDecl()) { 2640 Result = getDerived().RebuildTypedefType(Typedef); 2641 if (Result.isNull()) 2642 return QualType(); 2643 } 2644 2645 TypedefTypeLoc NewTL = TLB.push<TypedefTypeLoc>(Result); 2646 NewTL.setNameLoc(TL.getNameLoc()); 2647 2648 return Result; 2649} 2650 2651template<typename Derived> 2652QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB, 2653 TypeOfExprTypeLoc TL) { 2654 TypeOfExprType *T = TL.getTypePtr(); 2655 2656 // typeof expressions are not potentially evaluated contexts 2657 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2658 2659 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2660 if (E.isInvalid()) 2661 return QualType(); 2662 2663 QualType Result = TL.getType(); 2664 if (getDerived().AlwaysRebuild() || 2665 E.get() != T->getUnderlyingExpr()) { 2666 Result = getDerived().RebuildTypeOfExprType(move(E)); 2667 if (Result.isNull()) 2668 return QualType(); 2669 } 2670 else E.take(); 2671 2672 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(Result); 2673 NewTL.setNameLoc(TL.getNameLoc()); 2674 2675 return Result; 2676} 2677 2678template<typename Derived> 2679QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB, 2680 TypeOfTypeLoc TL) { 2681 TypeOfType *T = TL.getTypePtr(); 2682 2683 // FIXME: should be an inner type, or at least have a DeclaratorInfo. 2684 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2685 if (Underlying.isNull()) 2686 return QualType(); 2687 2688 QualType Result = TL.getType(); 2689 if (getDerived().AlwaysRebuild() || 2690 Underlying != T->getUnderlyingType()) { 2691 Result = getDerived().RebuildTypeOfType(Underlying); 2692 if (Result.isNull()) 2693 return QualType(); 2694 } 2695 2696 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(Result); 2697 NewTL.setNameLoc(TL.getNameLoc()); 2698 2699 return Result; 2700} 2701 2702template<typename Derived> 2703QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB, 2704 DecltypeTypeLoc TL) { 2705 DecltypeType *T = TL.getTypePtr(); 2706 2707 // decltype expressions are not potentially evaluated contexts 2708 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 2709 2710 Sema::OwningExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr()); 2711 if (E.isInvalid()) 2712 return QualType(); 2713 2714 QualType Result = TL.getType(); 2715 if (getDerived().AlwaysRebuild() || 2716 E.get() != T->getUnderlyingExpr()) { 2717 Result = getDerived().RebuildDecltypeType(move(E)); 2718 if (Result.isNull()) 2719 return QualType(); 2720 } 2721 else E.take(); 2722 2723 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result); 2724 NewTL.setNameLoc(TL.getNameLoc()); 2725 2726 return Result; 2727} 2728 2729template<typename Derived> 2730QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB, 2731 RecordTypeLoc TL) { 2732 RecordType *T = TL.getTypePtr(); 2733 RecordDecl *Record 2734 = cast_or_null<RecordDecl>(getDerived().TransformDecl(T->getDecl())); 2735 if (!Record) 2736 return QualType(); 2737 2738 QualType Result = TL.getType(); 2739 if (getDerived().AlwaysRebuild() || 2740 Record != T->getDecl()) { 2741 Result = getDerived().RebuildRecordType(Record); 2742 if (Result.isNull()) 2743 return QualType(); 2744 } 2745 2746 RecordTypeLoc NewTL = TLB.push<RecordTypeLoc>(Result); 2747 NewTL.setNameLoc(TL.getNameLoc()); 2748 2749 return Result; 2750} 2751 2752template<typename Derived> 2753QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB, 2754 EnumTypeLoc TL) { 2755 EnumType *T = TL.getTypePtr(); 2756 EnumDecl *Enum 2757 = cast_or_null<EnumDecl>(getDerived().TransformDecl(T->getDecl())); 2758 if (!Enum) 2759 return QualType(); 2760 2761 QualType Result = TL.getType(); 2762 if (getDerived().AlwaysRebuild() || 2763 Enum != T->getDecl()) { 2764 Result = getDerived().RebuildEnumType(Enum); 2765 if (Result.isNull()) 2766 return QualType(); 2767 } 2768 2769 EnumTypeLoc NewTL = TLB.push<EnumTypeLoc>(Result); 2770 NewTL.setNameLoc(TL.getNameLoc()); 2771 2772 return Result; 2773} 2774 2775template <typename Derived> 2776QualType TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB, 2777 ElaboratedTypeLoc TL) { 2778 ElaboratedType *T = TL.getTypePtr(); 2779 2780 // FIXME: this should be a nested type. 2781 QualType Underlying = getDerived().TransformType(T->getUnderlyingType()); 2782 if (Underlying.isNull()) 2783 return QualType(); 2784 2785 QualType Result = TL.getType(); 2786 if (getDerived().AlwaysRebuild() || 2787 Underlying != T->getUnderlyingType()) { 2788 Result = getDerived().RebuildElaboratedType(Underlying, T->getTagKind()); 2789 if (Result.isNull()) 2790 return QualType(); 2791 } 2792 2793 ElaboratedTypeLoc NewTL = TLB.push<ElaboratedTypeLoc>(Result); 2794 NewTL.setNameLoc(TL.getNameLoc()); 2795 2796 return Result; 2797} 2798 2799 2800template<typename Derived> 2801QualType TreeTransform<Derived>::TransformTemplateTypeParmType( 2802 TypeLocBuilder &TLB, 2803 TemplateTypeParmTypeLoc TL) { 2804 return TransformTypeSpecType(TLB, TL); 2805} 2806 2807template<typename Derived> 2808QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType( 2809 TypeLocBuilder &TLB, 2810 SubstTemplateTypeParmTypeLoc TL) { 2811 return TransformTypeSpecType(TLB, TL); 2812} 2813 2814template<typename Derived> 2815inline QualType 2816TreeTransform<Derived>::TransformTemplateSpecializationType( 2817 TypeLocBuilder &TLB, 2818 TemplateSpecializationTypeLoc TL) { 2819 return TransformTemplateSpecializationType(TLB, TL, QualType()); 2820} 2821 2822template<typename Derived> 2823QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2824 const TemplateSpecializationType *TST, 2825 QualType ObjectType) { 2826 // FIXME: this entire method is a temporary workaround; callers 2827 // should be rewritten to provide real type locs. 2828 2829 // Fake up a TemplateSpecializationTypeLoc. 2830 TypeLocBuilder TLB; 2831 TemplateSpecializationTypeLoc TL 2832 = TLB.push<TemplateSpecializationTypeLoc>(QualType(TST, 0)); 2833 2834 SourceLocation BaseLoc = getDerived().getBaseLocation(); 2835 2836 TL.setTemplateNameLoc(BaseLoc); 2837 TL.setLAngleLoc(BaseLoc); 2838 TL.setRAngleLoc(BaseLoc); 2839 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 2840 const TemplateArgument &TA = TST->getArg(i); 2841 TemplateArgumentLoc TAL; 2842 getDerived().InventTemplateArgumentLoc(TA, TAL); 2843 TL.setArgLocInfo(i, TAL.getLocInfo()); 2844 } 2845 2846 TypeLocBuilder IgnoredTLB; 2847 return TransformTemplateSpecializationType(IgnoredTLB, TL, ObjectType); 2848} 2849 2850template<typename Derived> 2851QualType TreeTransform<Derived>::TransformTemplateSpecializationType( 2852 TypeLocBuilder &TLB, 2853 TemplateSpecializationTypeLoc TL, 2854 QualType ObjectType) { 2855 const TemplateSpecializationType *T = TL.getTypePtr(); 2856 2857 TemplateName Template 2858 = getDerived().TransformTemplateName(T->getTemplateName(), ObjectType); 2859 if (Template.isNull()) 2860 return QualType(); 2861 2862 llvm::SmallVector<TemplateArgumentLoc, 4> NewTemplateArgs(T->getNumArgs()); 2863 for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) 2864 if (getDerived().TransformTemplateArgument(TL.getArgLoc(i), 2865 NewTemplateArgs[i])) 2866 return QualType(); 2867 2868 // FIXME: maybe don't rebuild if all the template arguments are the same. 2869 2870 QualType Result = 2871 getDerived().RebuildTemplateSpecializationType(Template, 2872 TL.getTemplateNameLoc(), 2873 TL.getLAngleLoc(), 2874 NewTemplateArgs.data(), 2875 NewTemplateArgs.size(), 2876 TL.getRAngleLoc()); 2877 2878 if (!Result.isNull()) { 2879 TemplateSpecializationTypeLoc NewTL 2880 = TLB.push<TemplateSpecializationTypeLoc>(Result); 2881 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc()); 2882 NewTL.setLAngleLoc(TL.getLAngleLoc()); 2883 NewTL.setRAngleLoc(TL.getRAngleLoc()); 2884 for (unsigned i = 0, e = NewTemplateArgs.size(); i != e; ++i) 2885 NewTL.setArgLocInfo(i, NewTemplateArgs[i].getLocInfo()); 2886 } 2887 2888 return Result; 2889} 2890 2891template<typename Derived> 2892QualType 2893TreeTransform<Derived>::TransformQualifiedNameType(TypeLocBuilder &TLB, 2894 QualifiedNameTypeLoc TL) { 2895 QualifiedNameType *T = TL.getTypePtr(); 2896 NestedNameSpecifier *NNS 2897 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), 2898 SourceRange()); 2899 if (!NNS) 2900 return QualType(); 2901 2902 QualType Named = getDerived().TransformType(T->getNamedType()); 2903 if (Named.isNull()) 2904 return QualType(); 2905 2906 QualType Result = TL.getType(); 2907 if (getDerived().AlwaysRebuild() || 2908 NNS != T->getQualifier() || 2909 Named != T->getNamedType()) { 2910 Result = getDerived().RebuildQualifiedNameType(NNS, Named); 2911 if (Result.isNull()) 2912 return QualType(); 2913 } 2914 2915 QualifiedNameTypeLoc NewTL = TLB.push<QualifiedNameTypeLoc>(Result); 2916 NewTL.setNameLoc(TL.getNameLoc()); 2917 2918 return Result; 2919} 2920 2921template<typename Derived> 2922QualType TreeTransform<Derived>::TransformTypenameType(TypeLocBuilder &TLB, 2923 TypenameTypeLoc TL) { 2924 TypenameType *T = TL.getTypePtr(); 2925 2926 /* FIXME: preserve source information better than this */ 2927 SourceRange SR(TL.getNameLoc()); 2928 2929 NestedNameSpecifier *NNS 2930 = getDerived().TransformNestedNameSpecifier(T->getQualifier(), SR); 2931 if (!NNS) 2932 return QualType(); 2933 2934 QualType Result; 2935 2936 if (const TemplateSpecializationType *TemplateId = T->getTemplateId()) { 2937 QualType NewTemplateId 2938 = getDerived().TransformType(QualType(TemplateId, 0)); 2939 if (NewTemplateId.isNull()) 2940 return QualType(); 2941 2942 if (!getDerived().AlwaysRebuild() && 2943 NNS == T->getQualifier() && 2944 NewTemplateId == QualType(TemplateId, 0)) 2945 return QualType(T, 0); 2946 2947 Result = getDerived().RebuildTypenameType(NNS, NewTemplateId); 2948 } else { 2949 Result = getDerived().RebuildTypenameType(NNS, T->getIdentifier(), SR); 2950 } 2951 if (Result.isNull()) 2952 return QualType(); 2953 2954 TypenameTypeLoc NewTL = TLB.push<TypenameTypeLoc>(Result); 2955 NewTL.setNameLoc(TL.getNameLoc()); 2956 2957 return Result; 2958} 2959 2960template<typename Derived> 2961QualType 2962TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB, 2963 ObjCInterfaceTypeLoc TL) { 2964 assert(false && "TransformObjCInterfaceType unimplemented"); 2965 return QualType(); 2966} 2967 2968template<typename Derived> 2969QualType 2970TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB, 2971 ObjCObjectPointerTypeLoc TL) { 2972 assert(false && "TransformObjCObjectPointerType unimplemented"); 2973 return QualType(); 2974} 2975 2976//===----------------------------------------------------------------------===// 2977// Statement transformation 2978//===----------------------------------------------------------------------===// 2979template<typename Derived> 2980Sema::OwningStmtResult 2981TreeTransform<Derived>::TransformNullStmt(NullStmt *S) { 2982 return SemaRef.Owned(S->Retain()); 2983} 2984 2985template<typename Derived> 2986Sema::OwningStmtResult 2987TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) { 2988 return getDerived().TransformCompoundStmt(S, false); 2989} 2990 2991template<typename Derived> 2992Sema::OwningStmtResult 2993TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S, 2994 bool IsStmtExpr) { 2995 bool SubStmtChanged = false; 2996 ASTOwningVector<&ActionBase::DeleteStmt> Statements(getSema()); 2997 for (CompoundStmt::body_iterator B = S->body_begin(), BEnd = S->body_end(); 2998 B != BEnd; ++B) { 2999 OwningStmtResult Result = getDerived().TransformStmt(*B); 3000 if (Result.isInvalid()) 3001 return getSema().StmtError(); 3002 3003 SubStmtChanged = SubStmtChanged || Result.get() != *B; 3004 Statements.push_back(Result.takeAs<Stmt>()); 3005 } 3006 3007 if (!getDerived().AlwaysRebuild() && 3008 !SubStmtChanged) 3009 return SemaRef.Owned(S->Retain()); 3010 3011 return getDerived().RebuildCompoundStmt(S->getLBracLoc(), 3012 move_arg(Statements), 3013 S->getRBracLoc(), 3014 IsStmtExpr); 3015} 3016 3017template<typename Derived> 3018Sema::OwningStmtResult 3019TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) { 3020 // The case value expressions are not potentially evaluated. 3021 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3022 3023 // Transform the left-hand case value. 3024 OwningExprResult LHS = getDerived().TransformExpr(S->getLHS()); 3025 if (LHS.isInvalid()) 3026 return SemaRef.StmtError(); 3027 3028 // Transform the right-hand case value (for the GNU case-range extension). 3029 OwningExprResult RHS = getDerived().TransformExpr(S->getRHS()); 3030 if (RHS.isInvalid()) 3031 return SemaRef.StmtError(); 3032 3033 // Build the case statement. 3034 // Case statements are always rebuilt so that they will attached to their 3035 // transformed switch statement. 3036 OwningStmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(), 3037 move(LHS), 3038 S->getEllipsisLoc(), 3039 move(RHS), 3040 S->getColonLoc()); 3041 if (Case.isInvalid()) 3042 return SemaRef.StmtError(); 3043 3044 // Transform the statement following the case 3045 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3046 if (SubStmt.isInvalid()) 3047 return SemaRef.StmtError(); 3048 3049 // Attach the body to the case statement 3050 return getDerived().RebuildCaseStmtBody(move(Case), move(SubStmt)); 3051} 3052 3053template<typename Derived> 3054Sema::OwningStmtResult 3055TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) { 3056 // Transform the statement following the default case 3057 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3058 if (SubStmt.isInvalid()) 3059 return SemaRef.StmtError(); 3060 3061 // Default statements are always rebuilt 3062 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(), 3063 move(SubStmt)); 3064} 3065 3066template<typename Derived> 3067Sema::OwningStmtResult 3068TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) { 3069 OwningStmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt()); 3070 if (SubStmt.isInvalid()) 3071 return SemaRef.StmtError(); 3072 3073 // FIXME: Pass the real colon location in. 3074 SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc()); 3075 return getDerived().RebuildLabelStmt(S->getIdentLoc(), S->getID(), ColonLoc, 3076 move(SubStmt)); 3077} 3078 3079template<typename Derived> 3080Sema::OwningStmtResult 3081TreeTransform<Derived>::TransformIfStmt(IfStmt *S) { 3082 // Transform the condition 3083 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3084 if (Cond.isInvalid()) 3085 return SemaRef.StmtError(); 3086 3087 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3088 3089 // Transform the "then" branch. 3090 OwningStmtResult Then = getDerived().TransformStmt(S->getThen()); 3091 if (Then.isInvalid()) 3092 return SemaRef.StmtError(); 3093 3094 // Transform the "else" branch. 3095 OwningStmtResult Else = getDerived().TransformStmt(S->getElse()); 3096 if (Else.isInvalid()) 3097 return SemaRef.StmtError(); 3098 3099 if (!getDerived().AlwaysRebuild() && 3100 FullCond->get() == S->getCond() && 3101 Then.get() == S->getThen() && 3102 Else.get() == S->getElse()) 3103 return SemaRef.Owned(S->Retain()); 3104 3105 return getDerived().RebuildIfStmt(S->getIfLoc(), FullCond, move(Then), 3106 S->getElseLoc(), move(Else)); 3107} 3108 3109template<typename Derived> 3110Sema::OwningStmtResult 3111TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) { 3112 // Transform the condition. 3113 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3114 if (Cond.isInvalid()) 3115 return SemaRef.StmtError(); 3116 3117 // Rebuild the switch statement. 3118 OwningStmtResult Switch = getDerived().RebuildSwitchStmtStart(move(Cond)); 3119 if (Switch.isInvalid()) 3120 return SemaRef.StmtError(); 3121 3122 // Transform the body of the switch statement. 3123 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3124 if (Body.isInvalid()) 3125 return SemaRef.StmtError(); 3126 3127 // Complete the switch statement. 3128 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), move(Switch), 3129 move(Body)); 3130} 3131 3132template<typename Derived> 3133Sema::OwningStmtResult 3134TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) { 3135 // Transform the condition 3136 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3137 if (Cond.isInvalid()) 3138 return SemaRef.StmtError(); 3139 3140 Sema::FullExprArg FullCond(getSema().FullExpr(Cond)); 3141 3142 // Transform the body 3143 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3144 if (Body.isInvalid()) 3145 return SemaRef.StmtError(); 3146 3147 if (!getDerived().AlwaysRebuild() && 3148 FullCond->get() == S->getCond() && 3149 Body.get() == S->getBody()) 3150 return SemaRef.Owned(S->Retain()); 3151 3152 return getDerived().RebuildWhileStmt(S->getWhileLoc(), FullCond, move(Body)); 3153} 3154 3155template<typename Derived> 3156Sema::OwningStmtResult 3157TreeTransform<Derived>::TransformDoStmt(DoStmt *S) { 3158 // Transform the condition 3159 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3160 if (Cond.isInvalid()) 3161 return SemaRef.StmtError(); 3162 3163 // Transform the body 3164 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3165 if (Body.isInvalid()) 3166 return SemaRef.StmtError(); 3167 3168 if (!getDerived().AlwaysRebuild() && 3169 Cond.get() == S->getCond() && 3170 Body.get() == S->getBody()) 3171 return SemaRef.Owned(S->Retain()); 3172 3173 return getDerived().RebuildDoStmt(S->getDoLoc(), move(Body), S->getWhileLoc(), 3174 /*FIXME:*/S->getWhileLoc(), move(Cond), 3175 S->getRParenLoc()); 3176} 3177 3178template<typename Derived> 3179Sema::OwningStmtResult 3180TreeTransform<Derived>::TransformForStmt(ForStmt *S) { 3181 // Transform the initialization statement 3182 OwningStmtResult Init = getDerived().TransformStmt(S->getInit()); 3183 if (Init.isInvalid()) 3184 return SemaRef.StmtError(); 3185 3186 // Transform the condition 3187 OwningExprResult Cond = getDerived().TransformExpr(S->getCond()); 3188 if (Cond.isInvalid()) 3189 return SemaRef.StmtError(); 3190 3191 // Transform the increment 3192 OwningExprResult Inc = getDerived().TransformExpr(S->getInc()); 3193 if (Inc.isInvalid()) 3194 return SemaRef.StmtError(); 3195 3196 // Transform the body 3197 OwningStmtResult Body = getDerived().TransformStmt(S->getBody()); 3198 if (Body.isInvalid()) 3199 return SemaRef.StmtError(); 3200 3201 if (!getDerived().AlwaysRebuild() && 3202 Init.get() == S->getInit() && 3203 Cond.get() == S->getCond() && 3204 Inc.get() == S->getInc() && 3205 Body.get() == S->getBody()) 3206 return SemaRef.Owned(S->Retain()); 3207 3208 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(), 3209 move(Init), move(Cond), move(Inc), 3210 S->getRParenLoc(), move(Body)); 3211} 3212 3213template<typename Derived> 3214Sema::OwningStmtResult 3215TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) { 3216 // Goto statements must always be rebuilt, to resolve the label. 3217 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(), 3218 S->getLabel()); 3219} 3220 3221template<typename Derived> 3222Sema::OwningStmtResult 3223TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) { 3224 OwningExprResult Target = getDerived().TransformExpr(S->getTarget()); 3225 if (Target.isInvalid()) 3226 return SemaRef.StmtError(); 3227 3228 if (!getDerived().AlwaysRebuild() && 3229 Target.get() == S->getTarget()) 3230 return SemaRef.Owned(S->Retain()); 3231 3232 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(), 3233 move(Target)); 3234} 3235 3236template<typename Derived> 3237Sema::OwningStmtResult 3238TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) { 3239 return SemaRef.Owned(S->Retain()); 3240} 3241 3242template<typename Derived> 3243Sema::OwningStmtResult 3244TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) { 3245 return SemaRef.Owned(S->Retain()); 3246} 3247 3248template<typename Derived> 3249Sema::OwningStmtResult 3250TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) { 3251 Sema::OwningExprResult Result = getDerived().TransformExpr(S->getRetValue()); 3252 if (Result.isInvalid()) 3253 return SemaRef.StmtError(); 3254 3255 // FIXME: We always rebuild the return statement because there is no way 3256 // to tell whether the return type of the function has changed. 3257 return getDerived().RebuildReturnStmt(S->getReturnLoc(), move(Result)); 3258} 3259 3260template<typename Derived> 3261Sema::OwningStmtResult 3262TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) { 3263 bool DeclChanged = false; 3264 llvm::SmallVector<Decl *, 4> Decls; 3265 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 3266 D != DEnd; ++D) { 3267 Decl *Transformed = getDerived().TransformDefinition(*D); 3268 if (!Transformed) 3269 return SemaRef.StmtError(); 3270 3271 if (Transformed != *D) 3272 DeclChanged = true; 3273 3274 Decls.push_back(Transformed); 3275 } 3276 3277 if (!getDerived().AlwaysRebuild() && !DeclChanged) 3278 return SemaRef.Owned(S->Retain()); 3279 3280 return getDerived().RebuildDeclStmt(Decls.data(), Decls.size(), 3281 S->getStartLoc(), S->getEndLoc()); 3282} 3283 3284template<typename Derived> 3285Sema::OwningStmtResult 3286TreeTransform<Derived>::TransformSwitchCase(SwitchCase *S) { 3287 assert(false && "SwitchCase is abstract and cannot be transformed"); 3288 return SemaRef.Owned(S->Retain()); 3289} 3290 3291template<typename Derived> 3292Sema::OwningStmtResult 3293TreeTransform<Derived>::TransformAsmStmt(AsmStmt *S) { 3294 // FIXME: Implement! 3295 assert(false && "Inline assembly cannot be transformed"); 3296 return SemaRef.Owned(S->Retain()); 3297} 3298 3299 3300template<typename Derived> 3301Sema::OwningStmtResult 3302TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) { 3303 // FIXME: Implement this 3304 assert(false && "Cannot transform an Objective-C @try statement"); 3305 return SemaRef.Owned(S->Retain()); 3306} 3307 3308template<typename Derived> 3309Sema::OwningStmtResult 3310TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) { 3311 // FIXME: Implement this 3312 assert(false && "Cannot transform an Objective-C @catch statement"); 3313 return SemaRef.Owned(S->Retain()); 3314} 3315 3316template<typename Derived> 3317Sema::OwningStmtResult 3318TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 3319 // FIXME: Implement this 3320 assert(false && "Cannot transform an Objective-C @finally statement"); 3321 return SemaRef.Owned(S->Retain()); 3322} 3323 3324template<typename Derived> 3325Sema::OwningStmtResult 3326TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) { 3327 // FIXME: Implement this 3328 assert(false && "Cannot transform an Objective-C @throw statement"); 3329 return SemaRef.Owned(S->Retain()); 3330} 3331 3332template<typename Derived> 3333Sema::OwningStmtResult 3334TreeTransform<Derived>::TransformObjCAtSynchronizedStmt( 3335 ObjCAtSynchronizedStmt *S) { 3336 // FIXME: Implement this 3337 assert(false && "Cannot transform an Objective-C @synchronized statement"); 3338 return SemaRef.Owned(S->Retain()); 3339} 3340 3341template<typename Derived> 3342Sema::OwningStmtResult 3343TreeTransform<Derived>::TransformObjCForCollectionStmt( 3344 ObjCForCollectionStmt *S) { 3345 // FIXME: Implement this 3346 assert(false && "Cannot transform an Objective-C for-each statement"); 3347 return SemaRef.Owned(S->Retain()); 3348} 3349 3350 3351template<typename Derived> 3352Sema::OwningStmtResult 3353TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) { 3354 // Transform the exception declaration, if any. 3355 VarDecl *Var = 0; 3356 if (S->getExceptionDecl()) { 3357 VarDecl *ExceptionDecl = S->getExceptionDecl(); 3358 TemporaryBase Rebase(*this, ExceptionDecl->getLocation(), 3359 ExceptionDecl->getDeclName()); 3360 3361 QualType T = getDerived().TransformType(ExceptionDecl->getType()); 3362 if (T.isNull()) 3363 return SemaRef.StmtError(); 3364 3365 Var = getDerived().RebuildExceptionDecl(ExceptionDecl, 3366 T, 3367 ExceptionDecl->getDeclaratorInfo(), 3368 ExceptionDecl->getIdentifier(), 3369 ExceptionDecl->getLocation(), 3370 /*FIXME: Inaccurate*/ 3371 SourceRange(ExceptionDecl->getLocation())); 3372 if (!Var || Var->isInvalidDecl()) { 3373 if (Var) 3374 Var->Destroy(SemaRef.Context); 3375 return SemaRef.StmtError(); 3376 } 3377 } 3378 3379 // Transform the actual exception handler. 3380 OwningStmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock()); 3381 if (Handler.isInvalid()) { 3382 if (Var) 3383 Var->Destroy(SemaRef.Context); 3384 return SemaRef.StmtError(); 3385 } 3386 3387 if (!getDerived().AlwaysRebuild() && 3388 !Var && 3389 Handler.get() == S->getHandlerBlock()) 3390 return SemaRef.Owned(S->Retain()); 3391 3392 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), 3393 Var, 3394 move(Handler)); 3395} 3396 3397template<typename Derived> 3398Sema::OwningStmtResult 3399TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) { 3400 // Transform the try block itself. 3401 OwningStmtResult TryBlock 3402 = getDerived().TransformCompoundStmt(S->getTryBlock()); 3403 if (TryBlock.isInvalid()) 3404 return SemaRef.StmtError(); 3405 3406 // Transform the handlers. 3407 bool HandlerChanged = false; 3408 ASTOwningVector<&ActionBase::DeleteStmt> Handlers(SemaRef); 3409 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) { 3410 OwningStmtResult Handler 3411 = getDerived().TransformCXXCatchStmt(S->getHandler(I)); 3412 if (Handler.isInvalid()) 3413 return SemaRef.StmtError(); 3414 3415 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I); 3416 Handlers.push_back(Handler.takeAs<Stmt>()); 3417 } 3418 3419 if (!getDerived().AlwaysRebuild() && 3420 TryBlock.get() == S->getTryBlock() && 3421 !HandlerChanged) 3422 return SemaRef.Owned(S->Retain()); 3423 3424 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), move(TryBlock), 3425 move_arg(Handlers)); 3426} 3427 3428//===----------------------------------------------------------------------===// 3429// Expression transformation 3430//===----------------------------------------------------------------------===// 3431template<typename Derived> 3432Sema::OwningExprResult 3433TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E, 3434 bool isAddressOfOperand) { 3435 return SemaRef.Owned(E->Retain()); 3436} 3437 3438template<typename Derived> 3439Sema::OwningExprResult 3440TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E, 3441 bool isAddressOfOperand) { 3442 NestedNameSpecifier *Qualifier = 0; 3443 if (E->getQualifier()) { 3444 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3445 E->getQualifierRange()); 3446 if (!Qualifier) 3447 return SemaRef.ExprError(); 3448 } 3449 3450 NamedDecl *ND 3451 = dyn_cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getDecl())); 3452 if (!ND) 3453 return SemaRef.ExprError(); 3454 3455 if (!getDerived().AlwaysRebuild() && 3456 Qualifier == E->getQualifier() && 3457 ND == E->getDecl() && 3458 !E->hasExplicitTemplateArgumentList()) 3459 return SemaRef.Owned(E->Retain()); 3460 3461 // FIXME: We're losing the explicit template arguments in this transformation. 3462 3463 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs()); 3464 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3465 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 3466 TransArgs[I])) 3467 return SemaRef.ExprError(); 3468 } 3469 3470 // FIXME: Pass the qualifier/qualifier range along. 3471 return getDerived().RebuildDeclRefExpr(Qualifier, E->getQualifierRange(), 3472 ND, E->getLocation(), 3473 isAddressOfOperand); 3474} 3475 3476template<typename Derived> 3477Sema::OwningExprResult 3478TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E, 3479 bool isAddressOfOperand) { 3480 return SemaRef.Owned(E->Retain()); 3481} 3482 3483template<typename Derived> 3484Sema::OwningExprResult 3485TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E, 3486 bool isAddressOfOperand) { 3487 return SemaRef.Owned(E->Retain()); 3488} 3489 3490template<typename Derived> 3491Sema::OwningExprResult 3492TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E, 3493 bool isAddressOfOperand) { 3494 return SemaRef.Owned(E->Retain()); 3495} 3496 3497template<typename Derived> 3498Sema::OwningExprResult 3499TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E, 3500 bool isAddressOfOperand) { 3501 return SemaRef.Owned(E->Retain()); 3502} 3503 3504template<typename Derived> 3505Sema::OwningExprResult 3506TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E, 3507 bool isAddressOfOperand) { 3508 return SemaRef.Owned(E->Retain()); 3509} 3510 3511template<typename Derived> 3512Sema::OwningExprResult 3513TreeTransform<Derived>::TransformParenExpr(ParenExpr *E, 3514 bool isAddressOfOperand) { 3515 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3516 if (SubExpr.isInvalid()) 3517 return SemaRef.ExprError(); 3518 3519 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3520 return SemaRef.Owned(E->Retain()); 3521 3522 return getDerived().RebuildParenExpr(move(SubExpr), E->getLParen(), 3523 E->getRParen()); 3524} 3525 3526template<typename Derived> 3527Sema::OwningExprResult 3528TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E, 3529 bool isAddressOfOperand) { 3530 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr(), 3531 E->getOpcode() == UnaryOperator::AddrOf); 3532 if (SubExpr.isInvalid()) 3533 return SemaRef.ExprError(); 3534 3535 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr()) 3536 return SemaRef.Owned(E->Retain()); 3537 3538 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(), 3539 E->getOpcode(), 3540 move(SubExpr)); 3541} 3542 3543template<typename Derived> 3544Sema::OwningExprResult 3545TreeTransform<Derived>::TransformSizeOfAlignOfExpr(SizeOfAlignOfExpr *E, 3546 bool isAddressOfOperand) { 3547 if (E->isArgumentType()) { 3548 DeclaratorInfo *OldT = E->getArgumentTypeInfo(); 3549 3550 DeclaratorInfo *NewT = getDerived().TransformType(OldT); 3551 if (!NewT) 3552 return SemaRef.ExprError(); 3553 3554 if (!getDerived().AlwaysRebuild() && OldT == NewT) 3555 return SemaRef.Owned(E->Retain()); 3556 3557 return getDerived().RebuildSizeOfAlignOf(NewT, E->getOperatorLoc(), 3558 E->isSizeOf(), 3559 E->getSourceRange()); 3560 } 3561 3562 Sema::OwningExprResult SubExpr(SemaRef); 3563 { 3564 // C++0x [expr.sizeof]p1: 3565 // The operand is either an expression, which is an unevaluated operand 3566 // [...] 3567 EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated); 3568 3569 SubExpr = getDerived().TransformExpr(E->getArgumentExpr()); 3570 if (SubExpr.isInvalid()) 3571 return SemaRef.ExprError(); 3572 3573 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr()) 3574 return SemaRef.Owned(E->Retain()); 3575 } 3576 3577 return getDerived().RebuildSizeOfAlignOf(move(SubExpr), E->getOperatorLoc(), 3578 E->isSizeOf(), 3579 E->getSourceRange()); 3580} 3581 3582template<typename Derived> 3583Sema::OwningExprResult 3584TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E, 3585 bool isAddressOfOperand) { 3586 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3587 if (LHS.isInvalid()) 3588 return SemaRef.ExprError(); 3589 3590 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3591 if (RHS.isInvalid()) 3592 return SemaRef.ExprError(); 3593 3594 3595 if (!getDerived().AlwaysRebuild() && 3596 LHS.get() == E->getLHS() && 3597 RHS.get() == E->getRHS()) 3598 return SemaRef.Owned(E->Retain()); 3599 3600 return getDerived().RebuildArraySubscriptExpr(move(LHS), 3601 /*FIXME:*/E->getLHS()->getLocStart(), 3602 move(RHS), 3603 E->getRBracketLoc()); 3604} 3605 3606template<typename Derived> 3607Sema::OwningExprResult 3608TreeTransform<Derived>::TransformCallExpr(CallExpr *E, 3609 bool isAddressOfOperand) { 3610 // Transform the callee. 3611 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 3612 if (Callee.isInvalid()) 3613 return SemaRef.ExprError(); 3614 3615 // Transform arguments. 3616 bool ArgChanged = false; 3617 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 3618 llvm::SmallVector<SourceLocation, 4> FakeCommaLocs; 3619 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 3620 OwningExprResult Arg = getDerived().TransformExpr(E->getArg(I)); 3621 if (Arg.isInvalid()) 3622 return SemaRef.ExprError(); 3623 3624 // FIXME: Wrong source location information for the ','. 3625 FakeCommaLocs.push_back( 3626 SemaRef.PP.getLocForEndOfToken(E->getArg(I)->getSourceRange().getEnd())); 3627 3628 ArgChanged = ArgChanged || Arg.get() != E->getArg(I); 3629 Args.push_back(Arg.takeAs<Expr>()); 3630 } 3631 3632 if (!getDerived().AlwaysRebuild() && 3633 Callee.get() == E->getCallee() && 3634 !ArgChanged) 3635 return SemaRef.Owned(E->Retain()); 3636 3637 // FIXME: Wrong source location information for the '('. 3638 SourceLocation FakeLParenLoc 3639 = ((Expr *)Callee.get())->getSourceRange().getBegin(); 3640 return getDerived().RebuildCallExpr(move(Callee), FakeLParenLoc, 3641 move_arg(Args), 3642 FakeCommaLocs.data(), 3643 E->getRParenLoc()); 3644} 3645 3646template<typename Derived> 3647Sema::OwningExprResult 3648TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E, 3649 bool isAddressOfOperand) { 3650 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3651 if (Base.isInvalid()) 3652 return SemaRef.ExprError(); 3653 3654 NestedNameSpecifier *Qualifier = 0; 3655 if (E->hasQualifier()) { 3656 Qualifier 3657 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 3658 E->getQualifierRange()); 3659 if (Qualifier == 0) 3660 return SemaRef.ExprError(); 3661 } 3662 3663 NamedDecl *Member 3664 = cast_or_null<NamedDecl>(getDerived().TransformDecl(E->getMemberDecl())); 3665 if (!Member) 3666 return SemaRef.ExprError(); 3667 3668 if (!getDerived().AlwaysRebuild() && 3669 Base.get() == E->getBase() && 3670 Qualifier == E->getQualifier() && 3671 Member == E->getMemberDecl() && 3672 !E->hasExplicitTemplateArgumentList()) 3673 return SemaRef.Owned(E->Retain()); 3674 3675 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs; 3676 if (E->hasExplicitTemplateArgumentList()) { 3677 TransArgs.resize(E->getNumTemplateArgs()); 3678 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 3679 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 3680 TransArgs[I])) 3681 return SemaRef.ExprError(); 3682 } 3683 } 3684 3685 // FIXME: Bogus source location for the operator 3686 SourceLocation FakeOperatorLoc 3687 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getSourceRange().getEnd()); 3688 3689 return getDerived().RebuildMemberExpr(move(Base), FakeOperatorLoc, 3690 E->isArrow(), 3691 Qualifier, 3692 E->getQualifierRange(), 3693 E->getMemberLoc(), 3694 Member, 3695 E->hasExplicitTemplateArgumentList(), 3696 E->getLAngleLoc(), 3697 TransArgs.data(), 3698 TransArgs.size(), 3699 E->getRAngleLoc(), 3700 0); 3701} 3702 3703template<typename Derived> 3704Sema::OwningExprResult 3705TreeTransform<Derived>::TransformCastExpr(CastExpr *E, 3706 bool isAddressOfOperand) { 3707 assert(false && "Cannot transform abstract class"); 3708 return SemaRef.Owned(E->Retain()); 3709} 3710 3711template<typename Derived> 3712Sema::OwningExprResult 3713TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E, 3714 bool isAddressOfOperand) { 3715 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3716 if (LHS.isInvalid()) 3717 return SemaRef.ExprError(); 3718 3719 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3720 if (RHS.isInvalid()) 3721 return SemaRef.ExprError(); 3722 3723 if (!getDerived().AlwaysRebuild() && 3724 LHS.get() == E->getLHS() && 3725 RHS.get() == E->getRHS()) 3726 return SemaRef.Owned(E->Retain()); 3727 3728 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(), 3729 move(LHS), move(RHS)); 3730} 3731 3732template<typename Derived> 3733Sema::OwningExprResult 3734TreeTransform<Derived>::TransformCompoundAssignOperator( 3735 CompoundAssignOperator *E, 3736 bool isAddressOfOperand) { 3737 return getDerived().TransformBinaryOperator(E, isAddressOfOperand); 3738} 3739 3740template<typename Derived> 3741Sema::OwningExprResult 3742TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E, 3743 bool isAddressOfOperand) { 3744 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 3745 if (Cond.isInvalid()) 3746 return SemaRef.ExprError(); 3747 3748 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 3749 if (LHS.isInvalid()) 3750 return SemaRef.ExprError(); 3751 3752 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 3753 if (RHS.isInvalid()) 3754 return SemaRef.ExprError(); 3755 3756 if (!getDerived().AlwaysRebuild() && 3757 Cond.get() == E->getCond() && 3758 LHS.get() == E->getLHS() && 3759 RHS.get() == E->getRHS()) 3760 return SemaRef.Owned(E->Retain()); 3761 3762 return getDerived().RebuildConditionalOperator(move(Cond), 3763 E->getQuestionLoc(), 3764 move(LHS), 3765 E->getColonLoc(), 3766 move(RHS)); 3767} 3768 3769template<typename Derived> 3770Sema::OwningExprResult 3771TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E, 3772 bool isAddressOfOperand) { 3773 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 3774 3775 // FIXME: Will we ever have type information here? It seems like we won't, 3776 // so do we even need to transform the type? 3777 QualType T = getDerived().TransformType(E->getType()); 3778 if (T.isNull()) 3779 return SemaRef.ExprError(); 3780 3781 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3782 if (SubExpr.isInvalid()) 3783 return SemaRef.ExprError(); 3784 3785 if (!getDerived().AlwaysRebuild() && 3786 T == E->getType() && 3787 SubExpr.get() == E->getSubExpr()) 3788 return SemaRef.Owned(E->Retain()); 3789 3790 return getDerived().RebuildImplicitCastExpr(T, E->getCastKind(), 3791 move(SubExpr), 3792 E->isLvalueCast()); 3793} 3794 3795template<typename Derived> 3796Sema::OwningExprResult 3797TreeTransform<Derived>::TransformExplicitCastExpr(ExplicitCastExpr *E, 3798 bool isAddressOfOperand) { 3799 assert(false && "Cannot transform abstract class"); 3800 return SemaRef.Owned(E->Retain()); 3801} 3802 3803template<typename Derived> 3804Sema::OwningExprResult 3805TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E, 3806 bool isAddressOfOperand) { 3807 QualType T; 3808 { 3809 // FIXME: Source location isn't quite accurate. 3810 SourceLocation TypeStartLoc 3811 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3812 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 3813 3814 T = getDerived().TransformType(E->getTypeAsWritten()); 3815 if (T.isNull()) 3816 return SemaRef.ExprError(); 3817 } 3818 3819 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 3820 if (SubExpr.isInvalid()) 3821 return SemaRef.ExprError(); 3822 3823 if (!getDerived().AlwaysRebuild() && 3824 T == E->getTypeAsWritten() && 3825 SubExpr.get() == E->getSubExpr()) 3826 return SemaRef.Owned(E->Retain()); 3827 3828 return getDerived().RebuildCStyleCaseExpr(E->getLParenLoc(), T, 3829 E->getRParenLoc(), 3830 move(SubExpr)); 3831} 3832 3833template<typename Derived> 3834Sema::OwningExprResult 3835TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E, 3836 bool isAddressOfOperand) { 3837 QualType T; 3838 { 3839 // FIXME: Source location isn't quite accurate. 3840 SourceLocation FakeTypeLoc 3841 = SemaRef.PP.getLocForEndOfToken(E->getLParenLoc()); 3842 TemporaryBase Rebase(*this, FakeTypeLoc, DeclarationName()); 3843 3844 T = getDerived().TransformType(E->getType()); 3845 if (T.isNull()) 3846 return SemaRef.ExprError(); 3847 } 3848 3849 OwningExprResult Init = getDerived().TransformExpr(E->getInitializer()); 3850 if (Init.isInvalid()) 3851 return SemaRef.ExprError(); 3852 3853 if (!getDerived().AlwaysRebuild() && 3854 T == E->getType() && 3855 Init.get() == E->getInitializer()) 3856 return SemaRef.Owned(E->Retain()); 3857 3858 return getDerived().RebuildCompoundLiteralExpr(E->getLParenLoc(), T, 3859 /*FIXME:*/E->getInitializer()->getLocEnd(), 3860 move(Init)); 3861} 3862 3863template<typename Derived> 3864Sema::OwningExprResult 3865TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E, 3866 bool isAddressOfOperand) { 3867 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 3868 if (Base.isInvalid()) 3869 return SemaRef.ExprError(); 3870 3871 if (!getDerived().AlwaysRebuild() && 3872 Base.get() == E->getBase()) 3873 return SemaRef.Owned(E->Retain()); 3874 3875 // FIXME: Bad source location 3876 SourceLocation FakeOperatorLoc 3877 = SemaRef.PP.getLocForEndOfToken(E->getBase()->getLocEnd()); 3878 return getDerived().RebuildExtVectorElementExpr(move(Base), FakeOperatorLoc, 3879 E->getAccessorLoc(), 3880 E->getAccessor()); 3881} 3882 3883template<typename Derived> 3884Sema::OwningExprResult 3885TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E, 3886 bool isAddressOfOperand) { 3887 bool InitChanged = false; 3888 3889 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 3890 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) { 3891 OwningExprResult Init = getDerived().TransformExpr(E->getInit(I)); 3892 if (Init.isInvalid()) 3893 return SemaRef.ExprError(); 3894 3895 InitChanged = InitChanged || Init.get() != E->getInit(I); 3896 Inits.push_back(Init.takeAs<Expr>()); 3897 } 3898 3899 if (!getDerived().AlwaysRebuild() && !InitChanged) 3900 return SemaRef.Owned(E->Retain()); 3901 3902 return getDerived().RebuildInitList(E->getLBraceLoc(), move_arg(Inits), 3903 E->getRBraceLoc()); 3904} 3905 3906template<typename Derived> 3907Sema::OwningExprResult 3908TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E, 3909 bool isAddressOfOperand) { 3910 Designation Desig; 3911 3912 // transform the initializer value 3913 OwningExprResult Init = getDerived().TransformExpr(E->getInit()); 3914 if (Init.isInvalid()) 3915 return SemaRef.ExprError(); 3916 3917 // transform the designators. 3918 ASTOwningVector<&ActionBase::DeleteExpr, 4> ArrayExprs(SemaRef); 3919 bool ExprChanged = false; 3920 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), 3921 DEnd = E->designators_end(); 3922 D != DEnd; ++D) { 3923 if (D->isFieldDesignator()) { 3924 Desig.AddDesignator(Designator::getField(D->getFieldName(), 3925 D->getDotLoc(), 3926 D->getFieldLoc())); 3927 continue; 3928 } 3929 3930 if (D->isArrayDesignator()) { 3931 OwningExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D)); 3932 if (Index.isInvalid()) 3933 return SemaRef.ExprError(); 3934 3935 Desig.AddDesignator(Designator::getArray(Index.get(), 3936 D->getLBracketLoc())); 3937 3938 ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(*D); 3939 ArrayExprs.push_back(Index.release()); 3940 continue; 3941 } 3942 3943 assert(D->isArrayRangeDesignator() && "New kind of designator?"); 3944 OwningExprResult Start 3945 = getDerived().TransformExpr(E->getArrayRangeStart(*D)); 3946 if (Start.isInvalid()) 3947 return SemaRef.ExprError(); 3948 3949 OwningExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D)); 3950 if (End.isInvalid()) 3951 return SemaRef.ExprError(); 3952 3953 Desig.AddDesignator(Designator::getArrayRange(Start.get(), 3954 End.get(), 3955 D->getLBracketLoc(), 3956 D->getEllipsisLoc())); 3957 3958 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(*D) || 3959 End.get() != E->getArrayRangeEnd(*D); 3960 3961 ArrayExprs.push_back(Start.release()); 3962 ArrayExprs.push_back(End.release()); 3963 } 3964 3965 if (!getDerived().AlwaysRebuild() && 3966 Init.get() == E->getInit() && 3967 !ExprChanged) 3968 return SemaRef.Owned(E->Retain()); 3969 3970 return getDerived().RebuildDesignatedInitExpr(Desig, move_arg(ArrayExprs), 3971 E->getEqualOrColonLoc(), 3972 E->usesGNUSyntax(), move(Init)); 3973} 3974 3975template<typename Derived> 3976Sema::OwningExprResult 3977TreeTransform<Derived>::TransformImplicitValueInitExpr( 3978 ImplicitValueInitExpr *E, 3979 bool isAddressOfOperand) { 3980 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 3981 3982 // FIXME: Will we ever have proper type location here? Will we actually 3983 // need to transform the type? 3984 QualType T = getDerived().TransformType(E->getType()); 3985 if (T.isNull()) 3986 return SemaRef.ExprError(); 3987 3988 if (!getDerived().AlwaysRebuild() && 3989 T == E->getType()) 3990 return SemaRef.Owned(E->Retain()); 3991 3992 return getDerived().RebuildImplicitValueInitExpr(T); 3993} 3994 3995template<typename Derived> 3996Sema::OwningExprResult 3997TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E, 3998 bool isAddressOfOperand) { 3999 // FIXME: Do we want the type as written? 4000 QualType T; 4001 4002 { 4003 // FIXME: Source location isn't quite accurate. 4004 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4005 T = getDerived().TransformType(E->getType()); 4006 if (T.isNull()) 4007 return SemaRef.ExprError(); 4008 } 4009 4010 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4011 if (SubExpr.isInvalid()) 4012 return SemaRef.ExprError(); 4013 4014 if (!getDerived().AlwaysRebuild() && 4015 T == E->getType() && 4016 SubExpr.get() == E->getSubExpr()) 4017 return SemaRef.Owned(E->Retain()); 4018 4019 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), move(SubExpr), 4020 T, E->getRParenLoc()); 4021} 4022 4023template<typename Derived> 4024Sema::OwningExprResult 4025TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E, 4026 bool isAddressOfOperand) { 4027 bool ArgumentChanged = false; 4028 ASTOwningVector<&ActionBase::DeleteExpr, 4> Inits(SemaRef); 4029 for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) { 4030 OwningExprResult Init = getDerived().TransformExpr(E->getExpr(I)); 4031 if (Init.isInvalid()) 4032 return SemaRef.ExprError(); 4033 4034 ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I); 4035 Inits.push_back(Init.takeAs<Expr>()); 4036 } 4037 4038 return getDerived().RebuildParenListExpr(E->getLParenLoc(), 4039 move_arg(Inits), 4040 E->getRParenLoc()); 4041} 4042 4043/// \brief Transform an address-of-label expression. 4044/// 4045/// By default, the transformation of an address-of-label expression always 4046/// rebuilds the expression, so that the label identifier can be resolved to 4047/// the corresponding label statement by semantic analysis. 4048template<typename Derived> 4049Sema::OwningExprResult 4050TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E, 4051 bool isAddressOfOperand) { 4052 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(), 4053 E->getLabel()); 4054} 4055 4056template<typename Derived> 4057Sema::OwningExprResult 4058TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E, 4059 bool isAddressOfOperand) { 4060 OwningStmtResult SubStmt 4061 = getDerived().TransformCompoundStmt(E->getSubStmt(), true); 4062 if (SubStmt.isInvalid()) 4063 return SemaRef.ExprError(); 4064 4065 if (!getDerived().AlwaysRebuild() && 4066 SubStmt.get() == E->getSubStmt()) 4067 return SemaRef.Owned(E->Retain()); 4068 4069 return getDerived().RebuildStmtExpr(E->getLParenLoc(), 4070 move(SubStmt), 4071 E->getRParenLoc()); 4072} 4073 4074template<typename Derived> 4075Sema::OwningExprResult 4076TreeTransform<Derived>::TransformTypesCompatibleExpr(TypesCompatibleExpr *E, 4077 bool isAddressOfOperand) { 4078 QualType T1, T2; 4079 { 4080 // FIXME: Source location isn't quite accurate. 4081 TemporaryBase Rebase(*this, E->getBuiltinLoc(), DeclarationName()); 4082 4083 T1 = getDerived().TransformType(E->getArgType1()); 4084 if (T1.isNull()) 4085 return SemaRef.ExprError(); 4086 4087 T2 = getDerived().TransformType(E->getArgType2()); 4088 if (T2.isNull()) 4089 return SemaRef.ExprError(); 4090 } 4091 4092 if (!getDerived().AlwaysRebuild() && 4093 T1 == E->getArgType1() && 4094 T2 == E->getArgType2()) 4095 return SemaRef.Owned(E->Retain()); 4096 4097 return getDerived().RebuildTypesCompatibleExpr(E->getBuiltinLoc(), 4098 T1, T2, E->getRParenLoc()); 4099} 4100 4101template<typename Derived> 4102Sema::OwningExprResult 4103TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E, 4104 bool isAddressOfOperand) { 4105 OwningExprResult Cond = getDerived().TransformExpr(E->getCond()); 4106 if (Cond.isInvalid()) 4107 return SemaRef.ExprError(); 4108 4109 OwningExprResult LHS = getDerived().TransformExpr(E->getLHS()); 4110 if (LHS.isInvalid()) 4111 return SemaRef.ExprError(); 4112 4113 OwningExprResult RHS = getDerived().TransformExpr(E->getRHS()); 4114 if (RHS.isInvalid()) 4115 return SemaRef.ExprError(); 4116 4117 if (!getDerived().AlwaysRebuild() && 4118 Cond.get() == E->getCond() && 4119 LHS.get() == E->getLHS() && 4120 RHS.get() == E->getRHS()) 4121 return SemaRef.Owned(E->Retain()); 4122 4123 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(), 4124 move(Cond), move(LHS), move(RHS), 4125 E->getRParenLoc()); 4126} 4127 4128template<typename Derived> 4129Sema::OwningExprResult 4130TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E, 4131 bool isAddressOfOperand) { 4132 return SemaRef.Owned(E->Retain()); 4133} 4134 4135template<typename Derived> 4136Sema::OwningExprResult 4137TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E, 4138 bool isAddressOfOperand) { 4139 OwningExprResult Callee = getDerived().TransformExpr(E->getCallee()); 4140 if (Callee.isInvalid()) 4141 return SemaRef.ExprError(); 4142 4143 OwningExprResult First 4144 = getDerived().TransformExpr(E->getArg(0), 4145 E->getNumArgs() == 1 && E->getOperator() == OO_Amp); 4146 if (First.isInvalid()) 4147 return SemaRef.ExprError(); 4148 4149 OwningExprResult Second(SemaRef); 4150 if (E->getNumArgs() == 2) { 4151 Second = getDerived().TransformExpr(E->getArg(1)); 4152 if (Second.isInvalid()) 4153 return SemaRef.ExprError(); 4154 } 4155 4156 if (!getDerived().AlwaysRebuild() && 4157 Callee.get() == E->getCallee() && 4158 First.get() == E->getArg(0) && 4159 (E->getNumArgs() != 2 || Second.get() == E->getArg(1))) 4160 return SemaRef.Owned(E->Retain()); 4161 4162 return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(), 4163 E->getOperatorLoc(), 4164 move(Callee), 4165 move(First), 4166 move(Second)); 4167} 4168 4169template<typename Derived> 4170Sema::OwningExprResult 4171TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E, 4172 bool isAddressOfOperand) { 4173 return getDerived().TransformCallExpr(E, isAddressOfOperand); 4174} 4175 4176template<typename Derived> 4177Sema::OwningExprResult 4178TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E, 4179 bool isAddressOfOperand) { 4180 QualType ExplicitTy; 4181 { 4182 // FIXME: Source location isn't quite accurate. 4183 SourceLocation TypeStartLoc 4184 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4185 TemporaryBase Rebase(*this, TypeStartLoc, DeclarationName()); 4186 4187 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 4188 if (ExplicitTy.isNull()) 4189 return SemaRef.ExprError(); 4190 } 4191 4192 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4193 if (SubExpr.isInvalid()) 4194 return SemaRef.ExprError(); 4195 4196 if (!getDerived().AlwaysRebuild() && 4197 ExplicitTy == E->getTypeAsWritten() && 4198 SubExpr.get() == E->getSubExpr()) 4199 return SemaRef.Owned(E->Retain()); 4200 4201 // FIXME: Poor source location information here. 4202 SourceLocation FakeLAngleLoc 4203 = SemaRef.PP.getLocForEndOfToken(E->getOperatorLoc()); 4204 SourceLocation FakeRAngleLoc = E->getSubExpr()->getSourceRange().getBegin(); 4205 SourceLocation FakeRParenLoc 4206 = SemaRef.PP.getLocForEndOfToken( 4207 E->getSubExpr()->getSourceRange().getEnd()); 4208 return getDerived().RebuildCXXNamedCastExpr(E->getOperatorLoc(), 4209 E->getStmtClass(), 4210 FakeLAngleLoc, 4211 ExplicitTy, 4212 FakeRAngleLoc, 4213 FakeRAngleLoc, 4214 move(SubExpr), 4215 FakeRParenLoc); 4216} 4217 4218template<typename Derived> 4219Sema::OwningExprResult 4220TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E, 4221 bool isAddressOfOperand) { 4222 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4223} 4224 4225template<typename Derived> 4226Sema::OwningExprResult 4227TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E, 4228 bool isAddressOfOperand) { 4229 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4230} 4231 4232template<typename Derived> 4233Sema::OwningExprResult 4234TreeTransform<Derived>::TransformCXXReinterpretCastExpr( 4235 CXXReinterpretCastExpr *E, 4236 bool isAddressOfOperand) { 4237 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4238} 4239 4240template<typename Derived> 4241Sema::OwningExprResult 4242TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E, 4243 bool isAddressOfOperand) { 4244 return getDerived().TransformCXXNamedCastExpr(E, isAddressOfOperand); 4245} 4246 4247template<typename Derived> 4248Sema::OwningExprResult 4249TreeTransform<Derived>::TransformCXXFunctionalCastExpr( 4250 CXXFunctionalCastExpr *E, 4251 bool isAddressOfOperand) { 4252 QualType ExplicitTy; 4253 { 4254 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4255 4256 ExplicitTy = getDerived().TransformType(E->getTypeAsWritten()); 4257 if (ExplicitTy.isNull()) 4258 return SemaRef.ExprError(); 4259 } 4260 4261 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4262 if (SubExpr.isInvalid()) 4263 return SemaRef.ExprError(); 4264 4265 if (!getDerived().AlwaysRebuild() && 4266 ExplicitTy == E->getTypeAsWritten() && 4267 SubExpr.get() == E->getSubExpr()) 4268 return SemaRef.Owned(E->Retain()); 4269 4270 // FIXME: The end of the type's source range is wrong 4271 return getDerived().RebuildCXXFunctionalCastExpr( 4272 /*FIXME:*/SourceRange(E->getTypeBeginLoc()), 4273 ExplicitTy, 4274 /*FIXME:*/E->getSubExpr()->getLocStart(), 4275 move(SubExpr), 4276 E->getRParenLoc()); 4277} 4278 4279template<typename Derived> 4280Sema::OwningExprResult 4281TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E, 4282 bool isAddressOfOperand) { 4283 if (E->isTypeOperand()) { 4284 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4285 4286 QualType T = getDerived().TransformType(E->getTypeOperand()); 4287 if (T.isNull()) 4288 return SemaRef.ExprError(); 4289 4290 if (!getDerived().AlwaysRebuild() && 4291 T == E->getTypeOperand()) 4292 return SemaRef.Owned(E->Retain()); 4293 4294 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4295 /*FIXME:*/E->getLocStart(), 4296 T, 4297 E->getLocEnd()); 4298 } 4299 4300 // We don't know whether the expression is potentially evaluated until 4301 // after we perform semantic analysis, so the expression is potentially 4302 // potentially evaluated. 4303 EnterExpressionEvaluationContext Unevaluated(SemaRef, 4304 Action::PotentiallyPotentiallyEvaluated); 4305 4306 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand()); 4307 if (SubExpr.isInvalid()) 4308 return SemaRef.ExprError(); 4309 4310 if (!getDerived().AlwaysRebuild() && 4311 SubExpr.get() == E->getExprOperand()) 4312 return SemaRef.Owned(E->Retain()); 4313 4314 return getDerived().RebuildCXXTypeidExpr(E->getLocStart(), 4315 /*FIXME:*/E->getLocStart(), 4316 move(SubExpr), 4317 E->getLocEnd()); 4318} 4319 4320template<typename Derived> 4321Sema::OwningExprResult 4322TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E, 4323 bool isAddressOfOperand) { 4324 return SemaRef.Owned(E->Retain()); 4325} 4326 4327template<typename Derived> 4328Sema::OwningExprResult 4329TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr( 4330 CXXNullPtrLiteralExpr *E, 4331 bool isAddressOfOperand) { 4332 return SemaRef.Owned(E->Retain()); 4333} 4334 4335template<typename Derived> 4336Sema::OwningExprResult 4337TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E, 4338 bool isAddressOfOperand) { 4339 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4340 4341 QualType T = getDerived().TransformType(E->getType()); 4342 if (T.isNull()) 4343 return SemaRef.ExprError(); 4344 4345 if (!getDerived().AlwaysRebuild() && 4346 T == E->getType()) 4347 return SemaRef.Owned(E->Retain()); 4348 4349 return getDerived().RebuildCXXThisExpr(E->getLocStart(), T); 4350} 4351 4352template<typename Derived> 4353Sema::OwningExprResult 4354TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E, 4355 bool isAddressOfOperand) { 4356 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4357 if (SubExpr.isInvalid()) 4358 return SemaRef.ExprError(); 4359 4360 if (!getDerived().AlwaysRebuild() && 4361 SubExpr.get() == E->getSubExpr()) 4362 return SemaRef.Owned(E->Retain()); 4363 4364 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), move(SubExpr)); 4365} 4366 4367template<typename Derived> 4368Sema::OwningExprResult 4369TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E, 4370 bool isAddressOfOperand) { 4371 ParmVarDecl *Param 4372 = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getParam())); 4373 if (!Param) 4374 return SemaRef.ExprError(); 4375 4376 if (getDerived().AlwaysRebuild() && 4377 Param == E->getParam()) 4378 return SemaRef.Owned(E->Retain()); 4379 4380 return getDerived().RebuildCXXDefaultArgExpr(Param); 4381} 4382 4383template<typename Derived> 4384Sema::OwningExprResult 4385TreeTransform<Derived>::TransformCXXZeroInitValueExpr(CXXZeroInitValueExpr *E, 4386 bool isAddressOfOperand) { 4387 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4388 4389 QualType T = getDerived().TransformType(E->getType()); 4390 if (T.isNull()) 4391 return SemaRef.ExprError(); 4392 4393 if (!getDerived().AlwaysRebuild() && 4394 T == E->getType()) 4395 return SemaRef.Owned(E->Retain()); 4396 4397 return getDerived().RebuildCXXZeroInitValueExpr(E->getTypeBeginLoc(), 4398 /*FIXME:*/E->getTypeBeginLoc(), 4399 T, 4400 E->getRParenLoc()); 4401} 4402 4403template<typename Derived> 4404Sema::OwningExprResult 4405TreeTransform<Derived>::TransformCXXConditionDeclExpr(CXXConditionDeclExpr *E, 4406 bool isAddressOfOperand) { 4407 VarDecl *Var 4408 = cast_or_null<VarDecl>(getDerived().TransformDefinition(E->getVarDecl())); 4409 if (!Var) 4410 return SemaRef.ExprError(); 4411 4412 if (!getDerived().AlwaysRebuild() && 4413 Var == E->getVarDecl()) 4414 return SemaRef.Owned(E->Retain()); 4415 4416 return getDerived().RebuildCXXConditionDeclExpr(E->getStartLoc(), 4417 /*FIXME:*/E->getStartLoc(), 4418 Var); 4419} 4420 4421template<typename Derived> 4422Sema::OwningExprResult 4423TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E, 4424 bool isAddressOfOperand) { 4425 // Transform the type that we're allocating 4426 TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName()); 4427 QualType AllocType = getDerived().TransformType(E->getAllocatedType()); 4428 if (AllocType.isNull()) 4429 return SemaRef.ExprError(); 4430 4431 // Transform the size of the array we're allocating (if any). 4432 OwningExprResult ArraySize = getDerived().TransformExpr(E->getArraySize()); 4433 if (ArraySize.isInvalid()) 4434 return SemaRef.ExprError(); 4435 4436 // Transform the placement arguments (if any). 4437 bool ArgumentChanged = false; 4438 ASTOwningVector<&ActionBase::DeleteExpr> PlacementArgs(SemaRef); 4439 for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) { 4440 OwningExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I)); 4441 if (Arg.isInvalid()) 4442 return SemaRef.ExprError(); 4443 4444 ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I); 4445 PlacementArgs.push_back(Arg.take()); 4446 } 4447 4448 // transform the constructor arguments (if any). 4449 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(SemaRef); 4450 for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I) { 4451 OwningExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I)); 4452 if (Arg.isInvalid()) 4453 return SemaRef.ExprError(); 4454 4455 ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I); 4456 ConstructorArgs.push_back(Arg.take()); 4457 } 4458 4459 if (!getDerived().AlwaysRebuild() && 4460 AllocType == E->getAllocatedType() && 4461 ArraySize.get() == E->getArraySize() && 4462 !ArgumentChanged) 4463 return SemaRef.Owned(E->Retain()); 4464 4465 return getDerived().RebuildCXXNewExpr(E->getLocStart(), 4466 E->isGlobalNew(), 4467 /*FIXME:*/E->getLocStart(), 4468 move_arg(PlacementArgs), 4469 /*FIXME:*/E->getLocStart(), 4470 E->isParenTypeId(), 4471 AllocType, 4472 /*FIXME:*/E->getLocStart(), 4473 /*FIXME:*/SourceRange(), 4474 move(ArraySize), 4475 /*FIXME:*/E->getLocStart(), 4476 move_arg(ConstructorArgs), 4477 E->getLocEnd()); 4478} 4479 4480template<typename Derived> 4481Sema::OwningExprResult 4482TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E, 4483 bool isAddressOfOperand) { 4484 OwningExprResult Operand = getDerived().TransformExpr(E->getArgument()); 4485 if (Operand.isInvalid()) 4486 return SemaRef.ExprError(); 4487 4488 if (!getDerived().AlwaysRebuild() && 4489 Operand.get() == E->getArgument()) 4490 return SemaRef.Owned(E->Retain()); 4491 4492 return getDerived().RebuildCXXDeleteExpr(E->getLocStart(), 4493 E->isGlobalDelete(), 4494 E->isArrayForm(), 4495 move(Operand)); 4496} 4497 4498template<typename Derived> 4499Sema::OwningExprResult 4500TreeTransform<Derived>::TransformCXXPseudoDestructorExpr( 4501 CXXPseudoDestructorExpr *E, 4502 bool isAddressOfOperand) { 4503 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4504 if (Base.isInvalid()) 4505 return SemaRef.ExprError(); 4506 4507 NestedNameSpecifier *Qualifier 4508 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4509 E->getQualifierRange()); 4510 if (E->getQualifier() && !Qualifier) 4511 return SemaRef.ExprError(); 4512 4513 QualType DestroyedType; 4514 { 4515 TemporaryBase Rebase(*this, E->getDestroyedTypeLoc(), DeclarationName()); 4516 DestroyedType = getDerived().TransformType(E->getDestroyedType()); 4517 if (DestroyedType.isNull()) 4518 return SemaRef.ExprError(); 4519 } 4520 4521 if (!getDerived().AlwaysRebuild() && 4522 Base.get() == E->getBase() && 4523 Qualifier == E->getQualifier() && 4524 DestroyedType == E->getDestroyedType()) 4525 return SemaRef.Owned(E->Retain()); 4526 4527 return getDerived().RebuildCXXPseudoDestructorExpr(move(Base), 4528 E->getOperatorLoc(), 4529 E->isArrow(), 4530 E->getDestroyedTypeLoc(), 4531 DestroyedType, 4532 Qualifier, 4533 E->getQualifierRange()); 4534} 4535 4536template<typename Derived> 4537Sema::OwningExprResult 4538TreeTransform<Derived>::TransformUnresolvedFunctionNameExpr( 4539 UnresolvedFunctionNameExpr *E, 4540 bool isAddressOfOperand) { 4541 // There is no transformation we can apply to an unresolved function name. 4542 return SemaRef.Owned(E->Retain()); 4543} 4544 4545template<typename Derived> 4546Sema::OwningExprResult 4547TreeTransform<Derived>::TransformUnaryTypeTraitExpr(UnaryTypeTraitExpr *E, 4548 bool isAddressOfOperand) { 4549 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4550 4551 QualType T = getDerived().TransformType(E->getQueriedType()); 4552 if (T.isNull()) 4553 return SemaRef.ExprError(); 4554 4555 if (!getDerived().AlwaysRebuild() && 4556 T == E->getQueriedType()) 4557 return SemaRef.Owned(E->Retain()); 4558 4559 // FIXME: Bad location information 4560 SourceLocation FakeLParenLoc 4561 = SemaRef.PP.getLocForEndOfToken(E->getLocStart()); 4562 4563 return getDerived().RebuildUnaryTypeTrait(E->getTrait(), 4564 E->getLocStart(), 4565 /*FIXME:*/FakeLParenLoc, 4566 T, 4567 E->getLocEnd()); 4568} 4569 4570template<typename Derived> 4571Sema::OwningExprResult 4572TreeTransform<Derived>::TransformUnresolvedDeclRefExpr( 4573 UnresolvedDeclRefExpr *E, 4574 bool isAddressOfOperand) { 4575 NestedNameSpecifier *NNS 4576 = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4577 E->getQualifierRange()); 4578 if (!NNS) 4579 return SemaRef.ExprError(); 4580 4581 DeclarationName Name 4582 = getDerived().TransformDeclarationName(E->getDeclName(), E->getLocation()); 4583 if (!Name) 4584 return SemaRef.ExprError(); 4585 4586 if (!getDerived().AlwaysRebuild() && 4587 NNS == E->getQualifier() && 4588 Name == E->getDeclName()) 4589 return SemaRef.Owned(E->Retain()); 4590 4591 return getDerived().RebuildUnresolvedDeclRefExpr(NNS, 4592 E->getQualifierRange(), 4593 Name, 4594 E->getLocation(), 4595 isAddressOfOperand); 4596} 4597 4598template<typename Derived> 4599Sema::OwningExprResult 4600TreeTransform<Derived>::TransformTemplateIdRefExpr(TemplateIdRefExpr *E, 4601 bool isAddressOfOperand) { 4602 TemporaryBase Rebase(*this, E->getTemplateNameLoc(), DeclarationName()); 4603 4604 TemplateName Template 4605 = getDerived().TransformTemplateName(E->getTemplateName()); 4606 if (Template.isNull()) 4607 return SemaRef.ExprError(); 4608 4609 NestedNameSpecifier *Qualifier = 0; 4610 if (E->getQualifier()) { 4611 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4612 E->getQualifierRange()); 4613 if (!Qualifier) 4614 return SemaRef.ExprError(); 4615 } 4616 4617 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs()); 4618 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4619 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 4620 TransArgs[I])) 4621 return SemaRef.ExprError(); 4622 } 4623 4624 // FIXME: Would like to avoid rebuilding if nothing changed, but we can't 4625 // compare template arguments (yet). 4626 4627 // FIXME: It's possible that we'll find out now that the template name 4628 // actually refers to a type, in which case the caller is actually dealing 4629 // with a functional cast. Give a reasonable error message! 4630 return getDerived().RebuildTemplateIdExpr(Qualifier, E->getQualifierRange(), 4631 Template, E->getTemplateNameLoc(), 4632 E->getLAngleLoc(), 4633 TransArgs.data(), 4634 TransArgs.size(), 4635 E->getRAngleLoc()); 4636} 4637 4638template<typename Derived> 4639Sema::OwningExprResult 4640TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E, 4641 bool isAddressOfOperand) { 4642 TemporaryBase Rebase(*this, /*FIXME*/E->getLocStart(), DeclarationName()); 4643 4644 QualType T = getDerived().TransformType(E->getType()); 4645 if (T.isNull()) 4646 return SemaRef.ExprError(); 4647 4648 CXXConstructorDecl *Constructor 4649 = cast_or_null<CXXConstructorDecl>( 4650 getDerived().TransformDecl(E->getConstructor())); 4651 if (!Constructor) 4652 return SemaRef.ExprError(); 4653 4654 bool ArgumentChanged = false; 4655 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4656 for (CXXConstructExpr::arg_iterator Arg = E->arg_begin(), 4657 ArgEnd = E->arg_end(); 4658 Arg != ArgEnd; ++Arg) { 4659 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4660 if (TransArg.isInvalid()) 4661 return SemaRef.ExprError(); 4662 4663 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4664 Args.push_back(TransArg.takeAs<Expr>()); 4665 } 4666 4667 if (!getDerived().AlwaysRebuild() && 4668 T == E->getType() && 4669 Constructor == E->getConstructor() && 4670 !ArgumentChanged) 4671 return SemaRef.Owned(E->Retain()); 4672 4673 return getDerived().RebuildCXXConstructExpr(T, Constructor, E->isElidable(), 4674 move_arg(Args)); 4675} 4676 4677/// \brief Transform a C++ temporary-binding expression. 4678/// 4679/// The transformation of a temporary-binding expression always attempts to 4680/// bind a new temporary variable to its subexpression, even if the 4681/// subexpression itself did not change, because the temporary variable itself 4682/// must be unique. 4683template<typename Derived> 4684Sema::OwningExprResult 4685TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E, 4686 bool isAddressOfOperand) { 4687 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4688 if (SubExpr.isInvalid()) 4689 return SemaRef.ExprError(); 4690 4691 return SemaRef.MaybeBindToTemporary(SubExpr.takeAs<Expr>()); 4692} 4693 4694/// \brief Transform a C++ expression that contains temporaries that should 4695/// be destroyed after the expression is evaluated. 4696/// 4697/// The transformation of a full expression always attempts to build a new 4698/// CXXExprWithTemporaries expression, even if the 4699/// subexpression itself did not change, because it will need to capture the 4700/// the new temporary variables introduced in the subexpression. 4701template<typename Derived> 4702Sema::OwningExprResult 4703TreeTransform<Derived>::TransformCXXExprWithTemporaries( 4704 CXXExprWithTemporaries *E, 4705 bool isAddressOfOperand) { 4706 OwningExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr()); 4707 if (SubExpr.isInvalid()) 4708 return SemaRef.ExprError(); 4709 4710 return SemaRef.Owned( 4711 SemaRef.MaybeCreateCXXExprWithTemporaries(SubExpr.takeAs<Expr>(), 4712 E->shouldDestroyTemporaries())); 4713} 4714 4715template<typename Derived> 4716Sema::OwningExprResult 4717TreeTransform<Derived>::TransformCXXTemporaryObjectExpr( 4718 CXXTemporaryObjectExpr *E, 4719 bool isAddressOfOperand) { 4720 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4721 QualType T = getDerived().TransformType(E->getType()); 4722 if (T.isNull()) 4723 return SemaRef.ExprError(); 4724 4725 CXXConstructorDecl *Constructor 4726 = cast_or_null<CXXConstructorDecl>( 4727 getDerived().TransformDecl(E->getConstructor())); 4728 if (!Constructor) 4729 return SemaRef.ExprError(); 4730 4731 bool ArgumentChanged = false; 4732 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4733 Args.reserve(E->getNumArgs()); 4734 for (CXXTemporaryObjectExpr::arg_iterator Arg = E->arg_begin(), 4735 ArgEnd = E->arg_end(); 4736 Arg != ArgEnd; ++Arg) { 4737 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4738 if (TransArg.isInvalid()) 4739 return SemaRef.ExprError(); 4740 4741 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4742 Args.push_back((Expr *)TransArg.release()); 4743 } 4744 4745 if (!getDerived().AlwaysRebuild() && 4746 T == E->getType() && 4747 Constructor == E->getConstructor() && 4748 !ArgumentChanged) 4749 return SemaRef.Owned(E->Retain()); 4750 4751 // FIXME: Bogus location information 4752 SourceLocation CommaLoc; 4753 if (Args.size() > 1) { 4754 Expr *First = (Expr *)Args[0]; 4755 CommaLoc 4756 = SemaRef.PP.getLocForEndOfToken(First->getSourceRange().getEnd()); 4757 } 4758 return getDerived().RebuildCXXTemporaryObjectExpr(E->getTypeBeginLoc(), 4759 T, 4760 /*FIXME:*/E->getTypeBeginLoc(), 4761 move_arg(Args), 4762 &CommaLoc, 4763 E->getLocEnd()); 4764} 4765 4766template<typename Derived> 4767Sema::OwningExprResult 4768TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr( 4769 CXXUnresolvedConstructExpr *E, 4770 bool isAddressOfOperand) { 4771 TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName()); 4772 QualType T = getDerived().TransformType(E->getTypeAsWritten()); 4773 if (T.isNull()) 4774 return SemaRef.ExprError(); 4775 4776 bool ArgumentChanged = false; 4777 ASTOwningVector<&ActionBase::DeleteExpr> Args(SemaRef); 4778 llvm::SmallVector<SourceLocation, 8> FakeCommaLocs; 4779 for (CXXUnresolvedConstructExpr::arg_iterator Arg = E->arg_begin(), 4780 ArgEnd = E->arg_end(); 4781 Arg != ArgEnd; ++Arg) { 4782 OwningExprResult TransArg = getDerived().TransformExpr(*Arg); 4783 if (TransArg.isInvalid()) 4784 return SemaRef.ExprError(); 4785 4786 ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg; 4787 FakeCommaLocs.push_back( 4788 SemaRef.PP.getLocForEndOfToken((*Arg)->getLocEnd())); 4789 Args.push_back(TransArg.takeAs<Expr>()); 4790 } 4791 4792 if (!getDerived().AlwaysRebuild() && 4793 T == E->getTypeAsWritten() && 4794 !ArgumentChanged) 4795 return SemaRef.Owned(E->Retain()); 4796 4797 // FIXME: we're faking the locations of the commas 4798 return getDerived().RebuildCXXUnresolvedConstructExpr(E->getTypeBeginLoc(), 4799 T, 4800 E->getLParenLoc(), 4801 move_arg(Args), 4802 FakeCommaLocs.data(), 4803 E->getRParenLoc()); 4804} 4805 4806template<typename Derived> 4807Sema::OwningExprResult 4808TreeTransform<Derived>::TransformCXXUnresolvedMemberExpr( 4809 CXXUnresolvedMemberExpr *E, 4810 bool isAddressOfOperand) { 4811 // Transform the base of the expression. 4812 OwningExprResult Base = getDerived().TransformExpr(E->getBase()); 4813 if (Base.isInvalid()) 4814 return SemaRef.ExprError(); 4815 4816 // Start the member reference and compute the object's type. 4817 Sema::TypeTy *ObjectType = 0; 4818 Base = SemaRef.ActOnStartCXXMemberReference(0, move(Base), 4819 E->getOperatorLoc(), 4820 E->isArrow()? tok::arrow : tok::period, 4821 ObjectType); 4822 if (Base.isInvalid()) 4823 return SemaRef.ExprError(); 4824 4825 // Transform the first part of the nested-name-specifier that qualifies 4826 // the member name. 4827 NamedDecl *FirstQualifierInScope 4828 = getDerived().TransformFirstQualifierInScope( 4829 E->getFirstQualifierFoundInScope(), 4830 E->getQualifierRange().getBegin()); 4831 4832 NestedNameSpecifier *Qualifier = 0; 4833 if (E->getQualifier()) { 4834 Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(), 4835 E->getQualifierRange(), 4836 QualType::getFromOpaquePtr(ObjectType), 4837 FirstQualifierInScope); 4838 if (!Qualifier) 4839 return SemaRef.ExprError(); 4840 } 4841 4842 DeclarationName Name 4843 = getDerived().TransformDeclarationName(E->getMember(), E->getMemberLoc(), 4844 QualType::getFromOpaquePtr(ObjectType)); 4845 if (!Name) 4846 return SemaRef.ExprError(); 4847 4848 if (!E->hasExplicitTemplateArgumentList()) { 4849 // This is a reference to a member without an explicitly-specified 4850 // template argument list. Optimize for this common case. 4851 if (!getDerived().AlwaysRebuild() && 4852 Base.get() == E->getBase() && 4853 Qualifier == E->getQualifier() && 4854 Name == E->getMember() && 4855 FirstQualifierInScope == E->getFirstQualifierFoundInScope()) 4856 return SemaRef.Owned(E->Retain()); 4857 4858 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 4859 E->isArrow(), 4860 E->getOperatorLoc(), 4861 Qualifier, 4862 E->getQualifierRange(), 4863 Name, 4864 E->getMemberLoc(), 4865 FirstQualifierInScope); 4866 } 4867 4868 // FIXME: This is an ugly hack, which forces the same template name to 4869 // be looked up multiple times. Yuck! 4870 TemporaryBase Rebase(*this, E->getMemberLoc(), DeclarationName()); 4871 TemplateName OrigTemplateName; 4872 if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) 4873 OrigTemplateName = SemaRef.Context.getDependentTemplateName(0, II); 4874 else 4875 OrigTemplateName 4876 = SemaRef.Context.getDependentTemplateName(0, 4877 Name.getCXXOverloadedOperator()); 4878 4879 TemplateName Template 4880 = getDerived().TransformTemplateName(OrigTemplateName, 4881 QualType::getFromOpaquePtr(ObjectType)); 4882 if (Template.isNull()) 4883 return SemaRef.ExprError(); 4884 4885 llvm::SmallVector<TemplateArgumentLoc, 4> TransArgs(E->getNumTemplateArgs()); 4886 for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) { 4887 if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], 4888 TransArgs[I])) 4889 return SemaRef.ExprError(); 4890 } 4891 4892 return getDerived().RebuildCXXUnresolvedMemberExpr(move(Base), 4893 E->isArrow(), 4894 E->getOperatorLoc(), 4895 Qualifier, 4896 E->getQualifierRange(), 4897 Template, 4898 E->getMemberLoc(), 4899 FirstQualifierInScope, 4900 E->getLAngleLoc(), 4901 TransArgs.data(), 4902 TransArgs.size(), 4903 E->getRAngleLoc()); 4904} 4905 4906template<typename Derived> 4907Sema::OwningExprResult 4908TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E, 4909 bool isAddressOfOperand) { 4910 return SemaRef.Owned(E->Retain()); 4911} 4912 4913template<typename Derived> 4914Sema::OwningExprResult 4915TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E, 4916 bool isAddressOfOperand) { 4917 // FIXME: poor source location 4918 TemporaryBase Rebase(*this, E->getAtLoc(), DeclarationName()); 4919 QualType EncodedType = getDerived().TransformType(E->getEncodedType()); 4920 if (EncodedType.isNull()) 4921 return SemaRef.ExprError(); 4922 4923 if (!getDerived().AlwaysRebuild() && 4924 EncodedType == E->getEncodedType()) 4925 return SemaRef.Owned(E->Retain()); 4926 4927 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(), 4928 EncodedType, 4929 E->getRParenLoc()); 4930} 4931 4932template<typename Derived> 4933Sema::OwningExprResult 4934TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E, 4935 bool isAddressOfOperand) { 4936 // FIXME: Implement this! 4937 assert(false && "Cannot transform Objective-C expressions yet"); 4938 return SemaRef.Owned(E->Retain()); 4939} 4940 4941template<typename Derived> 4942Sema::OwningExprResult 4943TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E, 4944 bool isAddressOfOperand) { 4945 return SemaRef.Owned(E->Retain()); 4946} 4947 4948template<typename Derived> 4949Sema::OwningExprResult 4950TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E, 4951 bool isAddressOfOperand) { 4952 ObjCProtocolDecl *Protocol 4953 = cast_or_null<ObjCProtocolDecl>( 4954 getDerived().TransformDecl(E->getProtocol())); 4955 if (!Protocol) 4956 return SemaRef.ExprError(); 4957 4958 if (!getDerived().AlwaysRebuild() && 4959 Protocol == E->getProtocol()) 4960 return SemaRef.Owned(E->Retain()); 4961 4962 return getDerived().RebuildObjCProtocolExpr(Protocol, 4963 E->getAtLoc(), 4964 /*FIXME:*/E->getAtLoc(), 4965 /*FIXME:*/E->getAtLoc(), 4966 E->getRParenLoc()); 4967 4968} 4969 4970template<typename Derived> 4971Sema::OwningExprResult 4972TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E, 4973 bool isAddressOfOperand) { 4974 // FIXME: Implement this! 4975 assert(false && "Cannot transform Objective-C expressions yet"); 4976 return SemaRef.Owned(E->Retain()); 4977} 4978 4979template<typename Derived> 4980Sema::OwningExprResult 4981TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E, 4982 bool isAddressOfOperand) { 4983 // FIXME: Implement this! 4984 assert(false && "Cannot transform Objective-C expressions yet"); 4985 return SemaRef.Owned(E->Retain()); 4986} 4987 4988template<typename Derived> 4989Sema::OwningExprResult 4990TreeTransform<Derived>::TransformObjCImplicitSetterGetterRefExpr( 4991 ObjCImplicitSetterGetterRefExpr *E, 4992 bool isAddressOfOperand) { 4993 // FIXME: Implement this! 4994 assert(false && "Cannot transform Objective-C expressions yet"); 4995 return SemaRef.Owned(E->Retain()); 4996} 4997 4998template<typename Derived> 4999Sema::OwningExprResult 5000TreeTransform<Derived>::TransformObjCSuperExpr(ObjCSuperExpr *E, 5001 bool isAddressOfOperand) { 5002 // FIXME: Implement this! 5003 assert(false && "Cannot transform Objective-C expressions yet"); 5004 return SemaRef.Owned(E->Retain()); 5005} 5006 5007template<typename Derived> 5008Sema::OwningExprResult 5009TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E, 5010 bool isAddressOfOperand) { 5011 // FIXME: Implement this! 5012 assert(false && "Cannot transform Objective-C expressions yet"); 5013 return SemaRef.Owned(E->Retain()); 5014} 5015 5016template<typename Derived> 5017Sema::OwningExprResult 5018TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E, 5019 bool isAddressOfOperand) { 5020 bool ArgumentChanged = false; 5021 ASTOwningVector<&ActionBase::DeleteExpr> SubExprs(SemaRef); 5022 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) { 5023 OwningExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I)); 5024 if (SubExpr.isInvalid()) 5025 return SemaRef.ExprError(); 5026 5027 ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I); 5028 SubExprs.push_back(SubExpr.takeAs<Expr>()); 5029 } 5030 5031 if (!getDerived().AlwaysRebuild() && 5032 !ArgumentChanged) 5033 return SemaRef.Owned(E->Retain()); 5034 5035 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(), 5036 move_arg(SubExprs), 5037 E->getRParenLoc()); 5038} 5039 5040template<typename Derived> 5041Sema::OwningExprResult 5042TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E, 5043 bool isAddressOfOperand) { 5044 // FIXME: Implement this! 5045 assert(false && "Cannot transform block expressions yet"); 5046 return SemaRef.Owned(E->Retain()); 5047} 5048 5049template<typename Derived> 5050Sema::OwningExprResult 5051TreeTransform<Derived>::TransformBlockDeclRefExpr(BlockDeclRefExpr *E, 5052 bool isAddressOfOperand) { 5053 // FIXME: Implement this! 5054 assert(false && "Cannot transform block-related expressions yet"); 5055 return SemaRef.Owned(E->Retain()); 5056} 5057 5058//===----------------------------------------------------------------------===// 5059// Type reconstruction 5060//===----------------------------------------------------------------------===// 5061 5062template<typename Derived> 5063QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType, 5064 SourceLocation Star) { 5065 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Star, 5066 getDerived().getBaseEntity()); 5067} 5068 5069template<typename Derived> 5070QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType, 5071 SourceLocation Star) { 5072 return SemaRef.BuildBlockPointerType(PointeeType, Qualifiers(), Star, 5073 getDerived().getBaseEntity()); 5074} 5075 5076template<typename Derived> 5077QualType 5078TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType, 5079 bool WrittenAsLValue, 5080 SourceLocation Sigil) { 5081 return SemaRef.BuildReferenceType(ReferentType, WrittenAsLValue, Qualifiers(), 5082 Sigil, getDerived().getBaseEntity()); 5083} 5084 5085template<typename Derived> 5086QualType 5087TreeTransform<Derived>::RebuildMemberPointerType(QualType PointeeType, 5088 QualType ClassType, 5089 SourceLocation Sigil) { 5090 return SemaRef.BuildMemberPointerType(PointeeType, ClassType, Qualifiers(), 5091 Sigil, getDerived().getBaseEntity()); 5092} 5093 5094template<typename Derived> 5095QualType 5096TreeTransform<Derived>::RebuildObjCObjectPointerType(QualType PointeeType, 5097 SourceLocation Sigil) { 5098 return SemaRef.BuildPointerType(PointeeType, Qualifiers(), Sigil, 5099 getDerived().getBaseEntity()); 5100} 5101 5102template<typename Derived> 5103QualType 5104TreeTransform<Derived>::RebuildArrayType(QualType ElementType, 5105 ArrayType::ArraySizeModifier SizeMod, 5106 const llvm::APInt *Size, 5107 Expr *SizeExpr, 5108 unsigned IndexTypeQuals, 5109 SourceRange BracketsRange) { 5110 if (SizeExpr || !Size) 5111 return SemaRef.BuildArrayType(ElementType, SizeMod, SizeExpr, 5112 IndexTypeQuals, BracketsRange, 5113 getDerived().getBaseEntity()); 5114 5115 QualType Types[] = { 5116 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy, 5117 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy, 5118 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty 5119 }; 5120 const unsigned NumTypes = sizeof(Types) / sizeof(QualType); 5121 QualType SizeType; 5122 for (unsigned I = 0; I != NumTypes; ++I) 5123 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(Types[I])) { 5124 SizeType = Types[I]; 5125 break; 5126 } 5127 5128 if (SizeType.isNull()) 5129 SizeType = SemaRef.Context.getFixedWidthIntType(Size->getBitWidth(), false); 5130 5131 IntegerLiteral ArraySize(*Size, SizeType, /*FIXME*/BracketsRange.getBegin()); 5132 return SemaRef.BuildArrayType(ElementType, SizeMod, &ArraySize, 5133 IndexTypeQuals, BracketsRange, 5134 getDerived().getBaseEntity()); 5135} 5136 5137template<typename Derived> 5138QualType 5139TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType, 5140 ArrayType::ArraySizeModifier SizeMod, 5141 const llvm::APInt &Size, 5142 unsigned IndexTypeQuals, 5143 SourceRange BracketsRange) { 5144 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0, 5145 IndexTypeQuals, BracketsRange); 5146} 5147 5148template<typename Derived> 5149QualType 5150TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType, 5151 ArrayType::ArraySizeModifier SizeMod, 5152 unsigned IndexTypeQuals, 5153 SourceRange BracketsRange) { 5154 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 0, 5155 IndexTypeQuals, BracketsRange); 5156} 5157 5158template<typename Derived> 5159QualType 5160TreeTransform<Derived>::RebuildVariableArrayType(QualType ElementType, 5161 ArrayType::ArraySizeModifier SizeMod, 5162 ExprArg SizeExpr, 5163 unsigned IndexTypeQuals, 5164 SourceRange BracketsRange) { 5165 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5166 SizeExpr.takeAs<Expr>(), 5167 IndexTypeQuals, BracketsRange); 5168} 5169 5170template<typename Derived> 5171QualType 5172TreeTransform<Derived>::RebuildDependentSizedArrayType(QualType ElementType, 5173 ArrayType::ArraySizeModifier SizeMod, 5174 ExprArg SizeExpr, 5175 unsigned IndexTypeQuals, 5176 SourceRange BracketsRange) { 5177 return getDerived().RebuildArrayType(ElementType, SizeMod, 0, 5178 SizeExpr.takeAs<Expr>(), 5179 IndexTypeQuals, BracketsRange); 5180} 5181 5182template<typename Derived> 5183QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType, 5184 unsigned NumElements) { 5185 // FIXME: semantic checking! 5186 return SemaRef.Context.getVectorType(ElementType, NumElements); 5187} 5188 5189template<typename Derived> 5190QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType, 5191 unsigned NumElements, 5192 SourceLocation AttributeLoc) { 5193 llvm::APInt numElements(SemaRef.Context.getIntWidth(SemaRef.Context.IntTy), 5194 NumElements, true); 5195 IntegerLiteral *VectorSize 5196 = new (SemaRef.Context) IntegerLiteral(numElements, SemaRef.Context.IntTy, 5197 AttributeLoc); 5198 return SemaRef.BuildExtVectorType(ElementType, SemaRef.Owned(VectorSize), 5199 AttributeLoc); 5200} 5201 5202template<typename Derived> 5203QualType 5204TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType, 5205 ExprArg SizeExpr, 5206 SourceLocation AttributeLoc) { 5207 return SemaRef.BuildExtVectorType(ElementType, move(SizeExpr), AttributeLoc); 5208} 5209 5210template<typename Derived> 5211QualType TreeTransform<Derived>::RebuildFunctionProtoType(QualType T, 5212 QualType *ParamTypes, 5213 unsigned NumParamTypes, 5214 bool Variadic, 5215 unsigned Quals) { 5216 return SemaRef.BuildFunctionType(T, ParamTypes, NumParamTypes, Variadic, 5217 Quals, 5218 getDerived().getBaseLocation(), 5219 getDerived().getBaseEntity()); 5220} 5221 5222template<typename Derived> 5223QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) { 5224 return SemaRef.Context.getFunctionNoProtoType(T); 5225} 5226 5227template<typename Derived> 5228QualType TreeTransform<Derived>::RebuildTypeOfExprType(ExprArg E) { 5229 return SemaRef.BuildTypeofExprType(E.takeAs<Expr>()); 5230} 5231 5232template<typename Derived> 5233QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) { 5234 return SemaRef.Context.getTypeOfType(Underlying); 5235} 5236 5237template<typename Derived> 5238QualType TreeTransform<Derived>::RebuildDecltypeType(ExprArg E) { 5239 return SemaRef.BuildDecltypeType(E.takeAs<Expr>()); 5240} 5241 5242template<typename Derived> 5243QualType TreeTransform<Derived>::RebuildTemplateSpecializationType( 5244 TemplateName Template, 5245 SourceLocation TemplateNameLoc, 5246 SourceLocation LAngleLoc, 5247 const TemplateArgumentLoc *Args, 5248 unsigned NumArgs, 5249 SourceLocation RAngleLoc) { 5250 return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, LAngleLoc, 5251 Args, NumArgs, RAngleLoc); 5252} 5253 5254template<typename Derived> 5255NestedNameSpecifier * 5256TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5257 SourceRange Range, 5258 IdentifierInfo &II, 5259 QualType ObjectType, 5260 NamedDecl *FirstQualifierInScope) { 5261 CXXScopeSpec SS; 5262 // FIXME: The source location information is all wrong. 5263 SS.setRange(Range); 5264 SS.setScopeRep(Prefix); 5265 return static_cast<NestedNameSpecifier *>( 5266 SemaRef.BuildCXXNestedNameSpecifier(0, SS, Range.getEnd(), 5267 Range.getEnd(), II, 5268 ObjectType, 5269 FirstQualifierInScope, 5270 false)); 5271} 5272 5273template<typename Derived> 5274NestedNameSpecifier * 5275TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5276 SourceRange Range, 5277 NamespaceDecl *NS) { 5278 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, NS); 5279} 5280 5281template<typename Derived> 5282NestedNameSpecifier * 5283TreeTransform<Derived>::RebuildNestedNameSpecifier(NestedNameSpecifier *Prefix, 5284 SourceRange Range, 5285 bool TemplateKW, 5286 QualType T) { 5287 if (T->isDependentType() || T->isRecordType() || 5288 (SemaRef.getLangOptions().CPlusPlus0x && T->isEnumeralType())) { 5289 assert(!T.hasQualifiers() && "Can't get cv-qualifiers here"); 5290 return NestedNameSpecifier::Create(SemaRef.Context, Prefix, TemplateKW, 5291 T.getTypePtr()); 5292 } 5293 5294 SemaRef.Diag(Range.getBegin(), diag::err_nested_name_spec_non_tag) << T; 5295 return 0; 5296} 5297 5298template<typename Derived> 5299TemplateName 5300TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5301 bool TemplateKW, 5302 TemplateDecl *Template) { 5303 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, 5304 Template); 5305} 5306 5307template<typename Derived> 5308TemplateName 5309TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5310 bool TemplateKW, 5311 OverloadedFunctionDecl *Ovl) { 5312 return SemaRef.Context.getQualifiedTemplateName(Qualifier, TemplateKW, Ovl); 5313} 5314 5315template<typename Derived> 5316TemplateName 5317TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5318 const IdentifierInfo &II, 5319 QualType ObjectType) { 5320 CXXScopeSpec SS; 5321 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5322 SS.setScopeRep(Qualifier); 5323 UnqualifiedId Name; 5324 Name.setIdentifier(&II, /*FIXME:*/getDerived().getBaseLocation()); 5325 return getSema().ActOnDependentTemplateName( 5326 /*FIXME:*/getDerived().getBaseLocation(), 5327 SS, 5328 Name, 5329 ObjectType.getAsOpaquePtr()) 5330 .template getAsVal<TemplateName>(); 5331} 5332 5333template<typename Derived> 5334TemplateName 5335TreeTransform<Derived>::RebuildTemplateName(NestedNameSpecifier *Qualifier, 5336 OverloadedOperatorKind Operator, 5337 QualType ObjectType) { 5338 CXXScopeSpec SS; 5339 SS.setRange(SourceRange(getDerived().getBaseLocation())); 5340 SS.setScopeRep(Qualifier); 5341 UnqualifiedId Name; 5342 SourceLocation SymbolLocations[3]; // FIXME: Bogus location information. 5343 Name.setOperatorFunctionId(/*FIXME:*/getDerived().getBaseLocation(), 5344 Operator, SymbolLocations); 5345 return getSema().ActOnDependentTemplateName( 5346 /*FIXME:*/getDerived().getBaseLocation(), 5347 SS, 5348 Name, 5349 ObjectType.getAsOpaquePtr()) 5350 .template getAsVal<TemplateName>(); 5351} 5352 5353template<typename Derived> 5354Sema::OwningExprResult 5355TreeTransform<Derived>::RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op, 5356 SourceLocation OpLoc, 5357 ExprArg Callee, 5358 ExprArg First, 5359 ExprArg Second) { 5360 Expr *FirstExpr = (Expr *)First.get(); 5361 Expr *SecondExpr = (Expr *)Second.get(); 5362 DeclRefExpr *DRE 5363 = cast<DeclRefExpr>(((Expr *)Callee.get())->IgnoreParenCasts()); 5364 bool isPostIncDec = SecondExpr && (Op == OO_PlusPlus || Op == OO_MinusMinus); 5365 5366 // Determine whether this should be a builtin operation. 5367 if (Op == OO_Subscript) { 5368 if (!FirstExpr->getType()->isOverloadableType() && 5369 !SecondExpr->getType()->isOverloadableType()) 5370 return getSema().CreateBuiltinArraySubscriptExpr(move(First), 5371 DRE->getLocStart(), 5372 move(Second), OpLoc); 5373 } else if (SecondExpr == 0 || isPostIncDec) { 5374 if (!FirstExpr->getType()->isOverloadableType()) { 5375 // The argument is not of overloadable type, so try to create a 5376 // built-in unary operation. 5377 UnaryOperator::Opcode Opc 5378 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5379 5380 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, move(First)); 5381 } 5382 } else { 5383 if (!FirstExpr->getType()->isOverloadableType() && 5384 !SecondExpr->getType()->isOverloadableType()) { 5385 // Neither of the arguments is an overloadable type, so try to 5386 // create a built-in binary operation. 5387 BinaryOperator::Opcode Opc = BinaryOperator::getOverloadedOpcode(Op); 5388 OwningExprResult Result 5389 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, FirstExpr, SecondExpr); 5390 if (Result.isInvalid()) 5391 return SemaRef.ExprError(); 5392 5393 First.release(); 5394 Second.release(); 5395 return move(Result); 5396 } 5397 } 5398 5399 // Compute the transformed set of functions (and function templates) to be 5400 // used during overload resolution. 5401 Sema::FunctionSet Functions; 5402 5403 // FIXME: Do we have to check 5404 // IsAcceptableNonMemberOperatorCandidate for each of these? 5405 for (OverloadIterator F(DRE->getDecl()), FEnd; F != FEnd; ++F) 5406 Functions.insert(*F); 5407 5408 // Add any functions found via argument-dependent lookup. 5409 Expr *Args[2] = { FirstExpr, SecondExpr }; 5410 unsigned NumArgs = 1 + (SecondExpr != 0); 5411 DeclarationName OpName 5412 = SemaRef.Context.DeclarationNames.getCXXOperatorName(Op); 5413 SemaRef.ArgumentDependentLookup(OpName, /*Operator*/true, Args, NumArgs, 5414 Functions); 5415 5416 // Create the overloaded operator invocation for unary operators. 5417 if (NumArgs == 1 || isPostIncDec) { 5418 UnaryOperator::Opcode Opc 5419 = UnaryOperator::getOverloadedOpcode(Op, isPostIncDec); 5420 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(First)); 5421 } 5422 5423 if (Op == OO_Subscript) 5424 return SemaRef.CreateOverloadedArraySubscriptExpr(DRE->getLocStart(), OpLoc, 5425 move(First),move(Second)); 5426 5427 // Create the overloaded operator invocation for binary operators. 5428 BinaryOperator::Opcode Opc = 5429 BinaryOperator::getOverloadedOpcode(Op); 5430 OwningExprResult Result 5431 = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]); 5432 if (Result.isInvalid()) 5433 return SemaRef.ExprError(); 5434 5435 First.release(); 5436 Second.release(); 5437 return move(Result); 5438} 5439 5440} // end namespace clang 5441 5442#endif // LLVM_CLANG_SEMA_TREETRANSFORM_H 5443