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