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