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